Modifier and Type | Method and Description |
---|---|
void |
ZkRegionMergeCoordination.completeRegionMergeTransaction(RegionServerServices services,
HRegionInfo mergedRegionInfo,
HRegion region_a,
HRegion region_b,
RegionMergeCoordination.RegionMergeDetails rmd,
HRegion mergedRegion) |
void |
RegionMergeCoordination.completeRegionMergeTransaction(RegionServerServices services,
HRegionInfo merged,
HRegion region_a,
HRegion region_b,
RegionMergeCoordination.RegionMergeDetails rmd,
HRegion mergedRegion)
Finish off merge transaction
|
void |
ZKSplitTransactionCoordination.completeSplitTransaction(RegionServerServices services,
HRegion a,
HRegion b,
SplitTransactionCoordination.SplitTransactionDetails std,
HRegion parent)
Finish off split transaction, transition the zknode
|
void |
SplitTransactionCoordination.completeSplitTransaction(RegionServerServices services,
HRegion first,
HRegion second,
SplitTransactionCoordination.SplitTransactionDetails std,
HRegion parent)
Finish off split transaction
|
void |
ZkCloseRegionCoordination.setClosedState(HRegion region,
ServerName sn,
CloseRegionCoordination.CloseRegionDetails crd)
In ZK-based version we do some znodes transitioning.
|
void |
CloseRegionCoordination.setClosedState(HRegion region,
ServerName sn,
CloseRegionCoordination.CloseRegionDetails crd)
Called after region is closed to notify all interesting parties / "register"
region as finally closed.
|
void |
ZKSplitTransactionCoordination.startSplitTransaction(HRegion parent,
ServerName serverName,
HRegionInfo hri_a,
HRegionInfo hri_b)
Creates a new ephemeral node in the PENDING_SPLIT state for the specified region.
|
void |
SplitTransactionCoordination.startSplitTransaction(HRegion parent,
ServerName serverName,
HRegionInfo hri_a,
HRegionInfo hri_b)
init coordination for split transaction
|
boolean |
ZkOpenRegionCoordination.transitionToOpened(HRegion r,
OpenRegionCoordination.OpenRegionDetails ord) |
boolean |
OpenRegionCoordination.transitionToOpened(HRegion r,
OpenRegionCoordination.OpenRegionDetails ord)
Tries to move regions to OPENED state.
|
void |
ZkRegionMergeCoordination.waitForRegionMergeTransaction(RegionServerServices services,
HRegionInfo mergedRegionInfo,
HRegion region_a,
HRegion region_b,
RegionMergeCoordination.RegionMergeDetails details)
Wait for the merging node to be transitioned from pending_merge
to merging by master.
|
void |
RegionMergeCoordination.waitForRegionMergeTransaction(RegionServerServices services,
HRegionInfo mergedRegionInfo,
HRegion region_a,
HRegion region_b,
RegionMergeCoordination.RegionMergeDetails details)
Get everything ready for region merge
|
void |
ZKSplitTransactionCoordination.waitForSplitTransaction(RegionServerServices services,
HRegion parent,
HRegionInfo hri_a,
HRegionInfo hri_b,
SplitTransactionCoordination.SplitTransactionDetails sptd)
Wait for the splitting node to be transitioned from pending_split to splitting by master.
|
void |
SplitTransactionCoordination.waitForSplitTransaction(RegionServerServices services,
HRegion parent,
HRegionInfo hri_a,
HRegionInfo hri_b,
SplitTransactionCoordination.SplitTransactionDetails std)
Wait while coordination process the transaction
|
Modifier and Type | Method and Description |
---|---|
HRegion |
RegionCoprocessorEnvironment.getRegion() |
Modifier and Type | Method and Description |
---|---|
void |
RegionServerObserver.postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c,
HRegion regionA,
HRegion regionB,
HRegion mergedRegion)
called after the regions merge.
|
void |
BaseRegionServerObserver.postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c,
HRegion regionA,
HRegion regionB,
HRegion mergedRegion) |
void |
RegionServerObserver.postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
HRegion regionA,
HRegion regionB,
HRegion mergedRegion)
This will be called after PONR step as part of regions merge transaction.
|
void |
BaseRegionServerObserver.postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
HRegion regionA,
HRegion regionB,
HRegion mergedRegion) |
void |
RegionServerObserver.postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
HRegion regionA,
HRegion regionB)
This will be called after the roll back of the regions merge.
|
void |
BaseRegionServerObserver.postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
HRegion regionA,
HRegion regionB) |
void |
RegionObserver.postSplit(ObserverContext<RegionCoprocessorEnvironment> c,
HRegion l,
HRegion r)
Deprecated.
Use postCompleteSplit() instead
|
void |
BaseRegionObserver.postSplit(ObserverContext<RegionCoprocessorEnvironment> e,
HRegion l,
HRegion r) |
void |
RegionServerObserver.preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
HRegion regionA,
HRegion regionB)
Called before the regions merge.
|
void |
BaseRegionServerObserver.preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
HRegion regionA,
HRegion regionB) |
void |
RegionServerObserver.preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
HRegion regionA,
HRegion regionB,
List<Mutation> metaEntries)
This will be called before PONR step as part of regions merge transaction.
|
void |
BaseRegionServerObserver.preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
HRegion regionA,
HRegion regionB,
List<Mutation> metaEntries) |
void |
RegionServerObserver.preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
HRegion regionA,
HRegion regionB)
This will be called before the roll back of the regions merge.
|
void |
BaseRegionServerObserver.preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
HRegion regionA,
HRegion regionB) |
Constructor and Description |
---|
FlushTableSubprocedure(ProcedureMember member,
ForeignExceptionDispatcher errorListener,
long wakeFrequency,
long timeout,
List<HRegion> regions,
String table,
org.apache.hadoop.hbase.procedure.flush.RegionServerFlushTableProcedureManager.FlushTableSubprocedurePool taskManager) |
Modifier and Type | Field and Description |
---|---|
protected HRegion |
RegionSplitPolicy.region
The region configured for this split policy.
|
Modifier and Type | Field and Description |
---|---|
protected Map<String,HRegion> |
HRegionServer.onlineRegions
Map of regions currently being served by this region server.
|
protected Map<String,HRegion> |
HRegionServer.recoveringRegions
Set of regions currently being in recovering state which means it can accept writes(edits from
previous failed region server) but not reads.
|
Modifier and Type | Method and Description |
---|---|
static HRegion |
HRegion.createHRegion(HRegionInfo info,
org.apache.hadoop.fs.Path rootDir,
org.apache.hadoop.conf.Configuration conf,
HTableDescriptor hTableDescriptor)
Convenience method creating new HRegions.
|
static HRegion |
HRegion.createHRegion(HRegionInfo info,
org.apache.hadoop.fs.Path rootDir,
org.apache.hadoop.conf.Configuration conf,
HTableDescriptor hTableDescriptor,
WAL wal) |
static HRegion |
HRegion.createHRegion(HRegionInfo info,
org.apache.hadoop.fs.Path rootDir,
org.apache.hadoop.conf.Configuration conf,
HTableDescriptor hTableDescriptor,
WAL wal,
boolean initialize)
Convenience method creating new HRegions.
|
static HRegion |
HRegion.createHRegion(HRegionInfo info,
org.apache.hadoop.fs.Path rootDir,
org.apache.hadoop.conf.Configuration conf,
HTableDescriptor hTableDescriptor,
WAL wal,
boolean initialize,
boolean ignoreWAL)
Convenience method creating new HRegions.
|
static HRegion |
HRegion.createHRegion(HRegionInfo info,
org.apache.hadoop.fs.Path rootDir,
org.apache.hadoop.fs.Path tableDir,
org.apache.hadoop.conf.Configuration conf,
HTableDescriptor hTableDescriptor,
WAL wal,
boolean initialize,
boolean ignoreWAL)
Convenience method creating new HRegions.
|
HRegion |
RegionMergeTransaction.execute(Server server,
RegionServerServices services)
Run the transaction.
|
HRegion |
HRegionServer.getFromOnlineRegions(String encodedRegionName) |
HRegion |
HStore.getHRegion() |
HRegion |
HRegionServer.getOnlineRegion(byte[] regionName) |
protected HRegion |
HRegionServer.getRegion(byte[] regionName)
Protected utility method for safely obtaining an HRegion handle.
|
protected HRegion |
HRegionServer.getRegionByEncodedName(byte[] regionName,
String encodedRegionName) |
HRegion |
HRegionServer.getRegionByEncodedName(String encodedRegionName) |
static HRegion |
HRegion.merge(HRegion a,
HRegion b)
Merge two regions whether they are adjacent or not.
|
static HRegion |
HRegion.mergeAdjacent(HRegion srcA,
HRegion srcB)
Merge two HRegions.
|
protected HRegion |
HRegion.openHRegion(CancelableProgressable reporter)
Open HRegion.
|
static HRegion |
HRegion.openHRegion(org.apache.hadoop.conf.Configuration conf,
org.apache.hadoop.fs.FileSystem fs,
org.apache.hadoop.fs.Path rootDir,
HRegionInfo info,
HTableDescriptor htd,
WAL wal)
Open a Region.
|
static HRegion |
HRegion.openHRegion(org.apache.hadoop.conf.Configuration conf,
org.apache.hadoop.fs.FileSystem fs,
org.apache.hadoop.fs.Path rootDir,
HRegionInfo info,
HTableDescriptor htd,
WAL wal,
RegionServerServices rsServices,
CancelableProgressable reporter)
Open a Region.
|
static HRegion |
HRegion.openHRegion(org.apache.hadoop.conf.Configuration conf,
org.apache.hadoop.fs.FileSystem fs,
org.apache.hadoop.fs.Path rootDir,
org.apache.hadoop.fs.Path tableDir,
HRegionInfo info,
HTableDescriptor htd,
WAL wal,
RegionServerServices rsServices,
CancelableProgressable reporter)
Open a Region.
|
static HRegion |
HRegion.openHRegion(HRegion other,
CancelableProgressable reporter)
Useful when reopening a closed region (normally for unit tests)
|
static HRegion |
HRegion.openHRegion(HRegionInfo info,
HTableDescriptor htd,
WAL wal,
org.apache.hadoop.conf.Configuration conf)
Open a Region.
|
static HRegion |
HRegion.openHRegion(HRegionInfo info,
HTableDescriptor htd,
WAL wal,
org.apache.hadoop.conf.Configuration conf,
RegionServerServices rsServices,
CancelableProgressable reporter)
Open a Region.
|
static HRegion |
HRegion.openHRegion(org.apache.hadoop.fs.Path rootDir,
HRegionInfo info,
HTableDescriptor htd,
WAL wal,
org.apache.hadoop.conf.Configuration conf)
Open a Region.
|
static HRegion |
HRegion.openHRegion(org.apache.hadoop.fs.Path rootDir,
HRegionInfo info,
HTableDescriptor htd,
WAL wal,
org.apache.hadoop.conf.Configuration conf,
RegionServerServices rsServices,
CancelableProgressable reporter)
Open a Region.
|
HRegion |
RegionMergeTransaction.stepsAfterPONR(Server server,
RegionServerServices services,
HRegion mergedRegion) |
HRegion |
RegionMergeTransaction.stepsBeforePONR(Server server,
RegionServerServices services,
boolean testing) |
Modifier and Type | Method and Description |
---|---|
PairOfSameType<HRegion> |
SplitTransaction.execute(Server server,
RegionServerServices services)
Run the transaction.
|
List<HRegion> |
HRegionServer.getOnlineRegions(TableName tableName)
Gets the online regions of the specified table.
|
Collection<HRegion> |
HRegionServer.getOnlineRegionsLocalContext()
For tests, web ui and metrics.
|
Map<String,HRegion> |
RegionServerServices.getRecoveringRegions() |
Map<String,HRegion> |
HRegionServer.getRecoveringRegions() |
PairOfSameType<HRegion> |
SplitTransaction.stepsAfterPONR(Server server,
RegionServerServices services,
PairOfSameType<HRegion> regions) |
PairOfSameType<HRegion> |
SplitTransaction.stepsBeforePONR(Server server,
RegionServerServices services,
boolean testing) |
Modifier and Type | Method and Description |
---|---|
static void |
HRegion.addRegionToMETA(HRegion meta,
HRegion r)
Inserts a new region's meta information into the passed
meta region. |
void |
HRegionServer.addToOnlineRegions(HRegion region) |
static void |
HRegion.closeHRegion(HRegion r)
This will do the necessary cleanup a call to
createHRegion(HRegionInfo, Path, Configuration, HTableDescriptor)
requires. |
protected void |
RegionSplitPolicy.configureForRegion(HRegion region)
Upon construction, this method will be called with the region
to be governed.
|
protected void |
KeyPrefixRegionSplitPolicy.configureForRegion(HRegion region) |
protected void |
IncreasingToUpperBoundRegionSplitPolicy.configureForRegion(HRegion region) |
protected void |
DelimitedKeyPrefixRegionSplitPolicy.configureForRegion(HRegion region) |
protected void |
ConstantSizeRegionSplitPolicy.configureForRegion(HRegion region) |
static RegionSplitPolicy |
RegionSplitPolicy.create(HRegion region,
org.apache.hadoop.conf.Configuration conf)
Create the RegionSplitPolicy configured for the given table.
|
void |
FlushRequestListener.flushRequested(org.apache.hadoop.hbase.regionserver.FlushType type,
HRegion region)
Callback which will get called when a flush request is made for a region.
|
static HRegion |
HRegion.merge(HRegion a,
HRegion b)
Merge two regions whether they are adjacent or not.
|
static HRegion |
HRegion.mergeAdjacent(HRegion srcA,
HRegion srcB)
Merge two HRegions.
|
static HRegion |
HRegion.openHRegion(HRegion other,
CancelableProgressable reporter)
Useful when reopening a closed region (normally for unit tests)
|
void |
RowProcessor.postBatchMutate(HRegion region)
The hook to be executed after the process() and applying the Mutations to region.
|
void |
BaseRowProcessor.postBatchMutate(HRegion region) |
void |
RegionServerCoprocessorHost.postMerge(HRegion regionA,
HRegion regionB,
HRegion mergedRegion) |
void |
RegionServerCoprocessorHost.postMergeCommit(HRegion regionA,
HRegion regionB,
HRegion mergedRegion) |
void |
RegionServerServices.postOpenDeployTasks(HRegion r)
Tasks to perform after region open to complete deploy of region on
regionserver
|
void |
HRegionServer.postOpenDeployTasks(HRegion r) |
void |
RowProcessor.postProcess(HRegion region,
WALEdit walEdit,
boolean success)
The hook to be executed after process() and applying the Mutations to region.
|
void |
BaseRowProcessor.postProcess(HRegion region,
WALEdit walEdit,
boolean success) |
void |
RegionServerCoprocessorHost.postRollBackMerge(HRegion regionA,
HRegion regionB) |
void |
RegionCoprocessorHost.postSplit(HRegion l,
HRegion r)
Invoked just after a split
|
void |
RowProcessor.preBatchMutate(HRegion region,
WALEdit walEdit)
The hook to be executed after the process() but before applying the Mutations to region.
|
void |
BaseRowProcessor.preBatchMutate(HRegion region,
WALEdit walEdit) |
boolean |
RegionServerCoprocessorHost.preMerge(HRegion regionA,
HRegion regionB) |
boolean |
RegionServerCoprocessorHost.preMergeCommit(HRegion regionA,
HRegion regionB,
List<Mutation> metaEntries) |
void |
RowProcessor.preProcess(HRegion region,
WALEdit walEdit)
The hook to be executed before process().
|
void |
BaseRowProcessor.preProcess(HRegion region,
WALEdit walEdit) |
void |
RegionServerCoprocessorHost.preRollBackMerge(HRegion regionA,
HRegion regionB) |
void |
RowProcessor.process(long now,
HRegion region,
List<Mutation> mutations,
WALEdit walEdit)
HRegion handles the locks and MVCC and invokes this method properly.
|
boolean |
HRegionServer.removeFromOnlineRegions(HRegion r,
ServerName destination) |
CompactionRequest |
CompactSplitThread.requestCompaction(HRegion r,
Store s,
String why,
CompactionRequest request) |
CompactionRequest |
CompactionRequestor.requestCompaction(HRegion r,
Store s,
String why,
CompactionRequest request) |
CompactionRequest |
CompactSplitThread.requestCompaction(HRegion r,
Store s,
String why,
int priority,
CompactionRequest request) |
CompactionRequest |
CompactionRequestor.requestCompaction(HRegion r,
Store s,
String why,
int pri,
CompactionRequest request) |
List<CompactionRequest> |
CompactSplitThread.requestCompaction(HRegion r,
String why) |
List<CompactionRequest> |
CompactionRequestor.requestCompaction(HRegion r,
String why) |
List<CompactionRequest> |
CompactSplitThread.requestCompaction(HRegion r,
String why,
int p,
List<Pair<CompactionRequest,Store>> requests) |
List<CompactionRequest> |
CompactionRequestor.requestCompaction(HRegion r,
String why,
int pri,
List<Pair<CompactionRequest,Store>> requests) |
List<CompactionRequest> |
CompactSplitThread.requestCompaction(HRegion r,
String why,
List<Pair<CompactionRequest,Store>> requests) |
List<CompactionRequest> |
CompactionRequestor.requestCompaction(HRegion r,
String why,
List<Pair<CompactionRequest,Store>> requests) |
void |
FlushRequester.requestDelayedFlush(HRegion region,
long delay)
Tell the listener the cache needs to be flushed after a delay
|
void |
FlushRequester.requestFlush(HRegion region)
Tell the listener the cache needs to be flushed.
|
void |
CompactSplitThread.requestRegionsMerge(HRegion a,
HRegion b,
boolean forcible) |
boolean |
CompactSplitThread.requestSplit(HRegion r) |
void |
CompactSplitThread.requestSplit(HRegion r,
byte[] midKey) |
void |
CompactSplitThread.requestSystemCompaction(HRegion r,
Store s,
String why) |
void |
CompactSplitThread.requestSystemCompaction(HRegion r,
String why) |
HRegion |
RegionMergeTransaction.stepsAfterPONR(Server server,
RegionServerServices services,
HRegion mergedRegion) |
Modifier and Type | Method and Description |
---|---|
PairOfSameType<HRegion> |
SplitTransaction.stepsAfterPONR(Server server,
RegionServerServices services,
PairOfSameType<HRegion> regions) |
Constructor and Description |
---|
HStore(HRegion region,
HColumnDescriptor family,
org.apache.hadoop.conf.Configuration confParam)
Constructor
|
MetricsRegionWrapperImpl(HRegion region) |
RegionCoprocessorHost(HRegion region,
RegionServerServices rsServices,
org.apache.hadoop.conf.Configuration conf)
Constructor
|
RegionMergeTransaction(HRegion a,
HRegion b,
boolean forcible)
Constructor
|
SplitTransaction(HRegion r,
byte[] splitrow)
Constructor
|
Constructor and Description |
---|
FlushSnapshotSubprocedure(ProcedureMember member,
ForeignExceptionDispatcher errorListener,
long wakeFrequency,
long timeout,
List<HRegion> regions,
HBaseProtos.SnapshotDescription snapshot,
org.apache.hadoop.hbase.regionserver.snapshot.RegionServerSnapshotManager.SnapshotSubprocedurePool taskManager) |
Modifier and Type | Method and Description |
---|---|
HRegion |
AccessController.getRegion() |
Modifier and Type | Method and Description |
---|---|
void |
AccessController.postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c,
HRegion regionA,
HRegion regionB,
HRegion mergedRegion) |
void |
AccessController.postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
HRegion regionA,
HRegion regionB,
HRegion mergedRegion) |
void |
AccessController.postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
HRegion regionA,
HRegion regionB) |
void |
AccessController.preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
HRegion regionA,
HRegion regionB) |
void |
AccessController.preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
HRegion regionA,
HRegion regionB,
List<Mutation> metaEntries) |
void |
AccessController.preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
HRegion regionA,
HRegion regionB) |
Modifier and Type | Method and Description |
---|---|
protected void |
DefaultVisibilityLabelServiceImpl.addSystemLabel(HRegion region,
Map<String,Integer> labels,
Map<String,List<Integer>> userAuths) |
static Filter |
VisibilityUtils.createVisibilityLabelFilter(HRegion region,
Authorizations authorizations) |
Modifier and Type | Method and Description |
---|---|
void |
SnapshotManifest.addRegion(HRegion region)
Creates a 'manifest' for the specified region, by reading directly from the HRegion object.
|
Modifier and Type | Method and Description |
---|---|
static HRegion |
HBaseFsckRepair.createHDFSRegionDir(org.apache.hadoop.conf.Configuration conf,
HRegionInfo hri,
HTableDescriptor htd)
Creates, flushes, and closes a new region.
|
HRegion |
MetaUtils.getMetaRegion() |
Modifier and Type | Method and Description |
---|---|
void |
ModifyRegionUtils.RegionFillTask.fillRegion(HRegion region) |
static boolean |
ServerRegionReplicaUtil.isReadOnly(HRegion region)
Returns whether this region replica can accept writes.
|
static boolean |
ServerRegionReplicaUtil.shouldReplayRecoveredEdits(HRegion region)
Returns whether to replay the recovered edits to flush the results.
|
Copyright © 2015 The Apache Software Foundation. All rights reserved.