Package org.apache.hadoop.hbase.regionserver

Interface Summary

Interface	Description
AbstractMultiFileWriter.WriterFactory
CellSink	A sink of cells that allows appending cells to the Writers that implement it.
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
Region	Region is a subset of HRegion with operations required for the Coprocessors.
Region.RowLock	Row lock held by a given thread.
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 com.google.protobuf.Message,T extends com.google.protobuf.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.
ScanOptions	This class gives you the ability to change the max versions and TTL options before opening a scanner for a Store.
SequenceId	Interface which abstracts implementations on log sequenceId assignment
Shipper	This interface denotes a scanner as one which can ship cells.
ShipperListener	Implementors of this interface are the ones who needs to do some action when the Shipper.shipped() is called
SplitLogWorker.TaskExecutor	Objects implementing this interface actually do the task that has been acquired by a SplitLogWorker.
Store	Interface for objects that hold a column family in a Region.
StoreConfigInformation	A more restricted interface for HStore.
StoreFile	An interface to describe a store data file.
StoreFileManager	Manages the store files and basic metadata about that that determines the logical structure (e.g.
StoreFileReader.Listener

Class Summary

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 com.google.protobuf.Message,T extends com.google.protobuf.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.
ByteBufferChunkKeyValue	ByteBuffer based cell which has the chunkid at the 0th offset
CellArrayImmutableSegment	CellArrayImmutableSegment extends the API supported by a Segment, and ImmutableSegment.
CellArrayMap	CellArrayMap is a simple array of Cells and cannot be allocated off-heap.
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 Cells, 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.
CustomizedScanInfoBuilder	Helper class for CP hooks to change max versions and TTL.
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.
DefaultStoreEngine	Default StoreEngine creates the default compactor, policy, and store file manager, or their derivatives.
DefaultStoreFlusher	Default implementation of StoreFlusher.
DelimitedKeyPrefixRegionSplitPolicy	A custom RegionSplitPolicy implementing a SplitPolicy that groups rows by a prefix of the row-key with a delimiter.
DisabledRegionSplitPolicy	A RegionSplitPolicy that disables region splits.
DumpRegionServerMetrics	Utility for doing JSON and MBeans.
EagerMemStoreCompactionStrategy
FifoRpcSchedulerFactory	Factory to use when you want to use the FifoRpcScheduler
FlushAllLargeStoresPolicy	A FlushPolicy that only flushes store larger a given threshold.
FlushAllStoresPolicy	A FlushPolicy that always flushes all stores for a given region.
FlushLargeStoresPolicy	A FlushPolicy that only flushes store larger a given threshold.
FlushNonSloppyStoresFirstPolicy	A FlushPolicy that only flushes store larger than a given threshold.
FlushPolicy	A flush policy determines the stores that need to be flushed when flushing a region.
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.
HRegionFileSystem	View to an on-disk Region.
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.
HStoreFile	A Store data file.
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.
MasterFifoRpcSchedulerFactory	Factory to use when you want to use the MasterFifoRpcScheduler
MemStoreCompactionStrategy	MemStoreCompactionStrategy is the root of a class hierarchy which defines the strategy for choosing the next action to apply in an (in-memory) memstore compaction.
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.
MemStoreSnapshot	Holds details of the snapshot taken on a MemStore.
MetricsHeapMemoryManager	This class is for maintaining the various regionserver's heap memory manager statistics and publishing them through the metrics interfaces.
MetricsHeapMemoryManagerSourceImpl	Hadoop2 implementation of MetricsHeapMemoryManagerSource.
MetricsRegion	This is the glue between the HRegion and whatever hadoop shim layer is loaded (hbase-hadoop1-compat or hbase-hadoop2-compat).
MetricsRegionAggregateSourceImpl
MetricsRegionServer	This class is for maintaining the various regionserver statistics and publishing them through the metrics interfaces.
MetricsRegionServerSourceFactoryImpl	Factory to create MetricsRegionServerSource when given a MetricsRegionServerWrapper
MetricsRegionServerSourceImpl	Hadoop2 implementation of MetricsRegionServerSource.
MetricsRegionSourceImpl
MetricsRegionWrapperImpl
MetricsTable
MetricsTableAggregateSourceImpl
MetricsTableLatenciesImpl	Implementation of MetricsTableLatencies to track latencies for one table in a RegionServer.
MetricsTableLatenciesImpl.TableHistograms
MetricsTableSourceImpl
MetricsTableWrapperAggregateImpl
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).
NonLazyKeyValueScanner	A "non-lazy" scanner which always does a real seek operation.
NonReversedNonLazyKeyValueScanner	A "non-reversed & non-lazy" scanner which does not support backward scanning and always does a real seek operation.
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.
OperationStatus	This class stores the Operation status code and the exception message that occurs in case of failure of operations like put, delete, etc.
RegionCoprocessorHost	Implements the coprocessor environment and runtime support for coprocessors loaded within a Region.
RegionServerAccounting	RegionServerAccounting keeps record of some basic real time information about the Region Server.
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.
ReversedMobStoreScanner	ReversedMobStoreScanner extends from ReversedStoreScanner, and is used to support reversed scanning in both the memstore and the MOB store.
ReversedStoreScanner	ReversedStoreScanner extends from StoreScanner, and is used to support reversed scanning.
RSDumpServlet
RSRpcServices	Implements the regionserver RPC services.
RSStatusServlet
ScanInfo	Immutable information for scans over a store.
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
ScannerIdGenerator	Generate a new style scanner id to prevent collision with previous started server or other RSs.
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.
ShutdownHook	Manage regionserver shutdown hooks.
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.
SplitLogWorker	This worker is spawned in every regionserver, including master.
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.
StoreFileScanner	KeyValueScanner adaptor over the Reader.
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.
StripeStoreConfig	Configuration class for stripe store and compactions.
StripeStoreEngine	The storage engine that implements the stripe-based store/compaction scheme.
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.
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 Summary

Enum	Description
BloomType
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
MemStoreCompactionStrategy.Action	Types of actions to be done on the pipeline upon MemStoreCompaction invocation.
MetricsRegionServerSourceFactoryImpl.FactoryStorage
Region.Operation	Operation enum is used in Region.startRegionOperation() and elsewhere to provide context for various checks.
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.
SplitLogWorker.TaskExecutor.Status
TimeRangeTracker.Type

Exception Summary

Exception	Description
LeaseException	Reports a problem with a lease
Leases.LeaseStillHeldException	Thrown if we are asked to create a lease but lease on passed name already exists.
NoSuchColumnFamilyException	Thrown if request for nonexistent column family.
RegionServerAbortedException	Thrown by the region server when it is aborting.
RegionServerRunningException	Thrown if the region server log directory exists (which indicates another region server is running at the same address)
RegionServerStoppedException	Thrown by the region server when it is in shutting down state.
RowTooBigException	Deprecated use RowTooBigException instead.
WrongRegionException	Thrown when a request contains a key which is not part of this region