| Modifier and Type | Class and Description |
|---|---|
class |
AuthUtil
Utility methods for helping with security tasks.
|
class |
BaseConfigurable
HBase version of Hadoop's Configured class that doesn't initialize the
configuration via
BaseConfigurable.setConf(Configuration) in the constructor, but
only sets the configuration through the BaseConfigurable.setConf(Configuration)
method |
class |
CellComparator
Compare two HBase cells.
|
interface |
CellScannable
Implementer can return a CellScanner over its Cell content.
|
interface |
CellScanner
An interface for iterating through a sequence of cells.
|
class |
ChoreService
ChoreService is a service that can be used to schedule instances of
ScheduledChore to run
periodically while sharing threads. |
class |
ClusterId
The identifier for this cluster.
|
class |
CompoundConfiguration
Do a shallow merge of multiple KV configuration pools.
|
class |
CoordinatedStateException
Thrown by operations requiring coordination state access or manipulation
when internal error within coordination engine (or other internal implementation) occurs.
|
interface |
CoordinatedStateManager
Implementations of this interface will keep and return to clients
implementations of classes providing API to execute
coordinated operations.
|
class |
CoordinatedStateManagerFactory
Creates instance of
CoordinatedStateManager
based on configuration. |
interface |
CoprocessorEnvironment
Coprocessor environment state.
|
static class |
HConstants.Modify
modifyTable op for replacing the table descriptor
|
static class |
HConstants.OperationStatusCode
Status codes used for return values of bulk operations.
|
class |
HDFSBlocksDistribution
Data structure to describe the distribution of HDFS blocks among hosts.
|
interface |
InterProcessLock
An interface for an application-specific lock.
|
interface |
InterProcessReadWriteLock
An interface for a distributed reader-writer lock.
|
class |
KeyValue
An HBase Key/Value.
|
class |
KeyValueTestUtil |
class |
KeyValueUtil
static convenience methods for dealing with KeyValues and collections of KeyValues
|
interface |
MetaMutationAnnotation
The field or the parameter to which this annotation can be applied only when it
holds mutations for hbase:meta table.
|
class |
MetaTableAccessor
Read/write operations on region and assignment information store in
hbase:meta. |
class |
NoTagsKeyValue
An extension of the KeyValue where the tags length is always 0
|
class |
RegionLocations
Container for holding a list of
HRegionLocation's that correspond to the
same range. |
class |
RegionTransition
Current state of a region in transition.
|
class |
RemoteExceptionHandler
An immutable class which contains a static method for handling
org.apache.hadoop.ipc.RemoteException exceptions.
|
class |
ScheduledChore
ScheduledChore is a task performed on a period in hbase.
|
class |
SplitLogCounters
Counters kept by the distributed WAL split log process.
|
class |
SplitLogTask
State of a WAL log split during distributed splitting.
|
interface |
TableDescriptors
Get, remove and modify table descriptors.
|
interface |
TableStateManager
Helper class for table state management for operations running inside
RegionServer or HMaster.
|
class |
Tag
Tags are part of cells and helps to add metadata about the KVs.
|
class |
TagRewriteCell
This can be used when a Cell has to change with addition/removal of one or more tags.
|
class |
TagType |
class |
Version |
class |
YouAreDeadException
This exception is thrown by the master when a region server reports and is
already being processed as dead.
|
class |
ZKNamespaceManager
Class servers two purposes:
1.
|
| Modifier and Type | Method and Description |
|---|---|
static ProcedureInfo |
ProcedureInfo.convert(ProcedureProtos.Procedure procProto)
Helper to convert the protobuf object.
|
static ProcedureProtos.Procedure |
ProcedureInfo.convertToProcedureProto(ProcedureInfo procInfo) |
long |
ProcedureInfo.getClientAckTime() |
ErrorHandlingProtos.ForeignExceptionMessage |
ProcedureInfo.getForeignExceptionMessage() |
Map<String,RegionState> |
ClusterStatus.getRegionsInTransition() |
KeyValue.KVComparator |
TableName.getRowComparator()
Deprecated.
The comparator is an internal property of the table. Should
not have been exposed here
|
boolean |
ProcedureInfo.hasClientAckTime() |
static boolean |
ProcedureInfo.isProcedureOwner(ProcedureInfo procInfo,
User user)
Check if the user is this procedure's owner
|
void |
ProcedureInfo.setClientAckTime(long timestamp) |
| Constructor and Description |
|---|
HTableDescriptor(TableName name,
HColumnDescriptor[] families)
INTERNAL Private constructor used internally creating table descriptors for
catalog tables,
hbase:meta and -ROOT-. |
ProcedureInfo(long procId,
String procName,
String procOwner,
ProcedureProtos.ProcedureState procState,
long parentId,
NonceKey nonceKey,
ErrorHandlingProtos.ForeignExceptionMessage exception,
long lastUpdate,
long startTime,
byte[] result) |
| Modifier and Type | Class and Description |
|---|---|
class |
TableHFileArchiveTracker
Track HFile archiving state changes in ZooKeeper.
|
class |
ZKTableArchiveClient
Example class for how to use the table archiving coordinated via zookeeper
|
| Modifier and Type | Class and Description |
|---|---|
class |
ExcludePrivateAnnotationsStandardDoclet
A Doclet
for excluding elements that are annotated with
InterfaceAudience.Private or
InterfaceAudience.LimitedPrivate. |
class |
IncludePublicAnnotationsStandardDoclet
A Doclet
that only includes class-level elements that are annotated with
InterfaceAudience.Public. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractClientScanner
Helper class for custom client scanners.
|
class |
Action<R>
A Get, Put, Increment, Append, or Delete associated with it's region.
|
class |
BufferedMutatorImpl
Used to communicate with a single HBase table similar to
HTable
but meant for batched, potentially asynchronous puts. |
class |
ClientScanner
Implements the scanner interface for the HBase client.
|
class |
ClientSideRegionScanner
A client scanner for a region opened for read-only on the client side.
|
class |
ClientSmallReversedScanner
Client scanner for small reversed scan.
|
class |
ClientSmallScanner
Client scanner for small scan.
|
protected static class |
ClientSmallScanner.SmallScannerCallableFactory |
interface |
ClusterConnection
Internal methods on Connection that should not be used by user code.
|
class |
ConnectionConfiguration
Configuration parameters for the connection.
|
class |
ConnectionUtils
Utility used by client connections.
|
class |
CoprocessorHConnection
Connection to an HTable from within a Coprocessor.
|
class |
DelayingRunner<T>
A wrapper for a runnable for a group of actions for a single regionserver.
|
class |
DelegatingRetryingCallable<T,D extends RetryingCallable<T>>
Helper callable for internal use when you just want to override a single method of a
RetryingCallable. |
class |
FlushRegionCallable
A Callable for flushRegion() RPC.
|
class |
HBaseAdmin
HBaseAdmin is no longer a client API.
|
protected static class |
HBaseAdmin.ProcedureFuture<V>
Future that waits on a procedure result.
|
class |
HConnectable<T>
This class makes it convenient for one to execute a command in the context
of a
HConnection instance based on the given Configuration. |
class |
HRegionLocator
An implementation of
RegionLocator. |
class |
HTable
An implementation of
Table. |
interface |
HTableInterface
Deprecated.
use
Table instead |
class |
HTablePool
Deprecated.
as of 0.98.1. See
HConnection.getTable(String). |
class |
HTableUtil
Deprecated.
since 1.0
|
class |
MetaCache
A cache implementation for region locations from meta.
|
class |
MetaScanner
Scanner class that contains the
hbase:meta table scanning logic. |
class |
MultiAction<R>
Container for Actions (i.e.
|
class |
MultiResponse
A container for Result objects, grouped by regionName.
|
class |
NeedUnmanagedConnectionException
Used for internal signalling that a Connection implementation needs to be
user-managed to be used for particular request types.
|
interface |
NonceGenerator
NonceGenerator interface.
|
class |
PerClientRandomNonceGenerator
NonceGenerator implementation that uses client ID hash + random int as nonce group,
and random numbers as nonces.
|
class |
RegionAdminServiceCallable<T>
Similar to
RegionServerCallable but for the AdminService interface. |
class |
RegionCoprocessorServiceExec
Represents a coprocessor service method execution against a single region.
|
class |
RegionReplicaUtil
Utility methods which contain the logic for regions and replicas.
|
class |
RegionServerCallable<T>
Implementations call a RegionServer and implement
RetryingCallable.call(int). |
class |
ResultBoundedCompletionService<V>
A completion service for the RpcRetryingCallerFactory.
|
class |
ResultStatsUtil
A
Result with some statistics about the server/region status |
static class |
RetriesExhaustedException.ThrowableWithExtraContext
Datastructure that allows adding more info around Throwable incident.
|
interface |
RetryingCallable<T>
A Callable
|
class |
ReversedClientScanner
A reversed client scanner which support backward scanning
|
class |
ReversedScannerCallable
A reversed ScannerCallable which supports backward scanning.
|
class |
RpcRetryingCaller<T>
Runs an rpc'ing
RetryingCallable. |
class |
RpcRetryingCallerFactory
Factory to create an
RpcRetryingCaller |
class |
RpcRetryingCallerWithReadReplicas
Caller that goes to replica if the primary region does no answer within a configurable
timeout.
|
class |
ScannerCallable
Scanner operations such as create, next, etc.
|
class |
ServerStatisticTracker
Tracks the statistics for multiple regions
|
class |
StatsTrackingRpcRetryingCaller<T>
An
RpcRetryingCaller that will update the per-region stats for the call on return,
if stats are available |
class |
VersionInfoUtil
Class to help with parsing the version info.
|
| Modifier and Type | Method and Description |
|---|---|
void |
Result.addResults(ClientProtos.RegionLoadStats loadStats)
Deprecated.
|
static <T> T |
HConnectionManager.execute(HConnectable<T> connectable)
Deprecated.
Internal method, do not use thru HConnectionManager.
|
static ThreadPoolExecutor |
HTable.getDefaultExecutor(org.apache.hadoop.conf.Configuration conf) |
protected org.apache.hadoop.hbase.client.ScannerCallableWithReplicas |
ClientScanner.getScannerCallable(byte[] localStartKey,
int nbRows) |
static void |
HConnectionManager.setServerSideHConnectionRetries(org.apache.hadoop.conf.Configuration c,
String sn,
org.apache.commons.logging.Log log)
Deprecated.
Internal method, do not use.
|
void |
Result.setStatistics(ClientProtos.RegionLoadStats loadStats)
Set load information about the region to the information about the result
|
| Constructor and Description |
|---|
HTable(TableName tableName,
ClusterConnection connection,
ConnectionConfiguration tableConfig,
RpcRetryingCallerFactory rpcCallerFactory,
RpcControllerFactory rpcControllerFactory,
ExecutorService pool)
Creates an object to access a HBase table.
|
RetriesExhaustedException(int numTries,
List<RetriesExhaustedException.ThrowableWithExtraContext> exceptions)
Create a new RetriesExhaustedException from the list of prior failures.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ClientBackoffPolicyFactory |
class |
ServerStatistics
Track the statistics for a single region
|
| Modifier and Type | Method and Description |
|---|---|
ServerStatistics.RegionStatistics |
ServerStatistics.getStatsForRegion(byte[] regionName) |
| Modifier and Type | Class and Description |
|---|---|
class |
AggregationClient
This client class is for invoking the aggregate functions deployed on the
Region Server side via the AggregateService.
|
class |
BigDecimalColumnInterpreter
ColumnInterpreter for doing Aggregation's with BigDecimal columns.
|
class |
LongColumnInterpreter
a concrete column interpreter implementation.
|
class |
SecureBulkLoadClient
Client proxy for SecureBulkLoadProtocol
used in conjunction with SecureBulkLoadEndpoint
|
| Modifier and Type | Class and Description |
|---|---|
class |
CodecException
Thrown when problems in the codec whether setup or context.
|
| Modifier and Type | Class and Description |
|---|---|
class |
PrefixTreeBlockMeta
Information about the block.
|
class |
PrefixTreeCodec
This class is created via reflection in DataBlockEncoding enum.
|
class |
PrefixTreeSeeker
These methods have the same definition as any implementation of the EncodedSeeker.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ArraySearcherPool
Pools PrefixTreeArraySearcher objects.
|
class |
DecoderFactory
Static wrapper class for the ArraySearcherPool.
|
class |
PrefixTreeArrayReversibleScanner
Methods for going backwards through a PrefixTree block.
|
class |
PrefixTreeArrayScanner
Extends PtCell and manipulates its protected fields.
|
class |
PrefixTreeArraySearcher
Searcher extends the capabilities of the Scanner + ReversibleScanner to add the ability to
position itself on a requested Cell without scanning through cells before it.
|
class |
PrefixTreeCell
As the PrefixTreeArrayScanner moves through the tree bytes, it changes the values in the fields
of this class so that Cell logic can be applied, but without allocating new memory for every Cell
iterated through.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ColumnNodeReader |
class |
ColumnReader
Position one of these appropriately in the data block and you can call its methods to retrieve
the family or qualifier at the current position.
|
| Modifier and Type | Class and Description |
|---|---|
class |
RowNodeReader
Position one of these appropriately in the data block and you can call its methods to retrieve
information necessary to decode the cells in the row.
|
| Modifier and Type | Class and Description |
|---|---|
class |
MvccVersionDecoder
Given a block and its blockMeta, this will decode the MvccVersion for the i-th Cell in the block.
|
class |
TimestampDecoder
Given a block and its blockMeta, this will decode the timestamp for the i-th Cell in the block.
|
| Modifier and Type | Class and Description |
|---|---|
class |
EncoderFactory
Retrieve PrefixTreeEncoders from this factory which handles pooling them and preparing the
ones retrieved from the pool for usage.
|
interface |
EncoderPool |
class |
EncoderPoolImpl |
class |
PrefixTreeEncoder
This is the primary class for converting a CellOutputStream into an encoded byte[].
|
| Modifier and Type | Class and Description |
|---|---|
class |
ColumnNodeWriter
Column nodes can be either family nodes or qualifier nodes, as both sections encode similarly.
|
class |
ColumnSectionWriter
Takes the tokenized family or qualifier data and flattens it into a stream of bytes.
|
| Modifier and Type | Class and Description |
|---|---|
class |
CellTypeEncoder
Detect if every KV has the same KeyValue.Type, in which case we don't need to store it for each
KV.
|
class |
ColumnNodeType
Specifies the type of columnnode writer.
|
class |
LongEncoder
Used to de-duplicate, sort, minimize/diff, and serialize timestamps and mvccVersions from a
collection of Cells.
|
| Modifier and Type | Class and Description |
|---|---|
class |
RowNodeWriter
Serializes the fields comprising one node of the row trie, which can be a branch, nub, or leaf.
|
class |
RowSectionWriter
Most of the complexity of the PrefixTree is contained in the "row section".
|
| Modifier and Type | Class and Description |
|---|---|
class |
TokenDepthComparator
Determines order of nodes in the output array.
|
class |
Tokenizer
Data structure used in the first stage of PrefixTree encoding:
accepts a sorted stream of ByteRanges
splits them into a set of tokens, each held by a
TokenizerNode
connects the TokenizerNodes via standard java references
keeps a pool of TokenizerNodes and a reusable byte[] for holding all token content |
class |
TokenizerNode
Individual node in a Trie structure.
|
class |
TokenizerRowSearchPosition
Warning: currently unused, but code is valid.
|
class |
TokenizerRowSearchResult
for recursively searching a PtBuilder
|
| Modifier and Type | Class and Description |
|---|---|
class |
CellScannerPosition
An indicator of the state of the scanner after an operation such as nextCell() or
positionAt(..).
|
interface |
CellSearcher
Methods for seeking to a random
Cell inside a sorted collection of cells. |
interface |
ReversibleCellScanner
An extension of CellScanner indicating the scanner supports iterating backwards through cells.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ConfigurationManager
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.
|
interface |
ConfigurationObserver
Every class that wants to observe changes in Configuration properties,
must implement interface (and also, register itself with the
ConfigurationManager object. |
interface |
PropagatingConfigurationObserver
This extension to ConfigurationObserver allows the configuration to propagate to the children of
the current
ConfigurationObserver. |
| Modifier and Type | Class and Description |
|---|---|
class |
BaseConstraint
Base class to use when actually implementing a
Constraint. |
interface |
Constraint
Apply a
Constraint (in traditional database terminology) to a HTable. |
class |
ConstraintException
Exception that a user defined constraint throws on failure of a
Put. |
class |
ConstraintProcessor
Processes multiple
Constraints on a given table. |
class |
Constraints
Utilities for adding/removing constraints from a table.
|
| Modifier and Type | Class and Description |
|---|---|
class |
BaseCoordinatedStateManager
Base class for
CoordinatedStateManager implementations. |
interface |
CloseRegionCoordination
Coordinated operations for close region handlers.
|
interface |
OpenRegionCoordination
Cocoordination operations for opening regions.
|
interface |
RegionMergeCoordination
Coordination operations for region merge transaction.
|
interface |
SplitLogManagerCoordination
Coordination for SplitLogManager.
|
interface |
SplitLogWorkerCoordination
Coordinated operations for
SplitLogWorker and
org.apache.hadoop.hbase.regionserver.handler.HLogSplitterHandler Important
methods for SplitLogWorker: SplitLogWorkerCoordination.isReady() called from SplitLogWorker.run() to check whether the coordination is
ready to supply the tasks SplitLogWorkerCoordination.taskLoop() loop for new tasks until the worker is stopped SplitLogWorkerCoordination.isStop() a flag indicates whether worker should finish SplitLogWorkerCoordination.registerListener() called from SplitLogWorker.run() and could register listener
for external changes in coordination (if required) SplitLogWorkerCoordination.endTask(SplitLogTask, AtomicLong, SplitTaskDetails) notify coordination engine that |
interface |
SplitTransactionCoordination
Coordination operations for split transaction.
|
class |
ZkCloseRegionCoordination
ZK-based implementation of
CloseRegionCoordination. |
class |
ZkOpenRegionCoordination
ZK-based implementation of
OpenRegionCoordination. |
class |
ZKSplitLogManagerCoordination
ZooKeeper based implementation of
org.apache.hadoop.hbase.master.SplitLogManagerCoordination |
class |
ZkSplitLogWorkerCoordination
ZooKeeper based implementation of
SplitLogWorkerCoordination
It listen for changes in ZooKeeper and |
| Modifier and Type | Class and Description |
|---|---|
class |
AggregateImplementation<T,S,P extends com.google.protobuf.Message,Q extends com.google.protobuf.Message,R extends com.google.protobuf.Message>
A concrete AggregateProtocol implementation.
|
class |
ColumnInterpreter<T,S,P extends com.google.protobuf.Message,Q extends com.google.protobuf.Message,R extends com.google.protobuf.Message>
Defines how value for specific column is interpreted and provides utility
methods like compare, add, multiply etc for them.
|
| Modifier and Type | Method and Description |
|---|---|
protected void |
CoprocessorHost.legacyWarning(Class<? extends Coprocessor> clazz,
String message)
limits the amount of logging to once per coprocessor class.
|
protected static boolean |
CoprocessorHost.useLegacyMethod(Class<? extends Coprocessor> clazz,
String methodName,
Class<?>... parameterTypes)
Used to gracefully handle fallback to deprecated methods when we
evolve coprocessor APIs.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ForeignExceptionDispatcher
The dispatcher acts as the state holding entity for foreign error handling.
|
interface |
ForeignExceptionListener
The ForeignExceptionListener is an interface for objects that can receive a ForeignException.
|
interface |
ForeignExceptionSnare
This is an interface for a cooperative exception throwing mechanism.
|
class |
TimeoutExceptionInjector
Time a given process/operation and report a failure if the elapsed time exceeds the max allowed
time.
|
| Modifier and Type | Class and Description |
|---|---|
class |
DeserializationException
Failed deserialization.
|
class |
HBaseException
Base checked exception in HBase.
|
class |
IllegalArgumentIOException
Exception thrown when an illegal argument is passed to a function/procedure.
|
class |
OutOfOrderScannerNextException
Thrown by a RegionServer while doing next() calls on a ResultScanner.
|
class |
RegionMovedException
Subclass if the server knows the region is now on another server.
|
class |
RegionOpeningException
Subclass if the server knows the region is now on another server.
|
class |
TimeoutIOException
Exception thrown when a blocking operation times out.
|
| Modifier and Type | Class and Description |
|---|---|
class |
EventHandler
Abstract base class for all HBase event handlers.
|
class |
EventType
List of all HBase event handler types.
|
class |
ExecutorService
This is a generic executor service.
|
class |
ExecutorType
The following is a list of all executor types, both those that run in the
master and those that run in the regionserver.
|
| Modifier and Type | Class and Description |
|---|---|
class |
FilterBase
Abstract base class to help you implement new Filters.
|
class |
FilterWrapper
This is a Filter wrapper class which is used in the server side.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AdminAuthorizedServlet
General servlet which is admin-authorized.
|
class |
HttpConfig
Statics to get access to Http related configuration.
|
class |
HttpServer
Create a Jetty embedded server to answer http requests.
|
class |
InfoServer
Create a Jetty embedded server to answer http requests.
|
interface |
ServerConfigurationKeys
This interface contains constants for configuration keys used
in the hbase http server code.
|
| Modifier and Type | Method and Description |
|---|---|
static org.mortbay.jetty.Connector |
HttpServer.createDefaultChannelConnector() |
| Modifier and Type | Class and Description |
|---|---|
class |
BoundedByteBufferPool
Like Hadoops' ByteBufferPool only you do not specify desired size when getting a ByteBuffer.
|
class |
ByteBufferInputStream
Not thread safe!
|
interface |
CellOutputStream
Accepts a stream of Cells.
|
class |
DataOutputOutputStream
OutputStream implementation that wraps a DataOutput.
|
class |
FileLink
The FileLink is a sort of hardlink, that allows access to a file given a set of locations.
|
class |
HalfStoreFileReader
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. |
interface |
HeapSize
Implementations can be asked for an estimate of their size in bytes.
|
class |
HFileLink
HFileLink describes a link to an hfile.
|
class |
LimitInputStream
Copied from guava source code v15 (LimitedInputStream)
Guava deprecated LimitInputStream in v14 and removed it in v15.
|
class |
Reference
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.
|
interface |
SizedCellScanner
A CellScanner that knows its size in memory in bytes.
|
class |
TagCompressionContext
Context that holds the dictionary for Tag compression and doing the compress/uncompress.
|
class |
WALLink
WALLink describes a link to a WAL.
|
interface |
WritableWithSize
An optional interface to 'size' writables.
|
| Modifier and Type | Class and Description |
|---|---|
class |
Compression
Compression related stuff.
|
class |
ReusableStreamGzipCodec
Fixes an inefficiency in Hadoop's Gzip codec, allowing to reuse compression
streams.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AES
AES-128, provided by the JCE
|
class |
AESDecryptor |
class |
AESEncryptor |
| Modifier and Type | Class and Description |
|---|---|
class |
CopyKeyDataBlockEncoder
Just copy data, do not do any kind of compression.
|
interface |
DataBlockEncoder
Encoding of KeyValue.
|
class |
DiffKeyDeltaEncoder
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
- ...
|
class |
EncodedDataBlock
Encapsulates a data block compressed using a particular encoding algorithm.
|
class |
EncoderBufferTooSmallException
Internal error which indicates a bug in a data block encoding algorithm.
|
class |
EncodingState
Keeps track of the encoding state.
|
class |
FastDiffDeltaEncoder
Encoder similar to
DiffKeyDeltaEncoder but supposedly faster. |
interface |
HFileBlockDecodingContext
A decoding context that is created by a reader's encoder, and is shared
across the reader's all read operations.
|
class |
HFileBlockDefaultDecodingContext
A default implementation of
HFileBlockDecodingContext. |
class |
HFileBlockDefaultEncodingContext
A default implementation of
HFileBlockEncodingContext. |
interface |
HFileBlockEncodingContext
An encoding context that is created by a writer's encoder, and is shared
across the writer's whole lifetime.
|
class |
PrefixKeyDeltaEncoder
Compress key by storing size of common prefix with previous KeyValue
and storing raw size of rest.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ThrottledInputStream
The ThrottleInputStream provides bandwidth throttling on a specified
InputStream.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractHFileReader
Common functionality needed by all versions of
HFile readers. |
class |
AbstractHFileWriter
Common functionality needed by all versions of
HFile writers. |
interface |
BlockCache
Block cache interface.
|
class |
BlockCacheKey
Cache Key for use with implementations of
BlockCache |
class |
BlockCacheUtil
Utilty for aggregating counts in CachedBlocks and toString/toJSON CachedBlocks and BlockCaches.
|
class |
BlockType
Various types of HFile blocks.
|
interface |
Cacheable
Cacheable is an interface that allows for an object to be cached.
|
interface |
CacheableDeserializer<T extends Cacheable>
Interface for a deserializer.
|
class |
CacheableDeserializerIdManager
This class is used to manage the identifiers for
CacheableDeserializer |
class |
CacheConfig
Stores all of the cache objects and configuration for a single HFile.
|
interface |
CachedBlock |
class |
CacheStats
Class that implements cache metrics.
|
class |
ChecksumUtil
Utility methods to compute and validate checksums.
|
class |
CombinedBlockCache
CombinedBlockCache is an abstraction layer that combines
LruBlockCache and BucketCache. |
class |
CorruptHFileException
This exception is thrown when attempts to read an HFile fail due to corruption or truncation
issues.
|
class |
FixedFileTrailer
The
HFile has a fixed trailer which contains offsets to other
variable parts of the file. |
class |
HFile
File format for hbase.
|
class |
HFileBlock
Reading
HFile version 1 and 2 blocks, and writing version 2 blocks. |
class |
HFileBlockIndex
Provides functionality to write (
HFileBlockIndex.BlockIndexWriter) and read
(HFileBlockIndex.BlockIndexReader) single-level and multi-level block indexes. |
class |
HFileContext
This carries the information on some of the meta data about the HFile.
|
class |
HFileContextBuilder
A builder that helps in building up the HFileContext
|
interface |
HFileDataBlockEncoder
Controls what kind of data block encoding is used.
|
class |
HFileDataBlockEncoderImpl
Do different kinds of data block encoding according to column family
options.
|
class |
HFileReaderV2
HFile reader for version 2. |
class |
HFileReaderV3
HFile reader for version 3. |
interface |
HFileScanner
A scanner allows you to position yourself within a HFile and
scan through it.
|
class |
HFileWriterV2
Writes HFile format version 2.
|
class |
HFileWriterV3
HFile writer for version 3. |
interface |
InlineBlockWriter
A way to write "inline" blocks into an
HFile. |
class |
InvalidHFileException
Thrown when an invalid HFile format is detected
|
class |
LruBlockCache
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, boolean) and LruBlockCache.getBlock(org.apache.hadoop.hbase.io.hfile.BlockCacheKey, boolean, boolean, boolean) operations. |
class |
LruCachedBlock
Represents an entry in the
LruBlockCache. |
class |
LruCachedBlockQueue
A memory-bound queue that will grow until an element brings
total size >= maxSize.
|
class |
MemcachedBlockCache
Class to store blocks into memcached.
|
class |
NoOpDataBlockEncoder
Does not perform any kind of encoding/decoding.
|
interface |
ResizableBlockCache
BlockCache which is resizable.
|
| Modifier and Type | Class and Description |
|---|---|
class |
BucketAllocator
This class is used to allocate a block with specified size and free the block
when evicting.
|
class |
BucketAllocatorException
Thrown by
BucketAllocator |
class |
BucketCache
BucketCache 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. |
class |
BucketCacheStats
Class that implements cache metrics for bucket cache.
|
class |
ByteBufferIOEngine
IO engine that stores data in memory using an array of ByteBuffers
ByteBufferArray |
class |
CachedEntryQueue
A memory-bound queue that will grow until an element brings total size larger
than maxSize.
|
class |
CacheFullException
Thrown by
BucketAllocator.allocateBlock(int) when cache is full for
the requested size |
class |
FileIOEngine
IO engine that stores data to a file on the local file system.
|
interface |
IOEngine
A class implementing IOEngine interface supports data services for
BucketCache. |
class |
UniqueIndexMap<T>
Map from type T to int and vice-versa.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
Dictionary
Dictionary interface
Dictionary indexes should be either bytes or shorts, only positive.
|
class |
HeapMemorySizeUtil |
class |
LRUDictionary
WALDictionary using an LRU eviction algorithm.
|
class |
StreamUtils |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractRpcClient
Provides the basics for a RpcClient implementation like configuration and Logging.
|
class |
AsyncCall
Represents an Async Hbase call and its response.
|
class |
AsyncRpcChannel
Netty RPC channel
|
class |
AsyncServerResponseHandler
Handles Hbase responses
|
class |
BlockingRpcCallback<R>
Simple
RpcCallback implementation providing a
Future-like BlockingRpcCallback.get() method, which
will block util the instance's BlockingRpcCallback.run(Object) method has been called. |
class |
Call
A call waiting for a value.
|
class |
ConnectionId
This class holds the address and the user ticket, etc.
|
interface |
Delayable
A call whose response can be delayed by the server.
|
class |
DelegatingPayloadCarryingRpcController
Simple delegating controller for use with the
RpcControllerFactory to help override
standard behavior of a PayloadCarryingRpcController. |
class |
FailedServers
A class to manage a list of servers that failed recently.
|
interface |
HBaseRPCErrorHandler
An interface for calling out of RPC for error conditions.
|
class |
IPCUtil
Utility to help ipc'ing.
|
class |
MasterCoprocessorRpcChannel
Provides clients with an RPC connection to call coprocessor endpoint
Services
against the active master. |
class |
MetricsHBaseServer |
class |
MetricsHBaseServerSourceFactoryImpl |
class |
MetricsHBaseServerSourceImpl |
class |
PayloadCarryingRpcController
Optionally carries Cells across the proxy/service interface down into ipc.
|
class |
RegionCoprocessorRpcChannel
Provides clients with an RPC connection to call coprocessor endpoint
Services
against a given table region. |
class |
RegionServerCoprocessorRpcChannel
Provides clients with an RPC connection to call coprocessor endpoint
Services against a given region server. |
interface |
RpcClient
Interface for RpcClient implementations so ConnectionManager can handle it.
|
class |
RpcClientFactory
Factory to create a
RpcClient |
class |
RpcClientImpl
Does RPC against a cluster.
|
class |
RpcControllerFactory
Factory to create a
PayloadCarryingRpcController |
class |
RpcExecutor |
class |
ServerRpcController
Used for server-side protobuf RPC service invocations.
|
class |
TimeLimitedRpcController |
| Modifier and Type | Method and Description |
|---|---|
com.google.protobuf.Message |
CoprocessorRpcChannel.callBlockingMethod(com.google.protobuf.Descriptors.MethodDescriptor method,
com.google.protobuf.RpcController controller,
com.google.protobuf.Message request,
com.google.protobuf.Message responsePrototype) |
void |
CoprocessorRpcChannel.callMethod(com.google.protobuf.Descriptors.MethodDescriptor method,
com.google.protobuf.RpcController controller,
com.google.protobuf.Message request,
com.google.protobuf.Message responsePrototype,
com.google.protobuf.RpcCallback<com.google.protobuf.Message> callback) |
| Modifier and Type | Class and Description |
|---|---|
class |
DefaultVisibilityExpressionResolver
This implementation creates tags by expanding expression using label ordinal.
|
class |
JobUtil
Utility methods to interact with a job.
|
class |
TableSnapshotInputFormatImpl
Hadoop MR API-agnostic implementation for mapreduce over table snapshots.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ActiveMasterManager
Handles everything on master-side related to master election.
|
class |
AssignCallable
A callable object that invokes the corresponding action that needs to be
taken for assignment of a region in transition.
|
interface |
AssignmentListener
Get notification of assignment events.
|
class |
AssignmentManager
Manages and performs region assignment.
|
class |
AssignmentVerificationReport
Helper class that is used by
RegionPlacementMaintainer to print
information for favored nodes |
class |
BulkAssigner
Base class used bulk assigning and unassigning regions.
|
class |
BulkReOpen
Performs bulk reopen of the list of regions provided to it.
|
class |
CatalogJanitor
A janitor for the catalog tables.
|
class |
ClusterStatusPublisher
Class to publish the cluster status to the client.
|
class |
DeadServer
Class to hold dead servers list and utility querying dead server list.
|
class |
GeneralBulkAssigner
Run bulk assign.
|
class |
HMasterCommandLine |
interface |
LoadBalancer
Makes decisions about the placement and movement of Regions across
RegionServers.
|
class |
MasterCoprocessorHost
Provides the coprocessor framework and environment for master oriented
operations.
|
class |
MasterDumpServlet |
class |
MasterFileSystem
This class abstracts a bunch of operations the HMaster needs to interact with
the underlying file system, including splitting log files, checking file
system status, etc.
|
class |
MasterRpcServices
Implements the master RPC services.
|
interface |
MasterServices
Services Master supplies
|
class |
MasterStatusServlet
The servlet responsible for rendering the index page of the
master.
|
class |
MetricsAssignmentManagerSourceImpl |
class |
MetricsMaster
This class is for maintaining the various master statistics
and publishing them through the metrics interfaces.
|
class |
MetricsMasterFilesystemSourceImpl |
class |
MetricsMasterSourceFactoryImpl
Factory to create MetricsMasterSource when given a MetricsMasterWrapper
|
class |
MetricsMasterSourceImpl
Hadoop2 implementation of MetricsMasterSource.
|
class |
MetricsMasterWrapperImpl
Impl for exposing HMaster Information through JMX
|
class |
MetricsSnapshotSourceImpl |
class |
OfflineCallback
Callback handler for creating unassigned offline znodes
used during bulk assign, async setting region to offline.
|
class |
RackManager
Wrapper over the rack resolution utility in Hadoop.
|
class |
RegionPlacementMaintainer
A tool that is used for manipulating and viewing favored nodes information
for regions.
|
class |
RegionState
State of a Region while undergoing transitions.
|
static class |
RegionState.State |
class |
RegionStates
Region state accountant.
|
class |
RegionStateStore
A helper to persist region state in meta.
|
interface |
ServerListener
Get notification of server events.
|
class |
ServerManager
The ServerManager class manages info about region servers.
|
class |
SnapshotOfRegionAssignmentFromMeta
Used internally for reading meta and constructing datastructures that are
then queried, for things like regions to regionservers, table to regions, etc.
|
interface |
SnapshotSentinel
Watch the current snapshot under process
|
class |
SplitLogManager
Distributes the task of log splitting to the available region servers.
|
static class |
SplitLogManager.Task
in memory state of an active task.
|
static class |
SplitLogManager.TaskBatch
Keeps track of the batch of tasks submitted together by a caller in splitLogDistributed().
|
class |
TableLockManager
A manager for distributed table level locks.
|
static class |
TableLockManager.NullTableLockManager
A null implementation
|
static interface |
TableLockManager.TableLock
A distributed lock for a table.
|
class |
TableNamespaceManager
This is a helper class used to manage the namespace
metadata that is stored in TableName.NAMESPACE_TABLE_NAME
It also mirrors updates to the ZK store by forwarding updates to
ZKNamespaceManager |
class |
UnAssignCallable
A callable object that invokes the corresponding action that needs to be
taken for unassignment of a region in transition.
|
| Modifier and Type | Class and Description |
|---|---|
class |
BalancerChore
Chore that will call HMaster.balance
HMaster.balance() when
needed. |
class |
ClusterStatusChore
Chore that will feed the balancer the cluster status.
|
class |
FavoredNodeAssignmentHelper
Helper class for
FavoredNodeLoadBalancer that has all the intelligence
for racks, meta scans, etc. |
class |
FavoredNodesPlan
This class contains the mapping information between each region and
its favored region server list.
|
class |
LoadBalancerFactory
The class that creates a load balancer from a conf.
|
class |
MetricsBalancerSourceImpl |
| Modifier and Type | Class and Description |
|---|---|
class |
BaseHFileCleanerDelegate
Base class for the hfile cleaning function inside the master.
|
class |
BaseLogCleanerDelegate
Base class for the log cleaning function inside the master.
|
interface |
FileCleanerDelegate
General interface for cleaning files from a folder (generally an archive or
backup folder).
|
class |
HFileCleaner
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.
|
class |
LogCleaner
This Chore, every time it runs, will attempt to delete the WALs in the old logs folder.
|
class |
ReplicationZKLockCleanerChore
A cleaner that cleans replication locks on zk which is locked by dead region servers
|
| Modifier and Type | Class and Description |
|---|---|
class |
ClosedRegionHandler
Handles CLOSED region event on Master.
|
class |
CreateTableHandler
Handler to create a table.
|
class |
DeleteTableHandler |
class |
DisableTableHandler
Handler to run disable of a table.
|
class |
DispatchMergingRegionHandler
Handles MERGE regions request on master: move the regions together(on the
same regionserver) and send MERGE RPC to regionserver.
|
class |
EnableTableHandler
Handler to run enable of a table.
|
class |
LogReplayHandler
Handle logReplay work from SSH.
|
class |
MetaServerShutdownHandler
Shutdown handler for the server hosting
hbase:meta |
class |
ModifyTableHandler |
class |
OpenedRegionHandler
Handles OPENED region event on Master.
|
class |
ServerShutdownHandler
Process server shutdown.
|
class |
TableAddFamilyHandler
Handles adding a new family to an existing table.
|
class |
TableDeleteFamilyHandler
Handles Deleting a column family from an existing table.
|
class |
TableEventHandler
Base class for performing operations against tables.
|
class |
TableModifyFamilyHandler
Handles adding a new family to an existing table.
|
interface |
TotesHRegionInfo
Implementors tote an HRegionInfo instance.
|
class |
TruncateTableHandler
Truncate the table by removing META and the HDFS files and recreating it.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AddColumnFamilyProcedure
The procedure to add a column family to an existing table.
|
class |
CreateTableProcedure |
class |
DeleteColumnFamilyProcedure
The procedure to delete a column family from an existing table.
|
class |
DeleteTableProcedure |
class |
DisableTableProcedure |
class |
EnableTableProcedure |
class |
MasterDDLOperationHelper
Helper class for schema change procedures
|
class |
MasterProcedureConstants |
class |
MasterProcedureEnv |
static class |
MasterProcedureEnv.MasterProcedureStoreListener |
static class |
MasterProcedureEnv.WALStoreLeaseRecovery |
class |
MasterProcedureQueue
ProcedureRunnableSet for the Master Procedures.
|
class |
MasterProcedureUtil |
class |
ModifyColumnFamilyProcedure
The procedure to modify a column family from an existing table.
|
class |
ModifyTableProcedure |
class |
ProcedurePrepareLatch
Latch used by the Master to have the prepare() sync behaviour for old
clients, that can only get exceptions in a synchronous way.
|
class |
ProcedureSyncWait
Helper to synchronously wait on conditions.
|
static interface |
ProcedureSyncWait.Predicate<T> |
interface |
TableProcedureInterface
Procedures that operates on a specific Table (e.g.
|
class |
TruncateTableProcedure |
| Modifier and Type | Class and Description |
|---|---|
class |
CloneSnapshotHandler
Handler to Clone a snapshot.
|
class |
DisabledTableSnapshotHandler
Take a snapshot of a disabled table.
|
class |
EnabledTableSnapshotHandler
Handle the master side of taking a snapshot of an online table, regardless of snapshot type.
|
class |
MasterSnapshotVerifier
General snapshot verification on the master.
|
class |
RestoreSnapshotHandler
Handler to Restore a snapshot.
|
class |
SnapshotFileCache
Intelligently keep track of all the files for all the snapshots.
|
class |
TakeSnapshotHandler
A handler for taking snapshots from the master.
|
| Modifier and Type | Class and Description |
|---|---|
class |
BaseSourceImpl
Hadoop 2 implementation of BaseSource (using metrics2 framework).
|
class |
MBeanSourceImpl
Hadoop2 metrics2 implementation of an object that registers MBeans.
|
| Modifier and Type | Class and Description |
|---|---|
class |
LogMonitoring
Utility functions for reading the log4j logs that are
being written by HBase.
|
class |
MemoryBoundedLogMessageBuffer
A size-bounded repository of alerts, which are kept
in a linked list.
|
interface |
MonitoredRPCHandler
A MonitoredTask implementation optimized for use with RPC Handlers
handling frequent, short duration tasks.
|
class |
MonitoredRPCHandlerImpl
A MonitoredTask implementation designed for use with RPC Handlers
handling frequent, short duration tasks.
|
interface |
MonitoredTask |
class |
StateDumpServlet |
class |
TaskMonitor
Singleton which keeps track of tasks going on in this VM.
|
class |
ThreadMonitoring |
| Modifier and Type | Class and Description |
|---|---|
class |
NamespaceAuditor
The Class NamespaceAuditor performs checks to ensure operations like table creation and region
splitting preserve namespace quota.
|
| Modifier and Type | Class and Description |
|---|---|
class |
MasterProcedureManager
A life-cycle management interface for globally barriered procedures on master.
|
class |
Procedure
A globally-barriered distributed procedure.
|
class |
ProcedureCoordinator
This is the master side of a distributed complex procedure execution.
|
interface |
ProcedureCoordinatorRpcs
RPCs for the coordinator to run a barriered procedure with subprocedures executed at
distributed members.
|
class |
ProcedureManager |
class |
ProcedureManagerHost<E extends ProcedureManager>
Provides the common setup framework and runtime services for globally
barriered procedure invocation from HBase services.
|
class |
ProcedureMember
Process to kick off and manage a running
Subprocedure on a member. |
interface |
ProcedureMemberRpcs
This is the notification interface for Procedures that encapsulates message passing from
members to a coordinator.
|
class |
RegionServerProcedureManager
A life-cycle management interface for globally barriered procedures on
region servers.
|
interface |
SubprocedureFactory
Task builder to build instances of a
ProcedureMember's Subprocedures. |
class |
ZKProcedureCoordinatorRpcs
ZooKeeper based
ProcedureCoordinatorRpcs for a ProcedureCoordinator |
class |
ZKProcedureMemberRpcs
ZooKeeper based controller for a procedure member.
|
class |
ZKProcedureUtil
This is a shared ZooKeeper-based znode management utils for distributed procedure.
|
| Modifier and Type | Class and Description |
|---|---|
class |
FlushTableSubprocedure
This flush region implementation uses the distributed procedure framework to flush
table regions.
|
| Modifier and Type | Class and Description |
|---|---|
class |
OnePhaseProcedure<TEnvironment> |
class |
Procedure<TEnvironment>
Base Procedure class responsible to handle the Procedure Metadata
e.g.
|
class |
ProcedureAbortedException
Thrown when a procedure is aborted
|
class |
ProcedureException |
class |
ProcedureExecutor<TEnvironment>
Thread Pool that executes the submitted procedures.
|
class |
ProcedureFairRunQueues<TKey,TQueue extends ProcedureFairRunQueues.FairObject>
This class is a container of queues that allows to select a queue
in a round robin fashion, considering priority of the queue.
|
interface |
ProcedureRunnableSet
Keep track of the runnable procedures
|
class |
ProcedureSimpleRunQueue
Simple runqueue for the procedures
|
class |
ProcedureYieldException |
class |
RemoteProcedureException
A RemoteProcedureException is an exception from another thread or process.
|
class |
SequentialProcedure<TEnvironment>
A SequentialProcedure describes one step in a procedure chain.
|
class |
StateMachineProcedure<TEnvironment,TState>
Procedure described by a series of steps.
|
class |
TwoPhaseProcedure<TEnvironment> |
| Modifier and Type | Method and Description |
|---|---|
protected void |
Procedure.addStackIndex(int index)
Called by the RootProcedureState on procedure execution.
|
protected boolean |
Procedure.childrenCountDown()
Called by the ProcedureExecutor to notify that one of the sub-procedures
has completed.
|
static ProcedureProtos.Procedure |
Procedure.convert(Procedure proc)
Helper to convert the procedure to protobuf.
|
static Procedure |
Procedure.convert(ProcedureProtos.Procedure proto)
Helper to convert the protobuf procedure.
|
static ProcedureInfo |
Procedure.createProcedureInfo(Procedure proc,
NonceKey nonceKey)
Helper to create the ProcedureInfo from Procedure.
|
protected Procedure[] |
Procedure.doExecute(TEnvironment env)
Internal method called by the ProcedureExecutor that starts the
user-level code execute().
|
protected void |
Procedure.doRollback(TEnvironment env)
Internal method called by the ProcedureExecutor that starts the
user-level code rollback().
|
protected static Long |
Procedure.getRootProcedureId(Map<Long,Procedure> procedures,
Procedure proc) |
protected int[] |
Procedure.getStackIndexes() |
protected ProcedureProtos.ProcedureState |
Procedure.getState() |
protected void |
Procedure.incChildrenLatch()
Called by the ProcedureExecutor on procedure-load to restore the latch state
|
protected boolean |
Procedure.removeStackIndex() |
protected void |
Procedure.setChildrenLatch(int numChildren)
Called by the ProcedureExecutor on procedure-load to restore the latch state
|
protected void |
Procedure.setNonceKey(NonceKey nonceKey)
Called by the ProcedureExecutor to set the value to the newly created procedure.
|
void |
Procedure.setOwner(String owner) |
protected void |
Procedure.setParentProcId(long parentProcId)
Called by the ProcedureExecutor to assign the parent to the newly created procedure.
|
protected void |
Procedure.setProcId(long procId)
Called by the ProcedureExecutor to assign the ID to the newly created procedure.
|
protected void |
Procedure.setStackIndexes(List<Integer> stackIndexes)
Called on store load to initialize the Procedure internals after
the creation/deserialization.
|
protected void |
Procedure.setStartTime(long startTime)
Called on store load to initialize the Procedure internals after
the creation/deserialization.
|
protected void |
Procedure.setState(ProcedureProtos.ProcedureState state) |
protected boolean |
Procedure.setTimeoutFailure() |
protected boolean |
Procedure.wasExecuted() |
| Modifier and Type | Interface and Description |
|---|---|
interface |
ProcedureStore
The ProcedureStore is used by the executor to persist the state of each procedure execution.
|
class |
ProcedureStoreTracker
Keeps track of live procedures.
|
| Modifier and Type | Method and Description |
|---|---|
void |
ProcedureStoreTracker.setDeleted(long procId,
boolean isDeleted) |
| Modifier and Type | Class and Description |
|---|---|
class |
CorruptedWALProcedureStoreException
Thrown when a procedure WAL is corrupted
|
class |
ProcedureWALFile
Describes a WAL File
|
class |
ProcedureWALFormat
Helper class that contains the WAL serialization utils.
|
static class |
ProcedureWALFormat.InvalidWALDataException |
class |
ProcedureWALFormatReader
Helper class that loads the procedures stored in a WAL
|
class |
WALProcedureStore
WAL implementation of the ProcedureStore.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ByteSlot
Similar to the ByteArrayOutputStream, with the exception that we can prepend an header.
|
class |
StringUtils |
class |
TimeoutBlockingQueue<E> |
| Modifier and Type | Class and Description |
|---|---|
class |
ProtobufUtil
Protobufs utility.
|
class |
ReplicationProtbufUtil |
class |
RequestConverter
Helper utility to build protocol buffer requests,
or build components for protocol buffer requests.
|
class |
ResponseConverter
Helper utility to build protocol buffer responses,
or retrieve data from protocol buffer responses.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AverageIntervalRateLimiter
This limiter will refill resources at every TimeUnit/resources interval.
|
class |
DefaultOperationQuota |
class |
FixedIntervalRateLimiter
With this limiter resources will be refilled only after a fixed interval of time.
|
class |
InvalidQuotaSettingsException
Generic quota exceeded exception for invalid settings
|
class |
MasterQuotaManager
Master Quota Manager.
|
interface |
OperationQuota
Interface that allows to check the quota available for an operation.
|
class |
QuotaCache
Cache that keeps track of the quota settings for the users and tables that are interacting with
it.
|
interface |
QuotaLimiter
Internal interface used to interact with the user/table quota.
|
class |
QuotaLimiterFactory |
class |
QuotaState
In-Memory state of table or namespace quotas
|
class |
QuotaTableUtil
Helper class to interact with the quota table.
|
class |
QuotaUtil
Helper class to interact with the quota table
|
class |
RateLimiter
Simple rate limiter.
|
class |
RegionServerQuotaManager
Region Server Quota Manager.
|
interface |
RegionStateListener
The listener interface for receiving region state events.
|
class |
TimeBasedLimiter
Simple time based limiter that checks the quota Throttle
|
class |
UserQuotaState
In-Memory state of the user quotas
|
| Modifier and Type | Class and Description |
|---|---|
class |
CellSkipListSet
|
interface |
ChangedReadersObserver
If set of MapFile.Readers in Store change, implementors are notified.
|
class |
ColumnCount
Simple wrapper for a byte buffer and a counter.
|
interface |
ColumnTracker
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.
|
interface |
CompactionRequestor |
class |
CompactSplitThread
Compact region on request and then run split if appropriate
|
class |
DefaultMemStore
The MemStore holds in-memory modifications to the Store.
|
class |
DefaultStoreFlusher
Default implementation of StoreFlusher.
|
interface |
DeleteTracker
This interface is used for the tracking and enforcement of Deletes
during the course of a Get or Scan operation.
|
class |
DelimitedKeyPrefixRegionSplitPolicy
A custom RegionSplitPolicy implementing a SplitPolicy that groups
rows by a prefix of the row-key with a delimiter.
|
class |
ExplicitColumnTracker
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 |
FlushAllStoresPolicy
A
FlushPolicy that always flushes all stores for a given region. |
class |
FlushPolicy
A flush policy determines the stores that need to be flushed when flushing a region.
|
interface |
FlushRequester
Request a flush.
|
interface |
FlushRequestListener
Listener which will get notified regarding flush requests of regions.
|
class |
HeapMemoryManager
Manages tuning of Heap memory using
HeapMemoryTuner. |
interface |
HeapMemoryTuner
Makes the decision regarding proper sizing of the heap memory.
|
class |
HeapMemStoreLAB
A memstore-local allocation buffer.
|
class |
HRegion |
class |
HRegionFileSystem
View to an on-disk Region.
|
class |
HRegionServerCommandLine
Class responsible for parsing the command line and starting the
RegionServer.
|
class |
HStore
A Store holds a column family in a Region.
|
class |
IncreasingToUpperBoundRegionSplitPolicy
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.
|
interface |
InternalScanner
Internal scanners differ from client-side scanners in that they operate on
HStoreKeys and byte[] instead of RowResults.
|
class |
KeyPrefixRegionSplitPolicy
A custom RegionSplitPolicy implementing a SplitPolicy that groups
rows by a prefix of the row-key
This ensures that a region is not split "inside" a prefix of a row key.
|
class |
KeyValueHeap
Implements a heap merge across any number of KeyValueScanners.
|
interface |
KeyValueScanner
Scanner that returns the next KeyValue.
|
interface |
LastSequenceId
Last flushed sequence Ids for the regions and their stores on region server
|
interface |
LeaseListener
LeaseListener is an interface meant to be implemented by users of the Leases
class.
|
class |
Leases
Leases
There are several server classes in HBase that need to track external
clients that occasionally send heartbeats.
|
class |
LogRoller
Runs periodically to determine if the WAL should be rolled.
|
class |
LruHashMap<K extends HeapSize,V extends HeapSize>
The LruHashMap is a memory-aware HashMap with a configurable maximum
memory footprint.
|
interface |
MemStore
The MemStore holds in-memory modifications to the Store.
|
class |
MemStoreChunkPool
A pool of
HeapMemStoreLAB.Chunk instances. |
interface |
MemStoreLAB
A memstore-local allocation buffer.
|
class |
MemStoreSnapshot
Holds details of the snapshot taken on a MemStore.
|
class |
MetricsRegion
This is the glue between the HRegion and whatever hadoop shim layer
is loaded (hbase-hadoop1-compat or hbase-hadoop2-compat).
|
class |
MetricsRegionAggregateSourceImpl |
class |
MetricsRegionServer
This class is for maintaining the various regionserver statistics
and publishing them through the metrics interfaces.
|
class |
MetricsRegionServerSourceFactoryImpl
Factory to create MetricsRegionServerSource when given a MetricsRegionServerWrapper
|
class |
MetricsRegionServerSourceImpl
Hadoop2 implementation of MetricsRegionServerSource.
|
class |
MetricsRegionSourceImpl |
class |
MetricsRegionWrapperImpl |
class |
MiniBatchOperationInProgress<T>
Wraps together the mutations which are applied as a batch to the region and their operation
status and WALEdits.
|
class |
MultiVersionConsistencyControl
Manages the read/write consistency within memstore.
|
class |
NonLazyKeyValueScanner
A "non-lazy" scanner which always does a real seek operation.
|
class |
NonReversedNonLazyKeyValueScanner
A "non-reversed & non-lazy" scanner which does not support backward scanning
and always does a real seek operation.
|
class |
NoOpHeapMemoryTuner
An implementation of HeapMemoryTuner which is not doing any tuning activity but just allows to
continue with old style fixed proportions.
|
class |
OperationStatus
This class stores the Operation status code and the exception message
that occurs in case of failure of operations like put, delete, etc.
|
class |
RegionMergeTransactionImpl |
class |
RegionOpeningState |
class |
RegionServerAccounting
RegionServerAccounting keeps record of some basic real time information about
the Region Server.
|
interface |
ReplicationService
Gateway to Cluster Replication.
|
interface |
ReplicationSinkService
A sink for a replication stream has to expose this service.
|
interface |
ReplicationSourceService
A source for a replication stream has to expose this service.
|
class |
ReversedKeyValueHeap
ReversedKeyValueHeap is used for supporting reversed scanning.
|
class |
RSDumpServlet |
class |
RSRpcServices
Implements the regionserver RPC services.
|
class |
RSStatusServlet |
class |
ScanDeleteTracker
This class is responsible for the tracking and enforcement of Deletes
during the course of a Scan operation.
|
class |
ScanInfo
Immutable information for scans over a store.
|
class |
ScanQueryMatcher
A query matcher that is specifically designed for the scan case.
|
class |
ScanWildcardColumnTracker
Keeps track of the columns for a scan if they are not explicitly specified
|
interface |
SequenceId
Interface which abstracts implementations on log sequenceId assignment
|
class |
ServerNonceManager
Implementation of nonce manager that stores nonces in a hash map and cleans them up after
some time; if nonce group/client ID is supplied, nonces are stored by client ID.
|
class |
ShutdownHook
Manage regionserver shutdown hooks.
|
class |
SplitLogWorker
This worker is spawned in every regionserver, including master.
|
class |
SplitTransactionImpl |
interface |
StoreConfigInformation
A more restricted interface for HStore.
|
class |
StoreEngine<SF extends org.apache.hadoop.hbase.regionserver.StoreFlusher,CP extends CompactionPolicy,C extends Compactor,SFM extends StoreFileManager>
StoreEngine is a factory that can create the objects necessary for HStore to operate.
|
class |
StoreFileInfo
Describe a StoreFile (hfile, reference, link)
|
interface |
StoreFileManager
Manages the store files and basic metadata about that that determines the logical structure
(e.g.
|
class |
StorefileRefresherChore
A chore for refreshing the store files for secondary regions hosted in the region server.
|
class |
StoreScanner
Scanner scans both the memstore and the Store.
|
class |
StoreUtils
Utility functions for region server storage layer.
|
class |
StripeMultiFileWriter
Base class for cell sink that separates the provided cells into multiple files.
|
class |
StripeStoreConfig
Configuration class for stripe store and compactions.
|
class |
StripeStoreFileManager
Stripe implementation of StoreFileManager.
|
class |
StripeStoreFlusher
Stripe implementation of StoreFlusher.
|
class |
TimeRangeTracker
Stores the minimum and maximum timestamp values (both are inclusive).
|
class |
UnexpectedStateException |
| Constructor and Description |
|---|
RegionServerServices.PostOpenDeployContext(Region region,
long masterSystemTime) |
RegionServerServices.RegionStateTransitionContext(RegionServerStatusProtos.RegionStateTransition.TransitionCode code,
long openSeqNum,
long masterSystemTime,
HRegionInfo... hris) |
| Modifier and Type | Class and Description |
|---|---|
class |
CompactionConfiguration
Compaction configuration for a particular instance of HStore.
|
class |
CompactionContext
This class holds all "physical" details necessary to run a compaction,
and abstracts away the details specific to a particular compaction.
|
class |
CompactionPolicy
A compaction policy determines how to select files for compaction,
how to compact them, and how to generate the compacted files.
|
class |
CompactionProgress
This class holds information relevant for tracking the progress of a
compaction.
|
class |
Compactor
A compactor is a compaction algorithm associated a given policy.
|
class |
CurrentHourProvider |
class |
DefaultCompactor
Compact passed set of files.
|
class |
ExploringCompactionPolicy
Class to pick which files if any to compact together.
|
class |
OffPeakHours |
class |
RatioBasedCompactionPolicy
The default algorithm for selecting files for compaction.
|
class |
StripeCompactionPolicy
Stripe store implementation of compaction policy.
|
class |
StripeCompactor
This is the placeholder for stripe compactor.
|
| Modifier and Type | Class and Description |
|---|---|
class |
CloseMetaHandler
Handles closing of the root region on a region server.
|
class |
CloseRegionHandler
Handles closing of a region on a region server.
|
class |
OpenMetaHandler
Handles opening of a meta region on a region server.
|
class |
OpenRegionHandler
Handles opening of a region on a region server.
|
class |
ParallelSeekHandler
Handler to seek storefiles in parallel.
|
class |
RegionReplicaFlushHandler
HBASE-11580: With the async wal approach (HBASE-11568), the edits are not persisted to wal in
secondary region replicas.
|
class |
WALSplitterHandler
Handles log splitting a wal
|
| Modifier and Type | Class and Description |
|---|---|
class |
FlushSnapshotSubprocedure
This online snapshot implementation uses the distributed procedure framework to force a
store flush and then records the hfiles.
|
| Modifier and Type | Class and Description |
|---|---|
class |
Compressor
A set of static functions for running our custom WAL compression/decompression.
|
class |
DamagedWALException
Thrown when a failed append or sync on a WAL.
|
class |
FSHLog
Implementation of
WAL to go against FileSystem; i.e. |
class |
MetricsEditsReplaySourceImpl
Hadoop1 implementation of MetricsMasterSource.
|
class |
MetricsWAL
Class used to push numbers about the WAL into the metrics subsystem.
|
class |
MetricsWALEditsReplay
Class used to push numbers about WAL edits replay into the metrics subsystem.
|
class |
MetricsWALSourceImpl
Class that transitions metrics from MetricsWAL into the metrics subsystem.
|
class |
ReplayHLogKey
An HLogKey specific to WalEdits coming from replay.
|
class |
SecureWALCellCodec
A WALCellCodec that encrypts the WALedits.
|
interface |
WALActionsListener
Get notification of WAL events.
|
class |
WALCoprocessorHost
Implements the coprocessor environment and runtime support for coprocessors
loaded within a
WAL. |
class |
WALEditsReplaySink
This class is responsible for replaying the edits coming from a failed region server.
|
class |
WALUtil
Helper methods to ease Region Server integration with the write ahead log.
|
class |
WriterBase
Context used by our wal dictionary compressor.
|
| Modifier and Type | Field and Description |
|---|---|
static byte[] |
ProtobufLogReader.PB_WAL_COMPLETE_MAGIC |
static byte[] |
ProtobufLogReader.PB_WAL_MAGIC |
| Modifier and Type | Method and Description |
|---|---|
long |
ProtobufLogReader.trailerSize() |
| Modifier and Type | Class and Description |
|---|---|
class |
HBaseReplicationEndpoint
A
BaseReplicationEndpoint for replication endpoints whose
target cluster is an HBase cluster. |
class |
ReplicationFactory
A factory class for instantiating replication objects that deal with replication state.
|
interface |
ReplicationListener
The replication listener interface can be implemented if a class needs to subscribe to events
generated by the ReplicationTracker.
|
class |
ReplicationLoadSink
A HBase ReplicationLoad to present MetricsSink information
|
class |
ReplicationLoadSource
A HBase ReplicationLoad to present MetricsSource information
|
interface |
ReplicationPeers
This provides an interface for maintaining a set of peer clusters.
|
class |
ReplicationPeersZKImpl
This class provides an implementation of the ReplicationPeers interface using Zookeeper.
|
class |
ReplicationPeerZKImpl |
class |
ReplicationQueueInfo
This class is responsible for the parsing logic for a znode representing a queue.
|
interface |
ReplicationQueues
This provides an interface for maintaining a region server's replication queues.
|
interface |
ReplicationQueuesClient
This provides an interface for clients of replication to view replication queues.
|
class |
ReplicationQueuesClientZKImpl |
class |
ReplicationQueuesZKImpl
This class provides an implementation of the ReplicationQueues interface using Zookeeper.
|
class |
ReplicationStateZKBase
This is a base class for maintaining replication state in zookeeper.
|
interface |
ReplicationTracker
This is the interface for a Replication Tracker.
|
class |
ReplicationTrackerZKImpl
This class is a Zookeeper implementation of the ReplicationTracker interface.
|
class |
ScopeWALEntryFilter
Keeps KVs that are scoped other than local
|
class |
SystemTableWALEntryFilter
Skips WAL edits for all System tables including META
|
| Constructor and Description |
|---|
ReplicationEndpoint.Context(org.apache.hadoop.conf.Configuration conf,
org.apache.hadoop.fs.FileSystem fs,
ReplicationPeerConfig peerConfig,
String peerId,
UUID clusterId,
ReplicationPeer replicationPeer,
MetricsSource metrics,
TableDescriptors tableDescriptors) |
ReplicationEndpoint.ReplicateContext() |
| Modifier and Type | Class and Description |
|---|---|
class |
HBaseInterClusterReplicationEndpoint
A
ReplicationEndpoint
implementation for replicating to another HBase cluster. |
class |
MetricsReplicationSourceImpl
Hadoop2 implementation of MetricsReplicationSource.
|
class |
MetricsSink
This class is for maintaining the various replication statistics for a sink and publishing them
through the metrics interfaces.
|
class |
RegionReplicaReplicationEndpoint
A
ReplicationEndpoint endpoint which receives the WAL edits from the
WAL, and sends the edits to replicas of regions. |
class |
Replication
Gateway to Replication.
|
class |
ReplicationLoad
This class is used for exporting some of the info from replication metrics
|
class |
ReplicationSink
This class is responsible for replicating the edits coming
from another cluster.
|
class |
ReplicationSource
Class that handles the source of a replication stream.
|
interface |
ReplicationSourceInterface
Interface that defines a replication source
|
class |
ReplicationSourceManager
This class is responsible to manage all the replication
sources.
|
class |
ReplicationThrottler
Per-peer per-node throttling controller for replication: enabled if
bandwidth > 0, a cycle = 100ms, by throttling we guarantee data pushed
to peer within each cycle won't exceed 'bandwidth' bytes
|
class |
ReplicationWALReaderManager
Wrapper class around WAL to help manage the implementation details
such as compression.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ExistsResource |
class |
MetricsREST |
class |
MetricsRESTSourceImpl
Hadoop Two implementation of a metrics2 source that will export metrics from the Rest server to
the hadoop metrics2 subsystem.
|
class |
MultiRowResource |
interface |
ProtobufMessageHandler
Common interface for models capable of supporting protobuf marshalling
and unmarshalling.
|
class |
RegionsResource |
class |
ResourceBase |
class |
ResourceConfig |
class |
RESTServlet
Singleton class encapsulating global REST servlet state and functions.
|
class |
RESTServletContainer
REST servlet container.
|
class |
ResultGenerator |
class |
RootResource |
class |
RowResource |
class |
RowResultGenerator |
class |
RowSpec
Parses a path based row/column/timestamp specification into its component
elements.
|
class |
ScannerInstanceResource |
class |
ScannerResource |
class |
ScannerResultGenerator |
class |
SchemaResource |
class |
StorageClusterStatusResource |
class |
StorageClusterVersionResource |
class |
TableResource |
class |
TableScanResource |
class |
VersionResource
Implements REST software version reporting
|
| Modifier and Type | Class and Description |
|---|---|
class |
GZIPRequestStream |
class |
GZIPRequestWrapper |
class |
GZIPResponseStream |
class |
GZIPResponseWrapper |
| Modifier and Type | Class and Description |
|---|---|
class |
CellModel
Representation of a cell.
|
class |
CellSetModel
Representation of a grouping of cells.
|
class |
ColumnSchemaModel
Representation of a column family schema.
|
class |
RowModel
Representation of a row.
|
class |
ScannerModel
A representation of Scanner parameters.
|
class |
StorageClusterStatusModel
Representation of the status of a storage cluster:
|
class |
StorageClusterVersionModel
Simple representation of the version of the storage cluster
|
class |
TableInfoModel
Representation of a list of table regions.
|
class |
TableListModel
Simple representation of a list of table names.
|
class |
TableModel
Simple representation of a table name.
|
class |
TableRegionModel
Representation of a region of a table and its current location on the
storage cluster.
|
class |
TableSchemaModel
A representation of HBase table descriptors.
|
class |
VersionModel
A representation of the collection of versions of the REST gateway software
components.
|
| Modifier and Type | Class and Description |
|---|---|
class |
JAXBContextResolver
Plumbing for hooking up Jersey's JSON entity body encoding and decoding
support to JAXB.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ProtobufMessageBodyConsumer
Adapter for hooking up Jersey content processing dispatch to
ProtobufMessageHandler interface capable handlers for decoding protobuf input.
|
| Modifier and Type | Class and Description |
|---|---|
class |
PlainTextMessageBodyProducer
An adapter between Jersey and Object.toString().
|
class |
ProtobufMessageBodyProducer
An adapter between Jersey and ProtobufMessageHandler implementors.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AuthMethod
Authentication method
|
class |
EncryptionUtil
Some static utility methods for encryption uses in hbase-client.
|
class |
HBasePolicyProvider
Implementation of secure Hadoop policy provider for mapping
protocol interfaces to hbase-policy.xml entries.
|
class |
HBaseSaslRpcClient
A utility class that encapsulates SASL logic for RPC client.
|
class |
HBaseSaslRpcServer
A utility class for dealing with SASL on RPC server
|
class |
SaslClientHandler
Handles Sasl connections
|
class |
SaslStatus |
class |
SaslUtil |
class |
SecureBulkLoadUtil |
class |
SecurityInfo
Maps RPC protocol interfaces to required configuration
|
class |
SecurityUtil
Security related generic utility methods.
|
class |
Superusers
Keeps lists of superusers and super groups loaded from HBase configuration,
checks if certain user is regarded as superuser.
|
class |
UserProvider
Provide an instance of a user.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AccessControlLists
Maintains lists of permission grants to users and groups to allow for
authorization checks by
AccessController. |
class |
AuthResult
Represents the result of an authorization check for logging and error
reporting.
|
class |
SecureBulkLoadEndpoint
Coprocessor service for bulk loads in secure mode.
|
class |
TableAuthManager
Performs authorization checks for a given user's assigned permissions
|
class |
TablePermission
Represents an authorization for access for the given actions, optionally
restricted to the given column family or column qualifier, over the
given table.
|
class |
UserPermission
Represents an authorization for access over the given table, column family
plus qualifier, for the given user.
|
class |
ZKPermissionWatcher
Handles synchronization of access control list entries and updates
throughout all nodes in the cluster.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AuthenticationKey
Represents a secret key used for signing and verifying authentication tokens
by
AuthenticationTokenSecretManager. |
class |
AuthenticationTokenIdentifier
Represents the identity information stored in an HBase authentication token.
|
class |
AuthenticationTokenSecretManager
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.
|
class |
AuthenticationTokenSelector |
class |
FsDelegationToken
Helper class to obtain a filesystem delegation token.
|
class |
TokenProvider
Provides a service for obtaining authentication tokens via the
AuthenticationProtos AuthenticationService coprocessor service. |
class |
ZKSecretWatcher
Synchronizes token encryption keys across cluster nodes.
|
| Modifier and Type | Class and Description |
|---|---|
class |
DefaultVisibilityLabelServiceImpl |
class |
DefinedSetFilterScanLabelGenerator
This is an implementation for ScanLabelGenerator.
|
class |
EnforcingScanLabelGenerator
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.
|
class |
ExpressionExpander |
class |
ExpressionParser |
class |
FeedUserAuthScanLabelGenerator
If the passed in authorization is null, then this ScanLabelGenerator
feeds the set of predefined authorization labels for the given user.
|
class |
ParseException |
class |
SimpleScanLabelGenerator
This is a simple implementation for ScanLabelGenerator.
|
class |
VisibilityConstants |
interface |
VisibilityLabelOrdinalProvider |
class |
VisibilityLabelsCache
Maintains the cache for visibility labels and also uses the zookeeper to update the labels in the
system.
|
class |
VisibilityLabelServiceManager
Manages singleton instance of
VisibilityLabelService |
class |
VisibilityLabelsValidator
A simple validator that validates the labels passed
|
class |
VisibilityReplicationEndpoint |
class |
VisibilityScanDeleteTracker
Similar to ScanDeletTracker but tracks the visibility expression also before
deciding if a Cell can be considered deleted
|
class |
VisibilityUtils
Utility method to support visibility
|
class |
ZKVisibilityLabelWatcher
A zk watcher that watches the labels table znode.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
ExpressionNode |
class |
LeafExpressionNode |
class |
NonLeafExpressionNode |
class |
Operator |
| Modifier and Type | Class and Description |
|---|---|
class |
ClientSnapshotDescriptionUtils
Class to help with dealing with a snapshot description on the client side.
|
class |
RestoreSnapshotHelper
Helper to Restore/Clone a Snapshot
|
class |
SnapshotDescriptionUtils
Utility class to help manage
SnapshotDesriptions. |
class |
SnapshotManifest
Utility class to help read/write the Snapshot Manifest.
|
class |
SnapshotManifestV1
DO NOT USE DIRECTLY.
|
class |
SnapshotManifestV2
DO NOT USE DIRECTLY.
|
class |
SnapshotReferenceUtil
Utility methods for interacting with the snapshot referenced files.
|
| Modifier and Type | Class and Description |
|---|---|
class |
CallQueue
A BlockingQueue reports waiting time in queue and queue length to
ThriftMetrics.
|
class |
HbaseHandlerMetricsProxy
Converts a Hbase.Iface using InvocationHandler so that it reports process
time of each call to ThriftMetrics.
|
class |
HThreadedSelectorServerArgs
A TThreadedSelectorServer.Args that reads hadoop configuration
|
class |
MetricsThriftServerSourceFactoryImpl
Class used to create metrics sources for Thrift and Thrift2 servers.
|
class |
MetricsThriftServerSourceImpl
Hadoop 2 version of MetricsThriftServerSource
MetricsThriftServerSource
Implements BaseSource through BaseSourceImpl, following the pattern |
class |
TBoundedThreadPoolServer
A bounded thread pool server customized for HBase.
|
class |
ThriftHttpServlet
Thrift Http Servlet is used for performing Kerberos authentication if security is enabled and
also used for setting the user specified in "doAs" parameter.
|
class |
ThriftMetrics
This class is for maintaining the various statistics of thrift server
and publishing them through the metrics interfaces.
|
class |
ThriftServerRunner
ThriftServerRunner - this class starts up a Thrift server which implements
the Hbase API specified in the Hbase.thrift IDL file.
|
class |
ThriftUtilities |
| Modifier and Type | Class and Description |
|---|---|
class |
ThriftHBaseServiceHandler
This class is a glue object that connects Thrift RPC calls to the HBase client API primarily
defined in the HTableInterface.
|
class |
ThriftUtilities |
| Modifier and Type | Class and Description |
|---|---|
class |
HBaseHTraceConfiguration |
class |
SpanReceiverHost
This class provides functions for reading the names of SpanReceivers from
hbase-site.xml, adding those SpanReceivers to the Tracer, and closing those
SpanReceivers when appropriate.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractByteRange
An abstract implementation of the ByteRange API
|
class |
AbstractHBaseTool
Common base class used for HBase command-line tools.
|
class |
AbstractPositionedByteRange
Extends the basic
SimpleByteRange implementation with position
support. |
class |
Addressing
Utility for network addresses, resolving and naming.
|
class |
ArrayUtils
A set of array utility functions that return reasonable values in cases where an array is
allocated or if it is null
|
interface |
BloomFilter
Defines the general behavior of a bloom filter.
|
interface |
BloomFilterBase
Common methods Bloom filter methods required at read and write time.
|
class |
BloomFilterFactory
Handles Bloom filter initialization based on configuration and serialized
metadata in the reader and writer of
StoreFile. |
interface |
BloomFilterWriter
Specifies methods needed to add elements to a Bloom filter and serialize the
resulting Bloom filter as a sequence of bytes.
|
class |
BoundedArrayQueue<E>
A bounded non-thread safe implementation of
Queue. |
class |
BoundedCompletionService<V>
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.
|
class |
BoundedConcurrentLinkedQueue<T>
A ConcurrentLinkedQueue that enforces a maximum queue size.
|
class |
BoundedPriorityBlockingQueue<E>
A generic bounded blocking Priority-Queue.
|
class |
ByteBloomFilter
Implements a Bloom filter, as defined by Bloom in 1970.
|
class |
ByteBufferArray
This class manages an array of ByteBuffers with a default size 4MB.
|
class |
ByteStringer
Hack to workaround HBASE-1304 issue that keeps bubbling up when a mapreduce context.
|
interface |
CancelableProgressable
Similar interface as
Progressable but returns
a boolean to support canceling the operation. |
class |
ChecksumFactory
Utility class that is used to generate a Checksum object.
|
class |
ChecksumType
Checksum types.
|
class |
Classes
Utilities for class manipulation.
|
class |
ClassLoaderBase
Base class loader that defines couple shared constants used
by sub-classes.
|
class |
ClassSize
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
|
class |
CollectionBackedScanner
Utility scanner that wraps a sortable collection and serves
as a KeyValueScanner.
|
class |
CollectionUtils
Utility methods for dealing with Collections, including treating null collections as empty.
|
class |
CompoundBloomFilter
A Bloom filter implementation built on top of
ByteBloomFilter,
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. |
class |
CompoundBloomFilterBase |
class |
CompoundBloomFilterWriter
Adds methods required for writing a compound Bloom filter to the data
section of an
HFile to the
CompoundBloomFilter class. |
class |
ConcatenatedLists<T>
A collection class that contains multiple sub-lists, which allows us to not copy lists.
|
class |
ConcurrentIndex<K,V>
A simple concurrent map of sets.
|
class |
ConfigUtil
Some configuration related utilities
|
class |
ConnectionCache
A utility to store user specific HConnections in memory.
|
class |
CoprocessorClassLoader
ClassLoader used to load classes for Coprocessor instances.
|
class |
DefaultEnvironmentEdge
Default implementation of an environment edge.
|
class |
DirectMemoryUtils
Utilities for interacting with and monitoring DirectByteBuffer allocations.
|
class |
DNS
Wrapper around Hadoop's DNS class to hide reflection.
|
class |
DrainBarrier
A simple barrier that can be used by classes that need to wait for some operations to
finish before stopping/closing/etc.
|
class |
DynamicClassLoader
This is a class loader that can load classes dynamically from new
jar files under a configured folder.
|
interface |
EnvironmentEdge
Has some basic interaction with the environment.
|
class |
EnvironmentEdgeManager
Manages a singleton instance of the environment edge.
|
class |
ExceptionUtil
This class handles the different interruption classes.
|
class |
ForeignExceptionUtil
Helper to convert Exceptions and StackTraces from/to protobuf.
|
class |
FSHDFSUtils
Implementation for hdfs
|
class |
FSMapRUtils
MapR implementation.
|
class |
FSTableDescriptors
Implementation of
TableDescriptors that reads descriptors from the
passed filesystem. |
class |
FSUtils
Utility methods for interacting with the underlying file system.
|
class |
FSVisitor
Utility methods for interacting with the hbase.root file system.
|
class |
Hash
This class represents a common API for hashing functions.
|
class |
HashedBytes
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.
|
class |
HasThread
Abstract class which contains a Thread and delegates the common Thread
methods to that instance.
|
class |
HBaseConfTool
Tool that prints out a configuration.
|
class |
HBaseFsckRepair
This class contains helper methods that repair parts of hbase's filesystem
contents.
|
class |
IdLock
Allows multiple concurrent clients to lock on a numeric id with a minimal
memory overhead.
|
class |
IncrementingEnvironmentEdge
Uses an incrementing algorithm instead of the default.
|
class |
IterableUtils
Utility methods for Iterable including null-safe handlers.
|
class |
JenkinsHash
Produces 32-bit hash for hash table lookup.
|
class |
JVM
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.
|
class |
JVMClusterUtil
Utility used running a cluster all in the one JVM.
|
class |
JvmPauseMonitor
Class which sets up a simple thread which runs in a loop sleeping
for a short interval of time.
|
class |
JvmVersion
Certain JVM versions are known to be unstable with HBase.
|
class |
KeyLocker<K extends Comparable<? super K>>
A utility class to manage a set of locks.
|
interface |
KeyRange
A key range use in split coverage.
|
class |
ManualEnvironmentEdge
An environment edge that uses a manually set value.
|
class |
MetaUtils
Contains utility methods for manipulating HBase meta tables.
|
class |
Methods |
class |
ModifyRegionUtils
Utility methods for interacting with the regions.
|
class |
MultiHConnection
Provides ability to create multiple HConnection instances and allows to process a batch of
actions using HConnection.processBatchCallback()
|
class |
MunkresAssignment
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".
|
class |
MurmurHash
This is a very fast, non-cryptographic hash suitable for general hash-based
lookup.
|
class |
MurmurHash3
This is a very fast, non-cryptographic hash suitable for general hash-based
lookup.
|
class |
NonceKey
This implementation is not smart and just treats nonce group and nonce as random bits.
|
class |
PoolMap<K,V>
The
PoolMap maps a key to a collection of values, the elements
of which are managed by a pool. |
class |
PrettyPrinter |
class |
ProtoUtil |
class |
ReflectionUtils |
class |
RegionSizeCalculator
Computes size of each region for given table and given column families.
|
class |
RegionSplitCalculator<R extends KeyRange>
This is a generic region split calculator.
|
class |
RegionSplitter
The
RegionSplitter class provides several utilities to help in the
administration lifecycle for developers who choose to manually split regions
instead of having HBase handle that automatically. |
class |
RetryCounter |
class |
RetryCounterFactory |
class |
ServerCommandLine
Base class for command lines that start up various HBase daemons.
|
class |
Sleeper
Sleeper for current thread.
|
class |
SortedCopyOnWriteSet<E>
|
class |
Strings
Utility for Strings.
|
class |
Threads
Thread Utility
|
class |
Triple<A,B,C>
Utility class to manage a triple.
|
class |
UnsafeAccess |
class |
UnsafeAvailChecker |
class |
Writables
Utility class with methods for manipulating Writable objects
|
| Modifier and Type | Class and Description |
|---|---|
class |
ByteRangeSet
Performance oriented class for de-duping and storing arbitrary byte[]'s arriving in non-sorted
order.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ByteRangeHashSet
This is probably the best implementation of ByteRangeSet at the moment, though a HashMap produces
garbage when adding a new element to it.
|
class |
ByteRangeTreeSet
Not currently used in production, but here as a benchmark comparison against ByteRangeHashSet.
|
| Modifier and Type | Class and Description |
|---|---|
class |
HFileCorruptionChecker
This class marches through all of the region's hfiles and verifies that
they are all valid files.
|
| Modifier and Type | Class and Description |
|---|---|
class |
LoadTestKVGenerator
A generator of random keys and values for load testing.
|
class |
RedundantKVGenerator
Generate list of key values which are very useful to test data block encoding
and compression.
|
| Modifier and Type | Class and Description |
|---|---|
class |
UFIntTool
UFInt is an abbreviation for Unsigned Fixed-width Integer.
|
class |
UVIntTool
Simple Variable Length Integer encoding.
|
class |
UVLongTool
Simple Variable Length Integer encoding.
|
| Modifier and Type | Class and Description |
|---|---|
class |
BoundedRegionGroupingProvider
A WAL Provider that pre-creates N WALProviders and then limits our grouping strategy to them.
|
class |
DefaultWALProvider
A WAL Provider that returns a single thread safe WAL that writes to HDFS.
|
interface |
WAL
A Write Ahead Log (WAL) provides service for reading, writing waledits.
|
class |
WALFactory
Entry point for users of the Write Ahead Log.
|
protected static class |
WALKey.Version |
interface |
WALProvider
The Write Ahead Log (WAL) stores all durable edits to the HRegion.
|
class |
WALSplitter
This class is responsible for splitting up a bunch of regionserver commit log
files that are no longer being written to, into new files, one per region for
region to replay on startup.
|
| Modifier and Type | Field and Description |
|---|---|
protected List<UUID> |
WALKey.clusterIds |
protected CompressionContext |
WALKey.compressionContext |
protected byte[] |
WALKey.encodedRegionName |
protected long |
WALKey.logSeqNum |
protected TableName |
WALKey.tablename |
protected static WALKey.Version |
WALKey.VERSION |
protected long |
WALKey.writeTime |
| Modifier and Type | Method and Description |
|---|---|
protected void |
WALKey.init(byte[] encodedRegionName,
TableName tablename,
long logSeqNum,
long now,
List<UUID> clusterIds,
long nonceGroup,
long nonce) |
void |
WALKey.setLogSeqNum(long sequence)
Allow that the log sequence id to be set post-construction and release all waiters on assigned
sequence number.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ClusterStatusTracker
Tracker on cluster settings up in zookeeper.
|
class |
DeletionListener
A ZooKeeper watcher meant to detect deletions of ZNodes.
|
class |
DrainingServerTracker
Tracks the list of draining region servers via ZK.
|
class |
EmptyWatcher
An empty ZooKeeper watcher
|
class |
LoadBalancerTracker
Tracks the load balancer state up in ZK
|
class |
MasterAddressTracker
Manages the location of the current active Master for the RegionServer.
|
class |
MetaTableLocator
Utility class to perform operation (get/wait for/verify/set/delete) on znode in ZooKeeper
which keeps hbase:meta region server location.
|
class |
RecoverableZooKeeper
A zookeeper that can handle 'recoverable' errors.
|
class |
RecoveringRegionWatcher
Watcher used to be notified of the recovering region coming out of recovering state
|
class |
RegionServerTracker
Tracks the online region servers via ZK.
|
class |
ZkAclReset
You may add the jaas.conf option
-Djava.security.auth.login.config=/PATH/jaas.conf
You may also specify -D to set options
"hbase.zookeeper.quorum" (it should be in hbase-site.xml)
"zookeeper.znode.parent" (it should be in hbase-site.xml)
Use -set-acls to set the ACLs, no option to erase ACLs
|
class |
ZKAssign
Utility class for doing region assignment in ZooKeeper.
|
class |
ZKClusterId
Publishes and synchronizes a unique identifier specific to a given HBase
cluster.
|
class |
ZKConfig
Utility methods for reading, and building the ZooKeeper configuration.
|
class |
ZKLeaderManager
Deprecated.
Not used
|
class |
ZKSplitLog
Common methods and attributes used by
SplitLogManager and
SplitLogWorker
running distributed splitting of WAL logs. |
class |
ZKTableStateClientSideReader
Non-instantiable class that provides helper functions to learn
about HBase table state for code running on client side (hence, not having
access to consensus context).
|
class |
ZKTableStateManager
Implementation of TableStateManager which reads, caches and sets state
up in ZooKeeper.
|
class |
ZKUtil
Internal HBase utility class for ZooKeeper.
|
class |
ZooKeeperListener
Base class for internal listeners of ZooKeeper events.
|
class |
ZooKeeperNodeTracker
Tracks the availability and value of a single ZooKeeper node.
|
class |
ZooKeeperWatcher
Acts as the single ZooKeeper Watcher.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ZKInterProcessLockBase
ZooKeeper based HLock implementation.
|
class |
ZKInterProcessReadLock
ZooKeeper based read lock: does not exclude other read locks, but excludes
and is excluded by write locks.
|
class |
ZKInterProcessReadWriteLock
ZooKeeper based implementation of
InterProcessReadWriteLock. |
class |
ZKInterProcessWriteLock
ZooKeeper based write lock:
|
| Modifier and Type | Class and Description |
|---|---|
class |
JmxCacheBuster
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.
|
| Modifier and Type | Class and Description |
|---|---|
class |
DynamicMetricsRegistry
An optional metrics registry class for creating and maintaining a
collection of MetricsMutables, making writing metrics source easier.
|
class |
MetricMutableQuantiles
Watches a stream of long values, maintaining online estimates of specific quantiles with provably
low error bounds.
|
class |
MetricsExecutorImpl
Class to handle the ScheduledExecutorService
ScheduledExecutorService used by MetricMutableQuantilesMetricMutableQuantiles |
class |
MutableHistogram
A histogram implementation that runs in constant space, and exports to hadoop2's metrics2 system.
|
class |
MutableRangeHistogram
Extended histogram implementation with metric range counters.
|
class |
MutableSizeHistogram
Extended histogram implementation with counters for metric size ranges.
|
class |
MutableTimeHistogram
Extended histogram implementation with counters for metric time ranges.
|
| Modifier and Type | Method and Description |
|---|---|
org.apache.hadoop.metrics2.lib.MutableRate |
DynamicMetricsRegistry.newRate(String name,
String desc,
boolean extended,
boolean returnExisting) |
| Modifier and Type | Class and Description |
|---|---|
class |
MetricQuantile
Specifies a quantile (with error bounds) to be watched by a
MetricSampleQuantiles object. |
class |
MetricSampleQuantiles
Implementation of the Cormode, Korn, Muthukrishnan, and Srivastava algorithm
for streaming calculation of targeted high-percentile epsilon-approximate
quantiles.
|
Copyright © 2007-2016 The Apache Software Foundation. All Rights Reserved.