Interface | Description |
---|---|
AbstractMultiFileWriter.WriterFactory | |
ChangedReadersObserver |
If set of MapFile.Readers in Store change, implementors are notified.
|
FavoredNodesForRegion |
Abstraction that allows different modules in RegionServer to update/get
the favored nodes information for regions.
|
FlushLifeCycleTracker |
Used to track flush execution.
|
FlushRequester |
Request a flush.
|
FlushRequestListener |
Listener which will get notified regarding flush requests of regions.
|
HeapMemoryManager.HeapMemoryTuneObserver |
Every class that wants to observe heap memory tune actions must implement this interface.
|
HeapMemoryTuner |
Makes the decision regarding proper sizing of the heap memory.
|
HRegion.BulkLoadListener |
Listener class to enable callers of
bulkLoadHFile() to perform any necessary
pre/post processing of a given bulkload call
|
HRegion.FlushResult | |
InternalScanner |
Internal scanners differ from client-side scanners in that they operate on
HStoreKeys and byte[] instead of RowResults.
|
KeyValueScanner |
Scanner that returns the next KeyValue.
|
LastSequenceId |
Last flushed sequence Ids for the regions and their stores on region server
|
LeaseListener |
LeaseListener is an interface meant to be implemented by users of the Leases
class.
|
MemStore |
The MemStore holds in-memory modifications to the Store.
|
MemStoreLAB |
A memstore-local allocation buffer.
|
MemStoreSizing |
Accounting of current heap and data sizes.
|
MetricsHeapMemoryManagerSource |
This interface will be implemented by a MetricsSource that will export metrics from
HeapMemoryManager in RegionServer into the hadoop metrics system.
|
MetricsRegionAggregateSource |
This interface will be implemented by a MetricsSource that will export metrics from
multiple regions into the hadoop metrics system.
|
MetricsRegionServerQuotaSource |
A collection of exposed metrics for space quotas from an HBase RegionServer.
|
MetricsRegionServerSource |
Interface for classes that expose metrics about the regionserver.
|
MetricsRegionServerSourceFactory |
Interface of a factory to create Metrics Sources used inside of regionservers.
|
MetricsRegionServerWrapper |
This is the interface that will expose RegionServer information to hadoop1/hadoop2
implementations of the MetricsRegionServerSource.
|
MetricsRegionSource |
This interface will be implemented to allow single regions to push metrics into
MetricsRegionAggregateSource that will in turn push data to the Hadoop metrics system.
|
MetricsRegionWrapper |
Interface of class that will wrap an HRegion and export numbers so they can be
used in MetricsRegionSource
|
MetricsTableAggregateSource |
This interface will be implemented by a MetricsSource that will export metrics from
multiple regions of a table into the hadoop metrics system.
|
MetricsTableLatencies |
Latency metrics for a specific table in a RegionServer.
|
MetricsTableSource |
This interface will be implemented to allow region server to push table metrics into
MetricsRegionAggregateSource that will in turn push data to the Hadoop metrics system.
|
MetricsTableWrapperAggregate |
Interface of class that will wrap a MetricsTableSource and export numbers so they can be
used in MetricsTableSource
|
MutableOnlineRegions |
Interface to Map of online regions.
|
OnlineRegions |
Provides read-only access to the Regions presently online on the
current RegionServer
|
RegionScanner |
RegionScanner describes iterators over rows in an HRegion.
|
RegionServerServices |
A curated subset of services provided by
HRegionServer . |
ReplicationService |
Gateway to Cluster Replication.
|
ReplicationSinkService |
A sink for a replication stream has to expose this service.
|
ReplicationSourceService |
A source for a replication stream has to expose this service.
|
RowProcessor<S extends Message,T extends Message> | Deprecated
As of release 2.0.0, this will be removed in HBase 3.0.0.
|
RpcSchedulerFactory |
A factory class that constructs an
RpcScheduler . |
SequenceId |
Interface which abstracts implementations on log sequenceId assignment
|
Shipper |
This interface denotes a scanner as one which can ship cells.
|
Store |
Interface for objects that hold a column family in a Region.
|
StoreConfigInformation |
A more restricted interface for HStore.
|
Class | Description |
---|---|
AbstractMemStore |
An abstract class, which implements the behaviour shared by all concrete memstore instances.
|
AbstractMultiFileWriter |
Base class for cell sink that separates the provided cells into multiple files.
|
AdaptiveMemStoreCompactionStrategy |
Adaptive is a heuristic that chooses whether to apply data compaction or not based on the
level of redundancy in the data.
|
AnnotationReadingPriorityFunction |
Reads special method annotations and table names to figure a priority for use by QoS facility in
ipc; e.g: rpcs to hbase:meta get priority.
|
BaseRowProcessor<S extends Message,T extends Message> |
Base class for RowProcessor with some default implementations.
|
BasicMemStoreCompactionStrategy |
Basic strategy chooses between two actions: flattening a segment or merging indices of all
segments in the pipeline.
|
BusyRegionSplitPolicy |
This class represents a split policy which makes the split decision based
on how busy a region is.
|
CellArrayImmutableSegment |
CellArrayImmutableSegment extends the API supported by a
Segment ,
and ImmutableSegment . |
CellChunkImmutableSegment |
CellChunkImmutableSegment extends the API supported by a
Segment ,
and ImmutableSegment . |
CellChunkMap |
CellChunkMap is an array of serialized representations of Cell
(pointing to Chunks with full Cell data) and can be allocated both off-heap and on-heap.
|
CellFlatMap |
CellFlatMap stores a constant number of elements and is immutable after creation stage.
|
CellSet |
A
Set of Cell s, where an add will overwrite the entry if already
exists in the set. |
Chunk |
A chunk of memory out of which allocations are sliced.
|
ChunkCreator |
Does the management of memstoreLAB chunk creations.
|
CompactedHFilesDischargeHandler |
Event handler that handles the removal and archival of the compacted hfiles
|
CompactedHFilesDischarger |
A chore service that periodically cleans up the compacted files when there are no active readers
using those compacted files and also helps in clearing the block cache of these compacted
file entries.
|
CompactingMemStore |
A memstore implementation which supports in-memory compaction.
|
CompactionPipeline |
The compaction pipeline of a
CompactingMemStore , is a FIFO queue of segments. |
CompactionTool | |
CompactSplit |
Compact region on request and then run split if appropriate
|
CompositeImmutableSegment |
The CompositeImmutableSegments is created as a collection of ImmutableSegments and supports
the interface of a single ImmutableSegments.
|
ConstantSizeRegionSplitPolicy |
A
RegionSplitPolicy implementation which splits a region
as soon as any of its store files exceeds a maximum configurable
size. |
CSLMImmutableSegment |
CSLMImmutableSegment is an abstract class that extends the API supported by a
Segment ,
and ImmutableSegment . |
DateTieredMultiFileWriter |
class for cell sink that separates the provided cells into multiple files for date tiered
compaction.
|
DateTieredStoreEngine |
HBASE-15400 This store engine allows us to store data in date tiered layout with exponential
sizing so that the more recent data has more granularity.
|
DefaultMemStore |
The MemStore holds in-memory modifications to the Store.
|
DisabledRegionSplitPolicy |
A
RegionSplitPolicy that disables region splits. |
EagerMemStoreCompactionStrategy | |
FifoRpcSchedulerFactory |
Factory to use when you want to use the
FifoRpcScheduler |
FlushNonSloppyStoresFirstPolicy |
A
FlushPolicy that only flushes store larger than a given threshold. |
FlushPolicyFactory |
The class that creates a flush policy from a conf and HTableDescriptor.
|
HeapMemoryManager |
Manages tuning of Heap memory using
HeapMemoryTuner . |
HeapMemoryManager.TunerContext |
POJO to pass all the relevant information required to do the heap memory tuning.
|
HeapMemoryManager.TunerResult |
POJO which holds the result of memory tuning done by HeapMemoryTuner implementation.
|
HMobStore |
The store implementation to save MOBs (medium objects), it extends the HStore.
|
HRegion |
Regions store data for a certain region of a table.
|
HRegion.FlushResultImpl |
Objects from this class are created when flushing to describe all the different states that
that method ends up in.
|
HRegion.RowLockImpl |
Class used to represent a lock on a row.
|
HRegionServer |
HRegionServer makes a set of HRegions available to clients.
|
HRegionServer.MovedRegionsCleaner |
Creates a Chore thread to clean the moved region cache.
|
HRegionServerCommandLine |
Class responsible for parsing the command line and starting the
RegionServer.
|
HStore |
A Store holds a column family in a Region.
|
ImmutableMemStoreLAB |
A MemStoreLAB implementation which wraps N MemStoreLABs.
|
ImmutableSegment |
ImmutableSegment is an abstract class that extends the API supported by a
Segment ,
and is not needed for a MutableSegment . |
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.
|
InternalScan |
Special scanner, currently used for increment operations to
allow additional server-side arguments for Scan operations.
|
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.
|
KeyValueHeap |
Implements a heap merge across any number of KeyValueScanners.
|
KeyValueHeap.KVScannerComparator | |
Leases |
Leases
There are several server classes in HBase that need to track external
clients that occasionally send heartbeats.
|
LogRoller |
Runs periodically to determine if the WAL should be rolled.
|
MemStoreCompactor |
The ongoing MemStore Compaction manager, dispatches a solo running compaction and interrupts
the compaction if requested.
|
MemStoreCompactorSegmentsIterator |
The MemStoreCompactorSegmentsIterator extends MemStoreSegmentsIterator
and performs the scan for compaction operation meaning it is based on SQM
|
MemStoreLABImpl |
A memstore-local allocation buffer.
|
MemStoreMergerSegmentsIterator |
The MemStoreMergerSegmentsIterator extends MemStoreSegmentsIterator
and performs the scan for simple merge operation meaning it is NOT based on SQM
|
MemStoreSegmentsIterator |
The MemStoreSegmentsIterator is designed to perform one iteration over given list of segments
For another iteration new instance of MemStoreSegmentsIterator needs to be created
The iterator is not thread-safe and must have only one instance per MemStore
in each period of time
|
MemStoreSize |
Data structure of three longs.
|
MetricsHeapMemoryManager |
This class is for maintaining the various regionserver's heap memory manager statistics and
publishing them through the metrics interfaces.
|
MetricsRegion |
This is the glue between the HRegion and whatever hadoop shim layer
is loaded (hbase-hadoop1-compat or hbase-hadoop2-compat).
|
MetricsRegionServer |
This class is for maintaining the various regionserver statistics
and publishing them through the metrics interfaces.
|
MetricsRegionWrapperImpl | |
MetricsTable | |
MiniBatchOperationInProgress<T> |
Wraps together the mutations which are applied as a batch to the region and their operation
status and WALEdits.
|
MobStoreScanner |
Scanner scans both the memstore and the MOB Store.
|
MultiVersionConcurrencyControl |
Manages the read/write consistency.
|
MultiVersionConcurrencyControl.WriteEntry |
Write number and whether write has completed given out at start of a write transaction.
|
MutableSegment |
A mutable segment in memstore, specifically the active segment.
|
NoLimitScannerContext |
This is a special
ScannerContext subclass that is designed to be used globally when
limits should not be enforced during invocations of InternalScanner.next(java.util.List)
or InternalScanner.next(java.util.List) . |
NonReversedNonLazyKeyValueScanner |
A "non-reversed & non-lazy" scanner which does not support backward scanning
and always does a real seek operation.
|
NoOpHeapMemoryTuner |
An implementation of HeapMemoryTuner which is not doing any tuning activity but just allows to
continue with old style fixed proportions.
|
NoTagByteBufferChunkKeyValue |
ByteBuffer based cell which has the chunkid at the 0th offset and with no tags
|
OffheapChunk |
An off heap chunk implementation.
|
OnheapChunk |
An on heap chunk implementation.
|
RegionCoprocessorHost |
Implements the coprocessor environment and runtime support for coprocessors
loaded within a
Region . |
RegionServerCoprocessorHost | |
RegionServerServices.PostOpenDeployContext |
Context for postOpenDeployTasks().
|
RegionServerServices.RegionStateTransitionContext | |
RegionServerTableMetrics |
Captures operation metrics by table.
|
RegionServicesForStores |
Services a Store needs from a Region.
|
RegionSplitPolicy |
A split policy determines when a Region should be split.
|
ReversedKeyValueHeap |
ReversedKeyValueHeap is used for supporting reversed scanning.
|
ReversedStoreScanner |
ReversedStoreScanner extends from StoreScanner, and is used to support
reversed scanning.
|
RSRpcServices |
Implements the regionserver RPC services.
|
RSStatusServlet | |
ScannerContext |
ScannerContext instances encapsulate limit tracking AND progress towards those limits during
invocations of
InternalScanner.next(java.util.List) and
InternalScanner.next(java.util.List) . |
ScannerContext.Builder | |
SecureBulkLoadManager |
Bulk loads in secure mode.
|
Segment |
This is an abstraction of a segment maintained in a memstore, e.g., the active
cell set or its snapshot.
|
SegmentFactory |
A singleton store segment factory.
|
SegmentScanner |
A scanner of a single memstore segment.
|
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.
|
SimpleRpcSchedulerFactory |
Constructs a
SimpleRpcScheduler . |
SnapshotSegmentScanner |
A basic SegmentScanner used against an ImmutableScanner snapshot
Used flushing where we do a single pass, no reverse scanning or
inserts happening.
|
SteppingSplitPolicy | |
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.
|
StoreFileInfo |
Describe a StoreFile (hfile, reference, link)
|
StoreFileReader |
Reader for a StoreFile.
|
StorefileRefresherChore |
A chore for refreshing the store files for secondary regions hosted in the region server.
|
StoreFileWriter |
A StoreFile writer.
|
StoreFileWriter.Builder | |
StoreScanner |
Scanner scans both the memstore and the Store.
|
StoreUtils |
Utility functions for region server storage layer.
|
StripeMultiFileWriter |
Base class for cell sink that separates the provided cells into multiple files for stripe
compaction.
|
StripeMultiFileWriter.BoundaryMultiWriter |
MultiWriter that separates the cells based on fixed row-key boundaries.
|
StripeMultiFileWriter.SizeMultiWriter |
MultiWriter that separates the cells based on target cell number per file and file count.
|
StripeStoreFileManager |
Stripe implementation of StoreFileManager.
|
StripeStoreFlusher |
Stripe implementation of StoreFlusher.
|
StripeStoreFlusher.BoundaryStripeFlushRequest |
Stripe flush request wrapper based on boundaries.
|
StripeStoreFlusher.SizeStripeFlushRequest |
Stripe flush request wrapper based on size.
|
StripeStoreFlusher.StripeFlushRequest |
Stripe flush request wrapper that writes a non-striped file.
|
TestMetricsRegionServerSourceFactory |
Test for the CompatibilitySingletonFactory and building MetricsRegionServerSource
|
TimeRangeTracker |
Stores minimum and maximum timestamp values, it is [minimumTimestamp, maximumTimestamp] in
interval notation.
|
TimeRangeTracker.NonSyncTimeRangeTracker | |
TimeRangeTracker.SyncTimeRangeTracker | |
VersionedSegmentsList |
A list of segment managers coupled with the version of the memstore (version at the time it was
created).
|
Enum | Description |
---|---|
ChunkCreator.ChunkType |
Types of chunks, based on their sizes
|
CompactingMemStore.IndexType |
Types of indexes (part of immutable segments) to be used after flattening,
compaction, or merge are applied.
|
HRegion.FlushResult.Result | |
ScannerContext.LimitScope |
The various scopes where a limit can be enforced.
|
ScannerContext.NextState |
The possible states a scanner may be in following a call to
InternalScanner.next(List) |
ScanType |
Enum to distinguish general scan types.
|
TimeRangeTracker.Type |
Exception | Description |
---|---|
Leases.LeaseStillHeldException |
Thrown if we are asked to create a lease but lease on passed name already
exists.
|