Uses of Class
org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv

Packages that use MasterProcedureEnv

Package	Description
org.apache.hadoop.hbase.master
org.apache.hadoop.hbase.master.assignment
org.apache.hadoop.hbase.master.locking
org.apache.hadoop.hbase.master.migrate
org.apache.hadoop.hbase.master.procedure
org.apache.hadoop.hbase.master.replication
org.apache.hadoop.hbase.procedure2
org.apache.hadoop.hbase.regionserver
org.apache.hadoop.hbase.regionserver.storefiletracker
org.apache.hadoop.hbase.rsgroup

Uses of MasterProcedureEnv in org.apache.hadoop.hbase.master

Fields in org.apache.hadoop.hbase.master with type parameters of type MasterProcedureEnv

Modifier and Type	Field	Description
private ProcedureExecutor<MasterProcedureEnv>	HMaster.procedureExecutor

Methods in org.apache.hadoop.hbase.master that return types with arguments of type MasterProcedureEnv

Modifier and Type	Method	Description
ProcedureExecutor<MasterProcedureEnv>	HMaster.getMasterProcedureExecutor()
ProcedureExecutor<MasterProcedureEnv>	MasterServices.getMasterProcedureExecutor()	Returns Master's instance of ProcedureExecutor
private RemoteProcedureDispatcher.RemoteProcedure<MasterProcedureEnv,?>	HMaster.getRemoteProcedure(long procId)

Method parameters in org.apache.hadoop.hbase.master with type arguments of type MasterProcedureEnv

Modifier and Type	Method	Description
void	MasterCoprocessorHost.preAbortProcedure(ProcedureExecutor<MasterProcedureEnv> procEnv, long procId)
private long	ClusterSchemaServiceImpl.submitProcedure(Procedure<MasterProcedureEnv> procedure, NonceKey nonceKey)

Uses of MasterProcedureEnv in org.apache.hadoop.hbase.master.assignment

Methods in org.apache.hadoop.hbase.master.assignment that return MasterProcedureEnv

Modifier and Type	Method	Description
private MasterProcedureEnv	AssignmentManager.getProcedureEnvironment()

Methods in org.apache.hadoop.hbase.master.assignment that return types with arguments of type MasterProcedureEnv

Modifier and Type	Method	Description
protected Procedure<MasterProcedureEnv>[]	RegionRemoteProcedureBase.execute(MasterProcedureEnv env)

Methods in org.apache.hadoop.hbase.master.assignment with parameters of type MasterProcedureEnv

Modifier and Type	Method	Description
protected boolean	MergeTableRegionsProcedure.abort(MasterProcedureEnv env)
boolean	MoveRegionProcedure.abort(MasterProcedureEnv env)	Deprecated.
protected boolean	RegionRemoteProcedureBase.abort(MasterProcedureEnv env)
protected boolean	RegionTransitionProcedure.abort(MasterProcedureEnv env)	Deprecated.
protected boolean	SplitTableRegionProcedure.abort(MasterProcedureEnv env)
protected Procedure.LockState	GCMultipleMergedRegionsProcedure.acquireLock(MasterProcedureEnv env)
protected Procedure.LockState	MergeTableRegionsProcedure.acquireLock(MasterProcedureEnv env)
protected Procedure.LockState	SplitTableRegionProcedure.acquireLock(MasterProcedureEnv env)
protected void	RegionRemoteProcedureBase.afterExec(MasterProcedureEnv env)
protected void	TransitRegionStateProcedure.afterExec(MasterProcedureEnv env)
protected void	RegionRemoteProcedureBase.afterReplay(MasterProcedureEnv env)
static TransitRegionStateProcedure	TransitRegionStateProcedure.assign(MasterProcedureEnv env, RegionInfo region, boolean forceNewPlan, ServerName targetServer)
static TransitRegionStateProcedure	TransitRegionStateProcedure.assign(MasterProcedureEnv env, RegionInfo region, ServerName targetServer)
protected void	RegionRemoteProcedureBase.beforeExec(MasterProcedureEnv env)
protected void	TransitRegionStateProcedure.beforeExec(MasterProcedureEnv env)
private void	TransitRegionStateProcedure.checkAndWaitForOriginalServer(MasterProcedureEnv env, ServerName lastHost)
(package private) static void	AssignmentManagerUtil.checkClosedRegion(MasterProcedureEnv env, RegionInfo regionInfo)
private void	MergeTableRegionsProcedure.checkClosedRegions(MasterProcedureEnv env)
private void	SplitTableRegionProcedure.checkClosedRegions(MasterProcedureEnv env)
private static void	MergeTableRegionsProcedure.checkRegionsToMerge(MasterProcedureEnv env, RegionInfo[] regions, boolean force)
private void	SplitTableRegionProcedure.checkSplittable(MasterProcedureEnv env, RegionInfo regionToSplit)	Check whether the region is splittable
private void	MergeTableRegionsProcedure.cleanupMergedRegion(MasterProcedureEnv env)	Clean up a merged region on rollback after failure.
private void	TransitRegionStateProcedure.closeRegion(MasterProcedureEnv env, RegionStateNode regionNode)
private void	TransitRegionStateProcedure.closeRegionAfterUpdatingMeta(MasterProcedureEnv env, RegionStateNode regionNode)
private StateMachineProcedure.Flow	TransitRegionStateProcedure.confirmClosed(MasterProcedureEnv env, RegionStateNode regionNode)
private StateMachineProcedure.Flow	TransitRegionStateProcedure.confirmOpened(MasterProcedureEnv env, RegionStateNode regionNode)
private static TransitRegionStateProcedure[]	AssignmentManagerUtil.createAssignProcedures(MasterProcedureEnv env, List<RegionInfo> regions, int regionReplication, ServerName targetServer, boolean ignoreIfInTransition)	Create assign procedures for the give regions, according to the regionReplication.
private TransitRegionStateProcedure[]	MergeTableRegionsProcedure.createAssignProcedures(MasterProcedureEnv env)
private TransitRegionStateProcedure[]	SplitTableRegionProcedure.createAssignProcedures(MasterProcedureEnv env)
(package private) static TransitRegionStateProcedure[]	AssignmentManagerUtil.createAssignProceduresForOpeningNewRegions(MasterProcedureEnv env, List<RegionInfo> regions, int regionReplication, ServerName targetServer)
(package private) static TransitRegionStateProcedure[]	AssignmentManagerUtil.createAssignProceduresForSplitDaughters(MasterProcedureEnv env, List<RegionInfo> daughters, int regionReplication, ServerName parentServer)
void	SplitTableRegionProcedure.createDaughterRegions(MasterProcedureEnv env)	Create daughter regions
private GCRegionProcedure[]	GCMergedRegionsProcedure.createGCRegionProcedures(MasterProcedureEnv env)	Deprecated.
private GCRegionProcedure[]	GCMultipleMergedRegionsProcedure.createGCRegionProcedures(MasterProcedureEnv env)
private void	MergeTableRegionsProcedure.createMergedRegion(MasterProcedureEnv env)	Create merged region.
private static TransitRegionStateProcedure[]	AssignmentManagerUtil.createRoundRobinAssignProcedures(MasterProcedureEnv env, List<RegionInfo> regions, int regionReplication, List<ServerName> serversToExclude, boolean ignoreIfInTransition)	Create round robin assign procedures for the given regions, according to the regionReplication.
private TransitRegionStateProcedure[]	MergeTableRegionsProcedure.createUnassignProcedures(MasterProcedureEnv env)
private TransitRegionStateProcedure[]	SplitTableRegionProcedure.createUnassignProcedures(MasterProcedureEnv env)
(package private) static TransitRegionStateProcedure[]	AssignmentManagerUtil.createUnassignProceduresForSplitOrMerge(MasterProcedureEnv env, Stream<RegionInfo> regions, int regionReplication)
private void	SplitTableRegionProcedure.deleteDaughterRegions(MasterProcedureEnv env)
protected Procedure<MasterProcedureEnv>[]	RegionRemoteProcedureBase.execute(MasterProcedureEnv env)
protected Procedure[]	RegionTransitionProcedure.execute(MasterProcedureEnv env)	Deprecated.
protected StateMachineProcedure.Flow	GCMergedRegionsProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.GCMergedRegionsState state)	Deprecated.
protected StateMachineProcedure.Flow	GCMultipleMergedRegionsProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.GCMergedRegionsState state)
protected StateMachineProcedure.Flow	GCRegionProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.GCRegionState state)
protected StateMachineProcedure.Flow	MergeTableRegionsProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.MergeTableRegionsState state)
protected StateMachineProcedure.Flow	MoveRegionProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.MoveRegionState state)	Deprecated.
protected StateMachineProcedure.Flow	SplitTableRegionProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.SplitTableRegionState state)
protected StateMachineProcedure.Flow	TransitRegionStateProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.RegionStateTransitionState state)
protected void	AssignProcedure.finishTransition(MasterProcedureEnv env, RegionStateNode regionNode)	Deprecated.
protected abstract void	RegionTransitionProcedure.finishTransition(MasterProcedureEnv env, RegionStateNode regionNode)	Deprecated.
protected void	UnassignProcedure.finishTransition(MasterProcedureEnv env, RegionStateNode regionNode)	Deprecated.
private TransitRegionStateProcedure	RegionRemoteProcedureBase.getParent(MasterProcedureEnv env)
private ServerName	SplitTableRegionProcedure.getParentRegionServerName(MasterProcedureEnv env)
protected ProcedureMetrics	AssignProcedure.getProcedureMetrics(MasterProcedureEnv env)	Deprecated.
protected ProcedureMetrics	CloseRegionProcedure.getProcedureMetrics(MasterProcedureEnv env)
protected ProcedureMetrics	MergeTableRegionsProcedure.getProcedureMetrics(MasterProcedureEnv env)
protected ProcedureMetrics	OpenRegionProcedure.getProcedureMetrics(MasterProcedureEnv env)
protected ProcedureMetrics	SplitTableRegionProcedure.getProcedureMetrics(MasterProcedureEnv env)
protected ProcedureMetrics	TransitRegionStateProcedure.getProcedureMetrics(MasterProcedureEnv env)
protected ProcedureMetrics	UnassignProcedure.getProcedureMetrics(MasterProcedureEnv env)	Deprecated.
(package private) static org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetRegionInfoResponse	AssignmentManagerUtil.getRegionInfoResponse(MasterProcedureEnv env, ServerName regionLocation, RegionInfo hri)	Raw call to remote regionserver to get info on a particular region.
(package private) static org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetRegionInfoResponse	AssignmentManagerUtil.getRegionInfoResponse(MasterProcedureEnv env, ServerName regionLocation, RegionInfo hri, boolean includeBestSplitRow)
private RegionStateNode	RegionRemoteProcedureBase.getRegionNode(MasterProcedureEnv env)
private int	MergeTableRegionsProcedure.getRegionReplication(MasterProcedureEnv env)
private int	SplitTableRegionProcedure.getRegionReplication(MasterProcedureEnv env)
RegionStateNode	RegionTransitionProcedure.getRegionState(MasterProcedureEnv env)	Deprecated.
private RegionStateNode	TransitRegionStateProcedure.getRegionStateNode(MasterProcedureEnv env)
private ServerName	MergeTableRegionsProcedure.getServerName(MasterProcedureEnv env)	The procedure could be restarted from a different machine.
protected boolean	GCMultipleMergedRegionsProcedure.holdLock(MasterProcedureEnv env)
protected boolean	MergeTableRegionsProcedure.holdLock(MasterProcedureEnv env)
private void	TransitRegionStateProcedure.initForceRetainmentRetryCounter(MasterProcedureEnv env)
private boolean	MergeTableRegionsProcedure.isMergeable(MasterProcedureEnv env, RegionState rs)
private List<org.apache.hadoop.fs.Path>	MergeTableRegionsProcedure.mergeStoreFiles(MasterProcedureEnv env, HRegionFileSystem regionFs, HRegionFileSystem mergeRegionFs, RegionInfo mergedRegion)
static TransitRegionStateProcedure	TransitRegionStateProcedure.move(MasterProcedureEnv env, RegionInfo region, ServerName targetServer)
RemoteProcedureDispatcher.RemoteOperation	CloseRegionProcedure.newRemoteOperation(MasterProcedureEnv env)
RemoteProcedureDispatcher.RemoteOperation	OpenRegionProcedure.newRemoteOperation(MasterProcedureEnv env)
protected abstract RemoteProcedureDispatcher.RemoteOperation	RegionRemoteProcedureBase.newRemoteOperation(MasterProcedureEnv env)
private void	SplitTableRegionProcedure.openParentRegion(MasterProcedureEnv env)	Rollback close parent region
private void	TransitRegionStateProcedure.openRegion(MasterProcedureEnv env, RegionStateNode regionNode)
protected void	AssignmentManager.DeadServerMetricRegionChore.periodicExecute(MasterProcedureEnv env)
protected void	AssignmentManager.RegionInTransitionChore.periodicExecute(MasterProcedureEnv env)
private void	RegionRemoteProcedureBase.persistAndWake(MasterProcedureEnv env, RegionStateNode regionNode)
private void	MergeTableRegionsProcedure.postCompletedMergeRegions(MasterProcedureEnv env)	Post merge region action
private void	MergeTableRegionsProcedure.postMergeRegionsCommit(MasterProcedureEnv env)	Post merge region action
private void	MergeTableRegionsProcedure.postRollBackMergeRegions(MasterProcedureEnv env)	Action after rollback a merge table regions action.
private void	SplitTableRegionProcedure.postRollBackSplitRegion(MasterProcedureEnv env)	Action after rollback a split table region action.
private void	SplitTableRegionProcedure.postSplitRegion(MasterProcedureEnv env)	Post split region actions
private void	MergeTableRegionsProcedure.preMergeRegions(MasterProcedureEnv env)	Pre merge region action
private void	MergeTableRegionsProcedure.preMergeRegionsCommit(MasterProcedureEnv env)	Post merge region action
private boolean	MergeTableRegionsProcedure.prepareMergeRegion(MasterProcedureEnv env)	Prepare merge and do some check
boolean	SplitTableRegionProcedure.prepareSplitRegion(MasterProcedureEnv env)	Prepare to Split region.
private void	SplitTableRegionProcedure.preSplitRegion(MasterProcedureEnv env)	Action before splitting region in a table.
private void	SplitTableRegionProcedure.preSplitRegionAfterMETA(MasterProcedureEnv env)	Pre split region actions after the Point-of-No-Return step
private void	SplitTableRegionProcedure.preSplitRegionBeforeMETA(MasterProcedureEnv env)	Post split region actions before the Point-of-No-Return step
private void	TransitRegionStateProcedure.queueAssign(MasterProcedureEnv env, RegionStateNode regionNode)
private void	TransitRegionStateProcedure.regionFailedOpenAfterUpdatingMeta(MasterProcedureEnv env, RegionStateNode regionNode)
protected void	GCMultipleMergedRegionsProcedure.releaseLock(MasterProcedureEnv env)
protected void	MergeTableRegionsProcedure.releaseLock(MasterProcedureEnv env)
protected void	SplitTableRegionProcedure.releaseLock(MasterProcedureEnv env)
Optional<RemoteProcedureDispatcher.RemoteOperation>	AssignProcedure.remoteCallBuild(MasterProcedureEnv env, ServerName serverName)	Deprecated.
Optional<RemoteProcedureDispatcher.RemoteOperation>	RegionRemoteProcedureBase.remoteCallBuild(MasterProcedureEnv env, ServerName remote)
abstract Optional<RemoteProcedureDispatcher.RemoteOperation>	RegionTransitionProcedure.remoteCallBuild(MasterProcedureEnv env, ServerName serverName)	Deprecated.
Optional<RemoteProcedureDispatcher.RemoteOperation>	UnassignProcedure.remoteCallBuild(MasterProcedureEnv env, ServerName serverName)	Deprecated.
protected boolean	AssignProcedure.remoteCallFailed(MasterProcedureEnv env, RegionStateNode regionNode, IOException exception)	Deprecated.
void	RegionRemoteProcedureBase.remoteCallFailed(MasterProcedureEnv env, ServerName remote, IOException exception)
protected abstract boolean	RegionTransitionProcedure.remoteCallFailed(MasterProcedureEnv env, RegionStateNode regionNode, IOException exception)	Deprecated.
void	RegionTransitionProcedure.remoteCallFailed(MasterProcedureEnv env, ServerName serverName, IOException exception)	Deprecated.
protected boolean	UnassignProcedure.remoteCallFailed(MasterProcedureEnv env, RegionStateNode regionNode, IOException exception)	Deprecated. Returns If true, we will re-wake up this procedure; if false, the procedure stays suspended.
void	RegionRemoteProcedureBase.remoteOperationCompleted(MasterProcedureEnv env, byte[] remoteResultData)
void	RegionTransitionProcedure.remoteOperationCompleted(MasterProcedureEnv env, byte[] remoteResultData)	Deprecated.
void	RegionRemoteProcedureBase.remoteOperationFailed(MasterProcedureEnv env, RemoteProcedureException error)
void	RegionTransitionProcedure.remoteOperationFailed(MasterProcedureEnv env, RemoteProcedureException error)	Deprecated.
(package private) static void	AssignmentManagerUtil.removeNonDefaultReplicas(MasterProcedureEnv env, Stream<RegionInfo> regions, int regionReplication)
private void	MergeTableRegionsProcedure.removeNonDefaultReplicas(MasterProcedureEnv env)
private void	SplitTableRegionProcedure.removeNonDefaultReplicas(MasterProcedureEnv env)
static TransitRegionStateProcedure	TransitRegionStateProcedure.reopen(MasterProcedureEnv env, RegionInfo region)
(package private) static void	AssignmentManagerUtil.reopenRegionsForRollback(MasterProcedureEnv env, List<RegionInfo> regions, int regionReplication, ServerName targetServer)
protected void	AssignProcedure.reportTransition(MasterProcedureEnv env, RegionStateNode regionNode, org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code, long openSeqNum)	Deprecated.
(package private) void	RegionRemoteProcedureBase.reportTransition(MasterProcedureEnv env, RegionStateNode regionNode, ServerName serverName, org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode transitionCode, long seqId)
protected abstract void	RegionTransitionProcedure.reportTransition(MasterProcedureEnv env, RegionStateNode regionNode, org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code, long seqId)	Deprecated.
void	TransitRegionStateProcedure.reportTransition(MasterProcedureEnv env, RegionStateNode regionNode, ServerName serverName, org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code, long seqId, long procId)
protected void	UnassignProcedure.reportTransition(MasterProcedureEnv env, RegionStateNode regionNode, org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code, long seqId)	Deprecated.
protected void	RegionRemoteProcedureBase.rollback(MasterProcedureEnv env)
protected void	RegionTransitionProcedure.rollback(MasterProcedureEnv env)	Deprecated.
private void	MergeTableRegionsProcedure.rollbackCloseRegionsForMerge(MasterProcedureEnv env)	Rollback close regions
private void	MergeTableRegionsProcedure.rollbackPrepareMerge(MasterProcedureEnv env)	Action for rollback a merge table after prepare merge
private void	SplitTableRegionProcedure.rollbackPrepareSplit(MasterProcedureEnv env)	Rollback prepare split region
protected void	GCMergedRegionsProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.GCMergedRegionsState state)	Deprecated.
protected void	GCMultipleMergedRegionsProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.GCMergedRegionsState state)
protected void	GCRegionProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.GCRegionState state)
protected void	MergeTableRegionsProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.MergeTableRegionsState state)	To rollback MergeTableRegionsProcedure, two AssignProcedures are asynchronously submitted for each region to be merged (rollback doesn't wait on the completion of the AssignProcedures) .
protected void	MoveRegionProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.MoveRegionState state)	Deprecated.
protected void	SplitTableRegionProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.SplitTableRegionState state)	To rollback SplitTableRegionProcedure, an AssignProcedure is asynchronously submitted for parent region to be split (rollback doesn't wait on the completion of the AssignProcedure) .
protected void	TransitRegionStateProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.RegionStateTransitionState state)
(package private) void	RegionRemoteProcedureBase.serverCrashed(MasterProcedureEnv env, RegionStateNode regionNode, ServerName serverName)
CompletableFuture<Void>	TransitRegionStateProcedure.serverCrashed(MasterProcedureEnv env, RegionStateNode regionNode, ServerName serverName, boolean forceNewPlan)
private static TransitRegionStateProcedure	TransitRegionStateProcedure.setOwner(MasterProcedureEnv env, TransitRegionStateProcedure proc)
private void	MergeTableRegionsProcedure.setRegionStateToMerging(MasterProcedureEnv env)	Set the region states to MERGING state
protected boolean	RegionRemoteProcedureBase.setTimeoutFailure(MasterProcedureEnv env)
protected boolean	TransitRegionStateProcedure.setTimeoutFailure(MasterProcedureEnv env)	At end of timeout, wake ourselves up so we run again.
private Pair<List<org.apache.hadoop.fs.Path>,List<org.apache.hadoop.fs.Path>>	SplitTableRegionProcedure.splitStoreFiles(MasterProcedureEnv env, HRegionFileSystem regionFs)	Create Split directory
protected boolean	AssignProcedure.startTransition(MasterProcedureEnv env, RegionStateNode regionNode)	Deprecated.
protected abstract boolean	RegionTransitionProcedure.startTransition(MasterProcedureEnv env, RegionStateNode regionNode)	Deprecated.
protected boolean	UnassignProcedure.startTransition(MasterProcedureEnv env, RegionStateNode regionNode)	Deprecated.
static TransitRegionStateProcedure	TransitRegionStateProcedure.unassign(MasterProcedureEnv env, RegionInfo region)
static TransitRegionStateProcedure	TransitRegionStateProcedure.unassignSplitMerge(MasterProcedureEnv env, RegionInfo region)
private void	RegionRemoteProcedureBase.unattach(MasterProcedureEnv env)
private void	SplitTableRegionProcedure.updateMeta(MasterProcedureEnv env)	Add daughter regions to META
private void	MergeTableRegionsProcedure.updateMetaForMergedRegions(MasterProcedureEnv env)	Add merged region to META and delete original regions.
protected boolean	AssignProcedure.updateTransition(MasterProcedureEnv env, RegionStateNode regionNode)	Deprecated.
protected abstract boolean	RegionTransitionProcedure.updateTransition(MasterProcedureEnv env, RegionStateNode regionNode)	Deprecated.
protected boolean	UnassignProcedure.updateTransition(MasterProcedureEnv env, RegionStateNode regionNode)	Deprecated.
protected void	CloseRegionProcedure.updateTransitionWithoutPersistingToMeta(MasterProcedureEnv env, RegionStateNode regionNode, org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode transitionCode, long seqId)
protected void	OpenRegionProcedure.updateTransitionWithoutPersistingToMeta(MasterProcedureEnv env, RegionStateNode regionNode, org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode transitionCode, long openSeqNum)
protected abstract void	RegionRemoteProcedureBase.updateTransitionWithoutPersistingToMeta(MasterProcedureEnv env, RegionStateNode regionNode, org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode transitionCode, long seqId)
protected boolean	RegionRemoteProcedureBase.waitInitialized(MasterProcedureEnv env)
protected boolean	TransitRegionStateProcedure.waitInitialized(MasterProcedureEnv env)
private void	MergeTableRegionsProcedure.writeMaxSequenceIdFile(MasterProcedureEnv env)
private void	SplitTableRegionProcedure.writeMaxSequenceIdFile(MasterProcedureEnv env)

Constructors in org.apache.hadoop.hbase.master.assignment with parameters of type MasterProcedureEnv

Modifier	Constructor	Description
	GCMergedRegionsProcedure(MasterProcedureEnv env, RegionInfo mergedChild, RegionInfo father, RegionInfo mother)	Deprecated.
	GCMultipleMergedRegionsProcedure(MasterProcedureEnv env, RegionInfo mergedChild, List<RegionInfo> parents)
	GCRegionProcedure(MasterProcedureEnv env, RegionInfo hri)
	MergeTableRegionsProcedure(MasterProcedureEnv env, RegionInfo[] regionsToMerge, boolean force)
	SplitTableRegionProcedure(MasterProcedureEnv env, RegionInfo regionToSplit, byte[] splitRow)
protected	TransitRegionStateProcedure(MasterProcedureEnv env, RegionInfo hri, ServerName assignCandidate, boolean forceNewPlan, TransitRegionStateProcedure.TransitionType type)
protected	TransitRegionStateProcedure(MasterProcedureEnv env, RegionInfo hri, ServerName assignCandidate, boolean forceNewPlan, TransitRegionStateProcedure.TransitionType type, boolean isSplit)

Uses of MasterProcedureEnv in org.apache.hadoop.hbase.master.locking

Methods in org.apache.hadoop.hbase.master.locking that return types with arguments of type MasterProcedureEnv

Modifier and Type	Method	Description
protected Procedure<MasterProcedureEnv>[]	LockProcedure.execute(MasterProcedureEnv env)

Methods in org.apache.hadoop.hbase.master.locking with parameters of type MasterProcedureEnv

Modifier and Type	Method	Description
protected boolean	LockProcedure.abort(MasterProcedureEnv env)
protected Procedure.LockState	LockProcedure.acquireLock(MasterProcedureEnv env)
boolean	LockProcedure.LockInterface.acquireLock(MasterProcedureEnv env)
boolean	LockProcedure.NamespaceExclusiveLock.acquireLock(MasterProcedureEnv env)
boolean	LockProcedure.RegionExclusiveLock.acquireLock(MasterProcedureEnv env)
boolean	LockProcedure.TableExclusiveLock.acquireLock(MasterProcedureEnv env)
boolean	LockProcedure.TableSharedLock.acquireLock(MasterProcedureEnv env)
protected void	LockProcedure.beforeReplay(MasterProcedureEnv env)	On recovery, re-execute from start to acquire the locks.
protected Procedure<MasterProcedureEnv>[]	LockProcedure.execute(MasterProcedureEnv env)
boolean	LockProcedure.holdLock(MasterProcedureEnv env)
void	LockProcedure.LockInterface.releaseLock(MasterProcedureEnv env)
void	LockProcedure.NamespaceExclusiveLock.releaseLock(MasterProcedureEnv env)
void	LockProcedure.RegionExclusiveLock.releaseLock(MasterProcedureEnv env)
protected void	LockProcedure.releaseLock(MasterProcedureEnv env)
void	LockProcedure.TableExclusiveLock.releaseLock(MasterProcedureEnv env)
void	LockProcedure.TableSharedLock.releaseLock(MasterProcedureEnv env)
protected void	LockProcedure.rollback(MasterProcedureEnv env)
protected boolean	LockProcedure.setTimeoutFailure(MasterProcedureEnv env)	Re run the procedure after every timeout to write new WAL entries so we don't hold back old WALs.
void	LockProcedure.unlock(MasterProcedureEnv env)

Uses of MasterProcedureEnv in org.apache.hadoop.hbase.master.migrate

Fields in org.apache.hadoop.hbase.master.migrate with type parameters of type MasterProcedureEnv

Modifier and Type	Field	Description
(package private) ProcedureExecutor<MasterProcedureEnv>	RollingUpgradeChore.procedureExecutor

Constructor parameters in org.apache.hadoop.hbase.master.migrate with type arguments of type MasterProcedureEnv

Modifier	Constructor	Description
private	RollingUpgradeChore(org.apache.hadoop.conf.Configuration conf, ProcedureExecutor<MasterProcedureEnv> procedureExecutor, TableDescriptors tableDescriptors, Stoppable stopper)

Uses of MasterProcedureEnv in org.apache.hadoop.hbase.master.procedure

Fields in org.apache.hadoop.hbase.master.procedure declared as MasterProcedureEnv

Modifier and Type	Field	Description
private final MasterProcedureEnv	LogRollProcedure.NewServerWALRoller.env
private MasterProcedureEnv	RSProcedureDispatcher.procedureEnv

Fields in org.apache.hadoop.hbase.master.procedure with type parameters of type MasterProcedureEnv

Modifier and Type	Field	Description
private final ProcedureExecutor<MasterProcedureEnv>	ProcedureSyncWait.ProcedureFuture.procExec

Methods in org.apache.hadoop.hbase.master.procedure that return types with arguments of type MasterProcedureEnv

Modifier and Type	Method	Description
private Procedure<MasterProcedureEnv>[]	RestoreBackupSystemTableProcedure.createDisableTableProcedure(MasterProcedureEnv env)
private Procedure<MasterProcedureEnv>[]	RestoreBackupSystemTableProcedure.createEnableTableProcedure(MasterProcedureEnv env)
private Procedure<MasterProcedureEnv>[]	SnapshotProcedure.createRemoteSnapshotProcedures(MasterProcedureEnv env)
private Procedure<MasterProcedureEnv>[]	RestoreBackupSystemTableProcedure.createRestoreSnapshotProcedure(MasterProcedureEnv env)
protected Procedure<MasterProcedureEnv>[]	FlushRegionProcedure.execute(MasterProcedureEnv env)
protected Procedure<MasterProcedureEnv>[]	ServerRemoteProcedure.execute(MasterProcedureEnv env)
protected Procedure<MasterProcedureEnv>[]	SnapshotRegionProcedure.execute(MasterProcedureEnv env)
protected Procedure<MasterProcedureEnv>[]	SnapshotVerifyProcedure.execute(MasterProcedureEnv env)
protected ProcedureExecutor<MasterProcedureEnv>	MasterProcedureUtil.NonceProcedureRunnable.getProcedureExecutor()

Methods in org.apache.hadoop.hbase.master.procedure with parameters of type MasterProcedureEnv

Modifier and Type	Method	Description
protected boolean	DeleteTableProcedure.abort(MasterProcedureEnv env)
protected boolean	FlushRegionProcedure.abort(MasterProcedureEnv env)
protected boolean	LogRollProcedure.abort(MasterProcedureEnv env)
protected boolean	LogRollRemoteProcedure.abort(MasterProcedureEnv env)
protected boolean	ReloadQuotasProcedure.abort(MasterProcedureEnv env)
boolean	RestoreSnapshotProcedure.abort(MasterProcedureEnv env)
protected boolean	ServerCrashProcedure.abort(MasterProcedureEnv env)
protected boolean	SnapshotRegionProcedure.abort(MasterProcedureEnv env)
protected boolean	SnapshotVerifyProcedure.abort(MasterProcedureEnv env)
protected boolean	SplitWALRemoteProcedure.abort(MasterProcedureEnv env)
protected boolean	SwitchRpcThrottleRemoteProcedure.abort(MasterProcedureEnv env)
protected Procedure.LockState	AbstractStateMachineNamespaceProcedure.acquireLock(MasterProcedureEnv env)
protected Procedure.LockState	AbstractStateMachineRegionProcedure.acquireLock(MasterProcedureEnv env)
protected Procedure.LockState	AbstractStateMachineTableProcedure.acquireLock(MasterProcedureEnv env)
protected Procedure.LockState	CreateNamespaceProcedure.acquireLock(MasterProcedureEnv env)
protected Procedure.LockState	FlushTableProcedure.acquireLock(MasterProcedureEnv env)
protected Procedure.LockState	ServerCrashProcedure.acquireLock(MasterProcedureEnv env)
protected Procedure.LockState	SnapshotRegionProcedure.acquireLock(MasterProcedureEnv env)
protected static void	AbstractStateMachineNamespaceProcedure.addOrUpdateNamespace(MasterProcedureEnv env, NamespaceDescriptor ns)	Insert/update the row into the ns family of meta table.
private void	RestoreSnapshotProcedure.addRegionsToInMemoryStates(List<RegionInfo> regionInfos, MasterProcedureEnv env, int regionReplication)	Add regions to in-memory states
private void	CloneSnapshotProcedure.addRegionsToMeta(MasterProcedureEnv env)	Add regions to hbase:meta table.
private static void	CreateTableProcedure.addRegionsToMeta(MasterProcedureEnv env, TableDescriptor tableDescriptor, List<RegionInfo> regionInfos)	Add the specified set of regions to the hbase:meta table.
protected static List<RegionInfo>	CreateTableProcedure.addTableToMeta(MasterProcedureEnv env, TableDescriptor tableDescriptor, List<RegionInfo> regions)
protected void	FlushTableProcedure.afterReplay(MasterProcedureEnv env)
protected void	SnapshotProcedure.afterReplay(MasterProcedureEnv env)
protected void	SplitWALProcedure.afterReplay(MasterProcedureEnv env)
private void	ModifyTableProcedure.assignNewReplicasIfNeeded(MasterProcedureEnv env)
private void	ServerCrashProcedure.assignRegions(MasterProcedureEnv env, List<RegionInfo> regions)	Assign the regions on the crashed RS to other Rses.
private static org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.OpenRegionRequest	RSProcedureDispatcher.buildOpenRegionRequest(MasterProcedureEnv env, ServerName serverName, List<RSProcedureDispatcher.RegionOpenOperation> operations)
org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.OpenRegionRequest.RegionOpenInfo	RSProcedureDispatcher.RegionOpenOperation.buildRegionOpenInfoRequest(MasterProcedureEnv env)
private boolean	ReopenTableRegionsProcedure.canSchedule(MasterProcedureEnv env, HRegionLocation loc)
protected final void	AbstractStateMachineNamespaceProcedure.checkNamespaceRSGroup(MasterProcedureEnv env, NamespaceDescriptor nd)
protected static void	AbstractStateMachineTableProcedure.checkOnline(MasterProcedureEnv env, RegionInfo ri)	Check region is online.
protected void	AbstractStateMachineTableProcedure.checkTableModifiable(MasterProcedureEnv env)	Check whether a table is modifiable - exists and either offline or online with config set
private static void	DeleteTableProcedure.cleanRegionsInMeta(MasterProcedureEnv env, TableName tableName)	There may be items for this table still up in hbase:meta in the case where the info:regioninfo column was empty because of some write error.
private void	ServerCrashProcedure.cleanupSplitDir(MasterProcedureEnv env)
private void	ModifyTableProcedure.closeExcessReplicasIfNeeded(MasterProcedureEnv env)
private void	FlushRegionProcedure.complete(MasterProcedureEnv env, Throwable error)
protected boolean	LogRollRemoteProcedure.complete(MasterProcedureEnv env, Throwable error)
protected boolean	ReloadQuotasProcedure.complete(MasterProcedureEnv env, Throwable error)
protected abstract boolean	ServerRemoteProcedure.complete(MasterProcedureEnv env, Throwable error)
private void	SnapshotRegionProcedure.complete(MasterProcedureEnv env, Throwable error)
protected boolean	SnapshotVerifyProcedure.complete(MasterProcedureEnv env, Throwable error)
protected boolean	SplitWALRemoteProcedure.complete(MasterProcedureEnv env, Throwable error)
protected boolean	SwitchRpcThrottleRemoteProcedure.complete(MasterProcedureEnv env, Throwable error)
private void	SnapshotProcedure.completeSnapshot(MasterProcedureEnv env)
protected void	InitMetaProcedure.completionCleanup(MasterProcedureEnv env)
protected void	MigrateNamespaceTableProcedure.completionCleanup(MasterProcedureEnv env)
protected void	ModifyTableProcedure.completionCleanup(MasterProcedureEnv env)
protected void	ServerRemoteProcedure.completionCleanup(MasterProcedureEnv env)
protected void	TruncateRegionProcedure.completionCleanup(MasterProcedureEnv env)
protected void	TruncateTableProcedure.completionCleanup(MasterProcedureEnv env)
private StateMachineProcedure.Flow	AbstractCloseTableRegionsProcedure.confirm(MasterProcedureEnv env)
private TransitRegionStateProcedure	TruncateRegionProcedure.createAssignProcedures(MasterProcedureEnv env)
protected static void	AbstractStateMachineNamespaceProcedure.createDirectory(MasterProcedureEnv env, NamespaceDescriptor nsDescriptor)	Create the namespace directory
private Procedure<MasterProcedureEnv>[]	RestoreBackupSystemTableProcedure.createDisableTableProcedure(MasterProcedureEnv env)
private Procedure<MasterProcedureEnv>[]	RestoreBackupSystemTableProcedure.createEnableTableProcedure(MasterProcedureEnv env)
private List<RegionInfo>	CloneSnapshotProcedure.createFilesystemLayout(MasterProcedureEnv env, TableDescriptor tableDescriptor, List<RegionInfo> newRegions)	Create regions in file system.
private FlushRegionProcedure[]	FlushTableProcedure.createFlushRegionProcedures(MasterProcedureEnv env)
private List<RegionInfo>	CloneSnapshotProcedure.createFsLayout(MasterProcedureEnv env, TableDescriptor tableDescriptor, List<RegionInfo> newRegions, CreateTableProcedure.CreateHdfsRegions hdfsRegionHandler)	Create region layout in file system.
protected static List<RegionInfo>	CreateTableProcedure.createFsLayout(MasterProcedureEnv env, TableDescriptor tableDescriptor, List<RegionInfo> newRegions)
protected static List<RegionInfo>	CreateTableProcedure.createFsLayout(MasterProcedureEnv env, TableDescriptor tableDescriptor, List<RegionInfo> newRegions, CreateTableProcedure.CreateHdfsRegions hdfsRegionHandler)
List<RegionInfo>	CreateTableProcedure.CreateHdfsRegions.createHdfsRegions(MasterProcedureEnv env, org.apache.hadoop.fs.Path tableRootDir, TableName tableName, List<RegionInfo> newRegions)
private Procedure<MasterProcedureEnv>[]	SnapshotProcedure.createRemoteSnapshotProcedures(MasterProcedureEnv env)
private Procedure<MasterProcedureEnv>[]	RestoreBackupSystemTableProcedure.createRestoreSnapshotProcedure(MasterProcedureEnv env)
static SnapshotProcedure	RecoverySnapshotUtils.createSnapshotProcedure(MasterProcedureEnv env, TableName tableName, String snapshotName, TableDescriptor tableDescriptor)	Creates a SnapshotProcedure for soft drop functionality.
private Procedure[]	ServerCrashProcedure.createSplittingWalProcedures(MasterProcedureEnv env, boolean splitMeta)
private TransitRegionStateProcedure	TruncateRegionProcedure.createUnAssignProcedures(MasterProcedureEnv env)
protected static void	DeleteTableProcedure.deleteAssignmentState(MasterProcedureEnv env, TableName tableName)
static void	MasterDDLOperationHelper.deleteColumnFamilyFromFileSystem(MasterProcedureEnv env, TableName tableName, List<RegionInfo> regionInfoList, byte[] familyName, boolean hasMob)	Remove the column family from the file system
private static void	DeleteNamespaceProcedure.deleteDirectory(MasterProcedureEnv env, String namespaceName)	Delete the namespace directories from the file system
protected static void	DeleteTableProcedure.deleteFromFs(MasterProcedureEnv env, TableName tableName, List<RegionInfo> regions, boolean archive)
private void	ModifyTableProcedure.deleteFromFs(MasterProcedureEnv env, TableDescriptor oldTableDescriptor, TableDescriptor newTableDescriptor)	Removes from hdfs the families that are not longer present in the new table descriptor.
protected static void	DeleteTableProcedure.deleteFromMeta(MasterProcedureEnv env, TableName tableName, List<RegionInfo> regions)
private static void	DeleteNamespaceProcedure.deleteNamespace(MasterProcedureEnv env, String namespaceName)	delete the row from the ns family in meta table.
static void	RecoverySnapshotUtils.deleteRecoverySnapshot(MasterProcedureEnv env, String snapshotName, TableName tableName)	Deletes a recovery snapshot during rollback scenarios.
private void	TruncateRegionProcedure.deleteRegionFromFileSystem(MasterProcedureEnv env)
private void	RestoreSnapshotProcedure.deleteRegionsFromInMemoryStates(List<RegionInfo> regionInfos, MasterProcedureEnv env, int regionReplication)	Delete regions from in-memory states
protected static void	DeleteTableProcedure.deleteTableDescriptorCache(MasterProcedureEnv env, TableName tableName)
protected static void	DeleteTableProcedure.deleteTableStates(MasterProcedureEnv env, TableName tableName)
void	RSProcedureDispatcher.ExecuteProceduresRemoteCall.dispatchCloseRequests(MasterProcedureEnv env, List<RSProcedureDispatcher.RegionCloseOperation> operations)
void	RSProcedureDispatcher.RemoteProcedureResolver.dispatchCloseRequests(MasterProcedureEnv env, List<RSProcedureDispatcher.RegionCloseOperation> operations)
void	RSProcedureDispatcher.ExecuteProceduresRemoteCall.dispatchOpenRequests(MasterProcedureEnv env, List<RSProcedureDispatcher.RegionOpenOperation> operations)
void	RSProcedureDispatcher.RemoteProcedureResolver.dispatchOpenRequests(MasterProcedureEnv env, List<RSProcedureDispatcher.RegionOpenOperation> operations)
void	RSProcedureDispatcher.ExecuteProceduresRemoteCall.dispatchServerOperations(MasterProcedureEnv env, List<RSProcedureDispatcher.ServerOperation> operations)
void	RSProcedureDispatcher.RemoteProcedureResolver.dispatchServerOperations(MasterProcedureEnv env, List<RSProcedureDispatcher.ServerOperation> operations)
protected Procedure<MasterProcedureEnv>[]	FlushRegionProcedure.execute(MasterProcedureEnv env)
protected Procedure<MasterProcedureEnv>[]	ServerRemoteProcedure.execute(MasterProcedureEnv env)
protected Procedure<MasterProcedureEnv>[]	SnapshotRegionProcedure.execute(MasterProcedureEnv env)
protected Procedure<MasterProcedureEnv>[]	SnapshotVerifyProcedure.execute(MasterProcedureEnv env)
protected StateMachineProcedure.Flow	AbstractCloseTableRegionsProcedure.executeFromState(MasterProcedureEnv env, TState state)
protected StateMachineProcedure.Flow	CloneSnapshotProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.CloneSnapshotState state)
protected StateMachineProcedure.Flow	CreateNamespaceProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.CreateNamespaceState state)
protected StateMachineProcedure.Flow	CreateTableProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.CreateTableState state)
protected StateMachineProcedure.Flow	DeleteNamespaceProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.DeleteNamespaceState state)
protected StateMachineProcedure.Flow	DeleteTableProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.DeleteTableState state)
protected StateMachineProcedure.Flow	DisableTableProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.DisableTableState state)
protected StateMachineProcedure.Flow	EnableTableProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.EnableTableState state)
protected StateMachineProcedure.Flow	FlushTableProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.FlushTableState state)
protected StateMachineProcedure.Flow	InitMetaProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.InitMetaState state)
protected StateMachineProcedure.Flow	LogRollProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.LogRollProcedureState state)
protected StateMachineProcedure.Flow	MigrateNamespaceTableProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.MigrateNamespaceTableProcedureState state)
protected StateMachineProcedure.Flow	ModifyNamespaceProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.ModifyNamespaceState state)
protected StateMachineProcedure.Flow	ModifyTableDescriptorProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.ModifyTableDescriptorState state)
protected StateMachineProcedure.Flow	ModifyTableProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.ModifyTableState state)
protected StateMachineProcedure.Flow	RecoverMetaProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.RecoverMetaState state)	Deprecated.
protected StateMachineProcedure.Flow	ReopenTableRegionsProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.ReopenTableRegionsState state)
protected StateMachineProcedure.Flow	RestoreBackupSystemTableProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.RestoreBackupSystemTableState state)
protected StateMachineProcedure.Flow	RestoreSnapshotProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.RestoreSnapshotState state)
protected StateMachineProcedure.Flow	ServerCrashProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.ServerCrashState state)
protected StateMachineProcedure.Flow	SnapshotProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.SnapshotState state)
protected StateMachineProcedure.Flow	SplitWALProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.SplitWALState state)
protected StateMachineProcedure.Flow	SwitchRpcThrottleProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.SwitchRpcThrottleState state)
protected StateMachineProcedure.Flow	TruncateRegionProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.TruncateRegionState state)
protected StateMachineProcedure.Flow	TruncateTableProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.TruncateTableState state)
private List<HRegionLocation>	ReopenTableRegionsProcedure.filterReopened(MasterProcedureEnv env, List<HRegionLocation> regionsToCheck)
private Stream<RegionInfo>	SnapshotProcedure.getDefaultRegionReplica(MasterProcedureEnv env)
protected static MasterQuotaManager	ProcedureSyncWait.getMasterQuotaManager(MasterProcedureEnv env)
protected ProcedureMetrics	ServerCrashProcedure.getProcedureMetrics(MasterProcedureEnv env)
static long	RecoverySnapshotUtils.getRecoverySnapshotTtl(MasterProcedureEnv env, TableDescriptor tableDescriptor)	Gets the TTL that should be used for snapshots created before destructive schema actions.
private List<RegionInfo>	ModifyTableProcedure.getRegionInfoList(MasterProcedureEnv env)	Fetches all Regions for a table.
(package private) List<RegionInfo>	HBCKServerCrashProcedure.getRegionsOnCrashedServer(MasterProcedureEnv env)	If no Regions found in Master context, then we will search hbase:meta for references to the passed server.
(package private) List<RegionInfo>	ServerCrashProcedure.getRegionsOnCrashedServer(MasterProcedureEnv env)	Returns List of Regions on crashed server.
protected static TableNamespaceManager	AbstractStateMachineNamespaceProcedure.getTableNamespaceManager(MasterProcedureEnv env)
protected final org.apache.hadoop.fs.Path	AbstractStateMachineTableProcedure.getWALRegionDir(MasterProcedureEnv env, RegionInfo region)
protected boolean	AbstractStateMachineRegionProcedure.holdLock(MasterProcedureEnv env)
protected boolean	DeleteTableProcedure.holdLock(MasterProcedureEnv env)
protected boolean	ModifyTableDescriptorProcedure.holdLock(MasterProcedureEnv env)
protected boolean	ServerCrashProcedure.holdLock(MasterProcedureEnv env)
protected boolean	SnapshotRegionProcedure.holdLock(MasterProcedureEnv env)
protected boolean	TruncateRegionProcedure.holdLock(MasterProcedureEnv env)
protected boolean	TruncateTableProcedure.holdLock(MasterProcedureEnv env)
private boolean	SnapshotProcedure.isAnySplitOrMergeProcedureRunning(MasterProcedureEnv env)
static boolean	RecoverySnapshotUtils.isRecoveryEnabled(MasterProcedureEnv env)	Checks if recovery snapshots are enabled for destructive table actions.
private boolean	ServerCrashProcedure.isSplittingDone(MasterProcedureEnv env, boolean splitMeta)
protected boolean	AbstractStateMachineTableProcedure.isTableEnabled(MasterProcedureEnv env)
protected final boolean	AbstractStateMachineTableProcedure.isTableModificationInProgress(MasterProcedureEnv env)	Some procedures cannot safely run while a table is being modified.
private TableDescriptor	SnapshotProcedure.loadTableDescriptorSnapshot(MasterProcedureEnv env)
private void	MigrateNamespaceTableProcedure.migrate(MasterProcedureEnv env)
protected abstract Optional<TableDescriptor>	ModifyTableDescriptorProcedure.modify(MasterProcedureEnv env, TableDescriptor current)	Sub class should implement this method to modify the table descriptor, such as storing the rs group information.
protected abstract int	AbstractCloseTableRegionsProcedure.numberOfUnclosedRegions(MasterProcedureEnv env)	Return the number of uncloses regions.
protected int	CloseExcessRegionReplicasProcedure.numberOfUnclosedRegions(MasterProcedureEnv env)
protected int	CloseTableRegionsProcedure.numberOfUnclosedRegions(MasterProcedureEnv env)
private void	CloneSnapshotProcedure.postCloneSnapshot(MasterProcedureEnv env)	Action after cloning from snapshot.
private void	CreateTableProcedure.postCreate(MasterProcedureEnv env)
private void	DeleteTableProcedure.postDelete(MasterProcedureEnv env)
protected void	DisableTableProcedure.postDisable(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.DisableTableState state)	Action after disabling table.
private void	EnableTableProcedure.postEnable(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.EnableTableState state)	Action after enabling table.
private void	ModifyTableProcedure.postModify(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.ModifyTableState state)	Action after modifying table.
private void	SnapshotProcedure.postSnapshot(MasterProcedureEnv env)
private void	TruncateRegionProcedure.postTruncate(MasterProcedureEnv env)
private void	TruncateTableProcedure.postTruncate(MasterProcedureEnv env)
private void	CloneSnapshotProcedure.preCloneSnapshot(MasterProcedureEnv env)	Action before cloning from snapshot.
private void	CreateTableProcedure.preCreate(MasterProcedureEnv env)
private boolean	DeleteTableProcedure.preDelete(MasterProcedureEnv env)
protected void	DisableTableProcedure.preDisable(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.DisableTableState state)	Action before disabling table.
private void	EnableTableProcedure.preEnable(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.EnableTableState state)	Action before enabling table.
protected void	AbstractStateMachineTableProcedure.preflightChecks(MasterProcedureEnv env, Boolean enabled)	Check that cluster is up and master is running.
protected void	FlushTableProcedure.preflightChecks(MasterProcedureEnv env, Boolean enabled)
protected void	ModifyTableProcedure.preflightChecks(MasterProcedureEnv env, Boolean enabled)
private void	ModifyTableProcedure.preModify(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.ModifyTableState state)	Action before modifying table.
private void	RestoreBackupSystemTableProcedure.prepare(MasterProcedureEnv env)
private void	CloneSnapshotProcedure.prepareClone(MasterProcedureEnv env)	Action before any real action of cloning from snapshot.
private boolean	CreateNamespaceProcedure.prepareCreate(MasterProcedureEnv env)	Action before any real action of creating namespace.
private boolean	CreateTableProcedure.prepareCreate(MasterProcedureEnv env)
private boolean	DeleteNamespaceProcedure.prepareDelete(MasterProcedureEnv env)	Action before any real action of deleting namespace.
private boolean	DeleteTableProcedure.prepareDelete(MasterProcedureEnv env)
private boolean	DisableTableProcedure.prepareDisable(MasterProcedureEnv env)	Action before any real action of disabling table.
private boolean	EnableTableProcedure.prepareEnable(MasterProcedureEnv env)	Action before any real action of enabling table.
private boolean	ModifyNamespaceProcedure.prepareModify(MasterProcedureEnv env)	Action before any real action of adding namespace.
private void	ModifyTableProcedure.prepareModify(MasterProcedureEnv env)	Check conditions before any real action of modifying a table.
private void	RestoreSnapshotProcedure.prepareRestore(MasterProcedureEnv env)	Action before any real action of restoring from snapshot.
private void	SnapshotProcedure.prepareSnapshot(MasterProcedureEnv env)
private void	SnapshotProcedure.prepareSnapshotEnv(MasterProcedureEnv env)
private boolean	TruncateTableProcedure.prepareTruncate(MasterProcedureEnv env)
private void	SnapshotProcedure.preSnapshot(MasterProcedureEnv env)
private void	TruncateRegionProcedure.preTruncate(MasterProcedureEnv env)
private boolean	TruncateTableProcedure.preTruncate(MasterProcedureEnv env)
protected void	AbstractStateMachineNamespaceProcedure.releaseLock(MasterProcedureEnv env)
protected void	AbstractStateMachineRegionProcedure.releaseLock(MasterProcedureEnv env)
protected void	AbstractStateMachineTableProcedure.releaseLock(MasterProcedureEnv env)
protected void	FlushTableProcedure.releaseLock(MasterProcedureEnv env)
protected void	ServerCrashProcedure.releaseLock(MasterProcedureEnv env)
protected void	SnapshotRegionProcedure.releaseLock(MasterProcedureEnv env)
Optional<RemoteProcedureDispatcher.RemoteOperation>	FlushRegionProcedure.remoteCallBuild(MasterProcedureEnv env, ServerName serverName)
Optional<RemoteProcedureDispatcher.RemoteOperation>	LogRollRemoteProcedure.remoteCallBuild(MasterProcedureEnv env, ServerName serverName)
Optional<RemoteProcedureDispatcher.RemoteOperation>	ReloadQuotasProcedure.remoteCallBuild(MasterProcedureEnv env, ServerName serverName)
Optional<RemoteProcedureDispatcher.RemoteOperation>	SnapshotRegionProcedure.remoteCallBuild(MasterProcedureEnv env, ServerName serverName)
Optional<RemoteProcedureDispatcher.RemoteOperation>	SnapshotVerifyProcedure.remoteCallBuild(MasterProcedureEnv env, ServerName serverName)
Optional<RemoteProcedureDispatcher.RemoteOperation>	SplitWALRemoteProcedure.remoteCallBuild(MasterProcedureEnv env, ServerName serverName)
Optional<RemoteProcedureDispatcher.RemoteOperation>	SwitchRpcThrottleRemoteProcedure.remoteCallBuild(MasterProcedureEnv masterProcedureEnv, ServerName remote)
void	FlushRegionProcedure.remoteCallFailed(MasterProcedureEnv env, ServerName serverName, IOException e)
protected final void	RSProcedureDispatcher.ExecuteProceduresRemoteCall.remoteCallFailed(MasterProcedureEnv env, IOException e)
void	ServerRemoteProcedure.remoteCallFailed(MasterProcedureEnv env, ServerName serverName, IOException exception)
void	SnapshotRegionProcedure.remoteCallFailed(MasterProcedureEnv env, ServerName serverName, IOException e)
void	FlushRegionProcedure.remoteOperationCompleted(MasterProcedureEnv env, byte[] remoteResultData)
void	LogRollRemoteProcedure.remoteOperationCompleted(MasterProcedureEnv env, byte[] remoteResultData)
void	ServerRemoteProcedure.remoteOperationCompleted(MasterProcedureEnv env, byte[] remoteResultData)
void	SnapshotRegionProcedure.remoteOperationCompleted(MasterProcedureEnv env, byte[] remoteResultData)
(package private) void	ServerRemoteProcedure.remoteOperationDone(MasterProcedureEnv env, Throwable error)
void	FlushRegionProcedure.remoteOperationFailed(MasterProcedureEnv env, RemoteProcedureException error)
void	ServerRemoteProcedure.remoteOperationFailed(MasterProcedureEnv env, RemoteProcedureException error)
void	SnapshotRegionProcedure.remoteOperationFailed(MasterProcedureEnv env, RemoteProcedureException e)
private static void	DeleteNamespaceProcedure.removeNamespaceQuota(MasterProcedureEnv env, String namespaceName)	remove quota for the namespace
private void	ModifyTableProcedure.removeReplicaColumnsIfNeeded(MasterProcedureEnv env)	remove replica columns if necessary.
private StateMachineProcedure.Flow	ReopenTableRegionsProcedure.reopenIfSchedulable(MasterProcedureEnv env, List<HRegionLocation> regionsToReopen, boolean shouldBatchBackoff)
private void	RestoreSnapshotProcedure.restoreSnapshot(MasterProcedureEnv env)	Execute the on-disk Restore
private void	CloneSnapshotProcedure.restoreSnapshotAcl(MasterProcedureEnv env)
private void	RestoreSnapshotProcedure.restoreSnapshotAcl(MasterProcedureEnv env)
protected void	FlushRegionProcedure.rollback(MasterProcedureEnv env)
protected void	LogRollRemoteProcedure.rollback(MasterProcedureEnv env)
protected void	ReloadQuotasProcedure.rollback(MasterProcedureEnv env)
protected void	SnapshotRegionProcedure.rollback(MasterProcedureEnv env)
protected void	SnapshotVerifyProcedure.rollback(MasterProcedureEnv env)
protected void	SplitWALRemoteProcedure.rollback(MasterProcedureEnv env)
protected void	SwitchRpcThrottleRemoteProcedure.rollback(MasterProcedureEnv env)
protected void	AbstractCloseTableRegionsProcedure.rollbackState(MasterProcedureEnv env, TState state)
protected void	CloneSnapshotProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.CloneSnapshotState state)
protected void	CreateNamespaceProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.CreateNamespaceState state)
protected void	CreateTableProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.CreateTableState state)
protected void	DeleteNamespaceProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.DeleteNamespaceState state)
protected void	DeleteTableProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.DeleteTableState state)
protected void	DisableTableProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.DisableTableState state)
protected void	EnableTableProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.EnableTableState state)
protected void	FlushTableProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.FlushTableState state)
protected void	InitMetaProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.InitMetaState state)
protected void	LogRollProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.LogRollProcedureState state)
protected void	MigrateNamespaceTableProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.MigrateNamespaceTableProcedureState state)
protected void	ModifyNamespaceProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.ModifyNamespaceState state)
protected void	ModifyTableDescriptorProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.ModifyTableDescriptorState state)
protected void	ModifyTableProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.ModifyTableState state)
protected void	RecoverMetaProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.RecoverMetaState recoverMetaState)	Deprecated.
protected void	ReopenTableRegionsProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.ReopenTableRegionsState state)
protected void	RestoreBackupSystemTableProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.RestoreBackupSystemTableState state)
protected void	RestoreSnapshotProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.RestoreSnapshotState state)
protected void	ServerCrashProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.ServerCrashState state)
protected void	SnapshotProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.SnapshotState state)
protected void	SplitWALProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.SplitWALState splitOneWalState)
protected void	SwitchRpcThrottleProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.SwitchRpcThrottleState state)
protected void	TruncateRegionProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.TruncateRegionState state)
protected void	TruncateTableProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.TruncateTableState state)
private void	DisableTableProcedure.runCoprocessorAction(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.DisableTableState state)	Coprocessor Action.
private void	EnableTableProcedure.runCoprocessorAction(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.EnableTableState state)	Coprocessor Action.
private void	ModifyTableProcedure.runCoprocessorAction(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.ModifyTableState state)	Coprocessor Action.
private StateMachineProcedure.Flow	AbstractCloseTableRegionsProcedure.schedule(MasterProcedureEnv env)
protected static void	CreateTableProcedure.setEnabledState(MasterProcedureEnv env, TableName tableName)
protected static void	CreateTableProcedure.setEnablingState(MasterProcedureEnv env, TableName tableName)
private static void	CreateNamespaceProcedure.setNamespaceQuota(MasterProcedureEnv env, NamespaceDescriptor nsDescriptor)	Set quota for the namespace
protected static void	DisableTableProcedure.setTableStateToDisabled(MasterProcedureEnv env, TableName tableName)	Mark table state to Disabled
private static void	DisableTableProcedure.setTableStateToDisabling(MasterProcedureEnv env, TableName tableName)	Mark table state to Disabling
protected static void	EnableTableProcedure.setTableStateToEnabled(MasterProcedureEnv env, TableName tableName)	Mark table state to Enabled
protected static void	EnableTableProcedure.setTableStateToEnabling(MasterProcedureEnv env, TableName tableName)	Mark table state to Enabling
protected boolean	AbstractCloseTableRegionsProcedure.setTimeoutFailure(MasterProcedureEnv env)
protected boolean	CreateTableProcedure.setTimeoutFailure(MasterProcedureEnv env)
protected boolean	DeleteTableProcedure.setTimeoutFailure(MasterProcedureEnv env)
protected boolean	FlushRegionProcedure.setTimeoutFailure(MasterProcedureEnv env)
protected boolean	InitMetaProcedure.setTimeoutFailure(MasterProcedureEnv env)
protected boolean	ReopenTableRegionsProcedure.setTimeoutFailure(MasterProcedureEnv env)	At end of timeout, wake ourselves up so we run again.
protected boolean	ServerCrashProcedure.setTimeoutFailure(MasterProcedureEnv env)
protected boolean	SnapshotProcedure.setTimeoutFailure(MasterProcedureEnv env)
protected boolean	SnapshotRegionProcedure.setTimeoutFailure(MasterProcedureEnv env)
protected boolean	SnapshotVerifyProcedure.setTimeoutFailure(MasterProcedureEnv env)
protected boolean	SplitWALProcedure.setTimeoutFailure(MasterProcedureEnv env)
private void	FlushRegionProcedure.setTimeoutForSuspend(MasterProcedureEnv env, String reason)
private void	SnapshotRegionProcedure.setTimeoutForSuspend(MasterProcedureEnv env, String reason)
protected boolean	CreateTableProcedure.shouldWaitClientAck(MasterProcedureEnv env)
protected boolean	ServerCrashProcedure.shouldWaitClientAck(MasterProcedureEnv env)
private void	SnapshotProcedure.snapshotClosedRegions(MasterProcedureEnv env)
private void	SnapshotProcedure.snapshotMobRegion(MasterProcedureEnv env)
private void	SnapshotProcedure.snapshotSplitOrClosedRegions(MasterProcedureEnv env, List<RegionInfo> regions, String threadPoolName)
private void	SnapshotProcedure.snapshotSplitRegions(MasterProcedureEnv env)
protected abstract int	AbstractCloseTableRegionsProcedure.submitUnassignProcedure(MasterProcedureEnv env, Consumer<TransitRegionStateProcedure> submit)	Submit TRSP for unassigning regions.
protected int	CloseExcessRegionReplicasProcedure.submitUnassignProcedure(MasterProcedureEnv env, Consumer<TransitRegionStateProcedure> submit)
protected int	CloseTableRegionsProcedure.submitUnassignProcedure(MasterProcedureEnv env, Consumer<TransitRegionStateProcedure> submit)
void	SwitchRpcThrottleProcedure.switchThrottleState(MasterProcedureEnv env, boolean rpcThrottleEnabled)
private void	RestoreSnapshotProcedure.updateMETA(MasterProcedureEnv env)	Apply changes to hbase:meta
static void	ServerCrashProcedure.updateProgress(MasterProcedureEnv env, long parentId)
private void	ModifyTableProcedure.updateTableDescriptor(MasterProcedureEnv env)	Update descriptor
private void	RestoreSnapshotProcedure.updateTableDescriptor(MasterProcedureEnv env)	Update descriptor
private void	SnapshotProcedure.verifySnapshot(MasterProcedureEnv env)
static <T> T	ProcedureSyncWait.waitFor(MasterProcedureEnv env, long waitTime, long waitingTimeForEvents, String purpose, ProcedureSyncWait.Predicate<T> predicate)
static <T> T	ProcedureSyncWait.waitFor(MasterProcedureEnv env, long waitTime, String purpose, ProcedureSyncWait.Predicate<T> predicate)
static <T> T	ProcedureSyncWait.waitFor(MasterProcedureEnv env, String purpose, ProcedureSyncWait.Predicate<T> predicate)
protected boolean	AbstractStateMachineNamespaceProcedure.waitInitialized(MasterProcedureEnv env)
protected boolean	AbstractStateMachineTableProcedure.waitInitialized(MasterProcedureEnv env)
protected boolean	CreateNamespaceProcedure.waitInitialized(MasterProcedureEnv env)
protected boolean	CreateTableProcedure.waitInitialized(MasterProcedureEnv env)
protected boolean	FlushRegionProcedure.waitInitialized(MasterProcedureEnv env)
protected boolean	InitMetaProcedure.waitInitialized(MasterProcedureEnv env)
protected boolean	SnapshotRegionProcedure.waitInitialized(MasterProcedureEnv env)
protected static void	ProcedureSyncWait.waitMetaRegions(MasterProcedureEnv env)
protected static void	ProcedureSyncWait.waitRegionInTransition(MasterProcedureEnv env, List<RegionInfo> regions)
private void	ServerCrashProcedure.zkCoordinatedSplitLogs(MasterProcedureEnv env)	Split logs using 'classic' zk-based coordination.
private void	ServerCrashProcedure.zkCoordinatedSplitMetaLogs(MasterProcedureEnv env)	Split hbase:meta logs using 'classic' zk-based coordination.

Method parameters in org.apache.hadoop.hbase.master.procedure with type arguments of type MasterProcedureEnv

Modifier and Type	Method	Description
static byte[]	ProcedureSyncWait.submitAndWaitProcedure(ProcedureExecutor<MasterProcedureEnv> procExec, Procedure<MasterProcedureEnv> proc)
static byte[]	ProcedureSyncWait.submitAndWaitProcedure(ProcedureExecutor<MasterProcedureEnv> procExec, Procedure<MasterProcedureEnv> proc)
protected long	MasterProcedureUtil.NonceProcedureRunnable.submitProcedure(Procedure<MasterProcedureEnv> proc)
static Future<byte[]>	ProcedureSyncWait.submitProcedure(ProcedureExecutor<MasterProcedureEnv> procExec, Procedure<MasterProcedureEnv> proc)
static Future<byte[]>	ProcedureSyncWait.submitProcedure(ProcedureExecutor<MasterProcedureEnv> procExec, Procedure<MasterProcedureEnv> proc)
static byte[]	ProcedureSyncWait.waitForProcedureToComplete(ProcedureExecutor<MasterProcedureEnv> procExec, Procedure<?> proc, long timeout)
static byte[]	ProcedureSyncWait.waitForProcedureToCompleteIOE(ProcedureExecutor<MasterProcedureEnv> procExec, Procedure<?> proc, long timeout)

Constructors in org.apache.hadoop.hbase.master.procedure with parameters of type MasterProcedureEnv

Modifier	Constructor	Description
protected	AbstractStateMachineNamespaceProcedure(MasterProcedureEnv env)
protected	AbstractStateMachineNamespaceProcedure(MasterProcedureEnv env, ProcedurePrepareLatch latch)
protected	AbstractStateMachineRegionProcedure(MasterProcedureEnv env, RegionInfo hri)
protected	AbstractStateMachineRegionProcedure(MasterProcedureEnv env, RegionInfo hri, ProcedurePrepareLatch latch)
protected	AbstractStateMachineTableProcedure(MasterProcedureEnv env)
protected	AbstractStateMachineTableProcedure(MasterProcedureEnv env, ProcedurePrepareLatch latch)
	CloneSnapshotProcedure(MasterProcedureEnv env, TableDescriptor tableDescriptor, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot)
	CloneSnapshotProcedure(MasterProcedureEnv env, TableDescriptor tableDescriptor, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot, boolean restoreAcl)	Constructor
	CloneSnapshotProcedure(MasterProcedureEnv env, TableDescriptor tableDescriptor, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot, boolean restoreAcl, String customSFT)
	CreateNamespaceProcedure(MasterProcedureEnv env, NamespaceDescriptor nsDescriptor)
	CreateNamespaceProcedure(MasterProcedureEnv env, NamespaceDescriptor nsDescriptor, ProcedurePrepareLatch latch)
	CreateTableProcedure(MasterProcedureEnv env, TableDescriptor tableDescriptor, RegionInfo[] newRegions)
	CreateTableProcedure(MasterProcedureEnv env, TableDescriptor tableDescriptor, RegionInfo[] newRegions, ProcedurePrepareLatch syncLatch)
	DeleteNamespaceProcedure(MasterProcedureEnv env, String namespaceName)
	DeleteNamespaceProcedure(MasterProcedureEnv env, String namespaceName, ProcedurePrepareLatch latch)
	DeleteTableProcedure(MasterProcedureEnv env, TableName tableName)
	DeleteTableProcedure(MasterProcedureEnv env, TableName tableName, ProcedurePrepareLatch syncLatch)
	DisableTableProcedure(MasterProcedureEnv env, TableName tableName, boolean skipTableStateCheck)	Constructor
	DisableTableProcedure(MasterProcedureEnv env, TableName tableName, boolean skipTableStateCheck, ProcedurePrepareLatch syncLatch)	Constructor
	EnableTableProcedure(MasterProcedureEnv env, TableName tableName)	Constructor
	EnableTableProcedure(MasterProcedureEnv env, TableName tableName, ProcedurePrepareLatch syncLatch)	Constructor
	FlushTableProcedure(MasterProcedureEnv env, TableName tableName)
	FlushTableProcedure(MasterProcedureEnv env, TableName tableName, List<byte[]> columnFamilies)
	HBCKServerCrashProcedure(MasterProcedureEnv env, ServerName serverName, boolean shouldSplitWal, boolean carryingMeta)
	ModifyNamespaceProcedure(MasterProcedureEnv env, NamespaceDescriptor newNsDescriptor)
	ModifyNamespaceProcedure(MasterProcedureEnv env, NamespaceDescriptor newNsDescriptor, ProcedurePrepareLatch latch)
protected	ModifyTableDescriptorProcedure(MasterProcedureEnv env, TableName tableName)
	ModifyTableProcedure(MasterProcedureEnv env, TableDescriptor htd)
	ModifyTableProcedure(MasterProcedureEnv env, TableDescriptor htd, ProcedurePrepareLatch latch)
	ModifyTableProcedure(MasterProcedureEnv env, TableDescriptor newTableDescriptor, ProcedurePrepareLatch latch, TableDescriptor oldTableDescriptor, boolean shouldCheckDescriptor, boolean reopenRegions)
	NewServerWALRoller(MasterProcedureEnv env)
	RestoreSnapshotProcedure(MasterProcedureEnv env, TableDescriptor oldTableDescriptor, TableDescriptor modifiedTableDescriptor, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot, boolean restoreAcl)	Constructor
	RestoreSnapshotProcedure(MasterProcedureEnv env, TableDescriptor tableDescriptor, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot)
	RestoreSnapshotProcedure(MasterProcedureEnv env, TableDescriptor tableDescriptor, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot, boolean restoreAcl)
	ServerCrashProcedure(MasterProcedureEnv env, ServerName serverName, boolean shouldSplitWal, boolean carryingMeta)	Call this constructor queuing up a Procedure.
	SnapshotProcedure(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot)
	TruncateRegionProcedure(MasterProcedureEnv env, RegionInfo hri)
	TruncateRegionProcedure(MasterProcedureEnv env, RegionInfo region, ProcedurePrepareLatch latch)
	TruncateTableProcedure(MasterProcedureEnv env, TableName tableName, boolean preserveSplits)
	TruncateTableProcedure(MasterProcedureEnv env, TableName tableName, boolean preserveSplits, ProcedurePrepareLatch latch)

Constructor parameters in org.apache.hadoop.hbase.master.procedure with type arguments of type MasterProcedureEnv

Modifier	Constructor	Description
	ProcedureFuture(ProcedureExecutor<MasterProcedureEnv> procExec, Procedure<?> proc)

Uses of MasterProcedureEnv in org.apache.hadoop.hbase.master.replication

Methods in org.apache.hadoop.hbase.master.replication that return types with arguments of type MasterProcedureEnv

Modifier and Type	Method	Description
protected Procedure<MasterProcedureEnv>[]	ClaimReplicationQueueRemoteProcedure.execute(MasterProcedureEnv env)
protected Procedure<MasterProcedureEnv>[]	ClaimReplicationQueuesProcedure.execute(MasterProcedureEnv env)	Deprecated.

Methods in org.apache.hadoop.hbase.master.replication with parameters of type MasterProcedureEnv

Modifier and Type	Method	Description
protected boolean	ClaimReplicationQueueRemoteProcedure.abort(MasterProcedureEnv env)
protected boolean	ClaimReplicationQueuesProcedure.abort(MasterProcedureEnv env)	Deprecated.
protected boolean	RefreshPeerProcedure.abort(MasterProcedureEnv env)
protected boolean	SyncReplicationReplayWALRemoteProcedure.abort(MasterProcedureEnv env)
protected Procedure.LockState	AbstractPeerProcedure.acquireLock(MasterProcedureEnv env)
private void	AssignReplicationQueuesProcedure.addMissingQueues(MasterProcedureEnv env)
protected void	AddPeerProcedure.afterReplay(MasterProcedureEnv env)
protected void	MigrateReplicationQueueFromZkToTableProcedure.afterReplay(MasterProcedureEnv env)
protected void	RecoverStandbyProcedure.afterReplay(MasterProcedureEnv env)
protected void	SyncReplicationReplayWALProcedure.afterReplay(MasterProcedureEnv env)
private void	RemovePeerProcedure.checkAssignReplicationQueuesFinished(MasterProcedureEnv env)
protected final void	AbstractPeerProcedure.checkPeerModificationEnabled(MasterProcedureEnv env)
private StateMachineProcedure.Flow	AssignReplicationQueuesProcedure.claimQueues(MasterProcedureEnv env)
private void	MigrateReplicationQueueFromZkToTableProcedure.cleanup(MasterProcedureEnv env)
protected boolean	ClaimReplicationQueueRemoteProcedure.complete(MasterProcedureEnv env, Throwable error)
protected boolean	RefreshPeerProcedure.complete(MasterProcedureEnv env, Throwable error)
protected boolean	SyncReplicationReplayWALRemoteProcedure.complete(MasterProcedureEnv env, Throwable error)
protected void	TransitPeerSyncReplicationStateProcedure.createDirForRemoteWAL(MasterProcedureEnv env)
private void	MigrateReplicationQueueFromZkToTableProcedure.disableReplicationLogCleaner(MasterProcedureEnv env)
protected void	AbstractPeerProcedure.enablePeer(MasterProcedureEnv env)
private void	MigrateReplicationQueueFromZkToTableProcedure.enableReplicationLogCleaner(MasterProcedureEnv env)
protected Procedure<MasterProcedureEnv>[]	ClaimReplicationQueueRemoteProcedure.execute(MasterProcedureEnv env)
protected Procedure<MasterProcedureEnv>[]	ClaimReplicationQueuesProcedure.execute(MasterProcedureEnv env)	Deprecated.
protected StateMachineProcedure.Flow	AssignReplicationQueuesProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.AssignReplicationQueuesState state)
protected StateMachineProcedure.Flow	MigrateReplicationQueueFromZkToTableProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.MigrateReplicationQueueFromZkToTableState state)
protected StateMachineProcedure.Flow	ModifyPeerProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.PeerModificationState state)
protected StateMachineProcedure.Flow	RecoverStandbyProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.RecoverStandbyState state)
protected StateMachineProcedure.Flow	SyncReplicationReplayWALProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.SyncReplicationReplayWALState state)
protected StateMachineProcedure.Flow	TransitPeerSyncReplicationStateProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.PeerSyncReplicationStateTransitionState state)
protected boolean	AbstractPeerProcedure.holdLock(MasterProcedureEnv env)
protected void	AddPeerProcedure.postPeerModification(MasterProcedureEnv env)
protected void	DisablePeerProcedure.postPeerModification(MasterProcedureEnv env)
protected void	EnablePeerProcedure.postPeerModification(MasterProcedureEnv env)
protected abstract void	ModifyPeerProcedure.postPeerModification(MasterProcedureEnv env)	Called before we finish the procedure.
protected void	RemovePeerProcedure.postPeerModification(MasterProcedureEnv env)
protected void	UpdatePeerConfigProcedure.postPeerModification(MasterProcedureEnv env)
private void	TransitPeerSyncReplicationStateProcedure.postTransit(MasterProcedureEnv env)
protected void	AddPeerProcedure.prePeerModification(MasterProcedureEnv env)
protected void	DisablePeerProcedure.prePeerModification(MasterProcedureEnv env)
protected void	EnablePeerProcedure.prePeerModification(MasterProcedureEnv env)
protected abstract void	ModifyPeerProcedure.prePeerModification(MasterProcedureEnv env)	Called before we start the actual processing.
protected void	RemovePeerProcedure.prePeerModification(MasterProcedureEnv env)
protected void	UpdatePeerConfigProcedure.prePeerModification(MasterProcedureEnv env)
protected void	TransitPeerSyncReplicationStateProcedure.preTransit(MasterProcedureEnv env)
protected final void	AbstractPeerProcedure.refreshPeer(MasterProcedureEnv env, PeerProcedureInterface.PeerOperationType type)
protected void	AddPeerProcedure.releaseLatch(MasterProcedureEnv env)
protected void	ModifyPeerProcedure.releaseLatch(MasterProcedureEnv env)
protected void	AbstractPeerProcedure.releaseLock(MasterProcedureEnv env)
Optional<RemoteProcedureDispatcher.RemoteOperation>	ClaimReplicationQueueRemoteProcedure.remoteCallBuild(MasterProcedureEnv env, ServerName remote)
Optional<RemoteProcedureDispatcher.RemoteOperation>	RefreshPeerProcedure.remoteCallBuild(MasterProcedureEnv env, ServerName remote)
Optional<RemoteProcedureDispatcher.RemoteOperation>	SyncReplicationReplayWALRemoteProcedure.remoteCallBuild(MasterProcedureEnv env, ServerName remote)
protected void	TransitPeerSyncReplicationStateProcedure.removeAllReplicationQueues(MasterProcedureEnv env)
private void	AssignReplicationQueuesProcedure.removeQueues(MasterProcedureEnv env)
private void	RemovePeerProcedure.removeRemoteWALs(MasterProcedureEnv env)
protected void	ModifyPeerProcedure.reopenRegions(MasterProcedureEnv env)
protected void	TransitPeerSyncReplicationStateProcedure.reopenRegions(MasterProcedureEnv env)
protected void	ClaimReplicationQueueRemoteProcedure.rollback(MasterProcedureEnv env)
protected void	ClaimReplicationQueuesProcedure.rollback(MasterProcedureEnv env)	Deprecated.
protected void	RefreshPeerProcedure.rollback(MasterProcedureEnv env)
protected void	SyncReplicationReplayWALRemoteProcedure.rollback(MasterProcedureEnv env)
protected void	AbstractPeerNoLockProcedure.rollbackState(MasterProcedureEnv env, TState state)
protected void	AssignReplicationQueuesProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.AssignReplicationQueuesState state)
protected void	MigrateReplicationQueueFromZkToTableProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.MigrateReplicationQueueFromZkToTableState state)
protected void	SyncReplicationReplayWALProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.SyncReplicationReplayWALState state)
protected final void	AbstractPeerProcedure.setLastPushedSequenceId(MasterProcedureEnv env, ReplicationPeerConfig peerConfig)
protected final void	AbstractPeerProcedure.setLastPushedSequenceIdForTable(MasterProcedureEnv env, TableName tableName, Map<String,Long> lastSeqIds)
protected void	TransitPeerSyncReplicationStateProcedure.setPeerNewSyncReplicationState(MasterProcedureEnv env)
protected boolean	AbstractPeerNoLockProcedure.setTimeoutFailure(MasterProcedureEnv env)
protected boolean	AssignReplicationQueuesProcedure.setTimeoutFailure(MasterProcedureEnv env)
protected boolean	ClaimReplicationQueuesProcedure.setTimeoutFailure(MasterProcedureEnv env)	Deprecated.
protected boolean	MigrateReplicationQueueFromZkToTableProcedure.setTimeoutFailure(MasterProcedureEnv env)
private boolean	ModifyPeerProcedure.shouldFailForMigrating(MasterProcedureEnv env)
private boolean	AssignReplicationQueuesProcedure.shouldSkip(MasterProcedureEnv env)
private boolean	ClaimReplicationQueueRemoteProcedure.shouldSkip(MasterProcedureEnv env)
protected void	TransitPeerSyncReplicationStateProcedure.transitPeerSyncReplicationState(MasterProcedureEnv env)
private void	SyncReplicationReplayWALRemoteProcedure.truncateWALs(MasterProcedureEnv env)	Only truncate wals one by one when task succeed.
protected void	AddPeerProcedure.updateLastPushedSequenceIdForSerialPeer(MasterProcedureEnv env)
protected void	ModifyPeerProcedure.updateLastPushedSequenceIdForSerialPeer(MasterProcedureEnv env)
protected void	UpdatePeerConfigProcedure.updateLastPushedSequenceIdForSerialPeer(MasterProcedureEnv env)
protected void	AddPeerProcedure.updatePeerStorage(MasterProcedureEnv env)
protected void	DisablePeerProcedure.updatePeerStorage(MasterProcedureEnv env)
protected void	EnablePeerProcedure.updatePeerStorage(MasterProcedureEnv env)
protected abstract void	ModifyPeerProcedure.updatePeerStorage(MasterProcedureEnv env)
protected void	RemovePeerProcedure.updatePeerStorage(MasterProcedureEnv env)
protected void	UpdatePeerConfigProcedure.updatePeerStorage(MasterProcedureEnv env)
protected boolean	AbstractPeerNoLockProcedure.waitInitialized(MasterProcedureEnv env)
protected boolean	ClaimReplicationQueueRemoteProcedure.waitInitialized(MasterProcedureEnv env)
protected boolean	RefreshPeerProcedure.waitInitialized(MasterProcedureEnv env)
private void	MigrateReplicationQueueFromZkToTableProcedure.waitUntilNoPeerProcedure(MasterProcedureEnv env)

Uses of MasterProcedureEnv in org.apache.hadoop.hbase.procedure2

Methods in org.apache.hadoop.hbase.procedure2 with parameters of type MasterProcedureEnv

Modifier and Type	Method	Description
static void	ProcedureFutureUtil.suspendIfNecessary(Procedure<?> proc, Consumer<CompletableFuture<Void>> setFuture, CompletableFuture<Void> future, MasterProcedureEnv env, Runnable actionAfterDone)
static void	ProcedureFutureUtil.wakeUp(Procedure<?> proc, MasterProcedureEnv env)

Uses of MasterProcedureEnv in org.apache.hadoop.hbase.regionserver

Methods in org.apache.hadoop.hbase.regionserver with parameters of type MasterProcedureEnv

Modifier and Type	Method	Description
org.apache.hadoop.fs.Path	HRegionFileSystem.commitDaughterRegion(RegionInfo regionInfo, List<org.apache.hadoop.fs.Path> allRegionFiles, MasterProcedureEnv env)	Commit a daughter region, moving it from the split temporary directory to the proper location in the filesystem.
void	HRegionFileSystem.commitMergedRegion(List<org.apache.hadoop.fs.Path> allMergedFiles, MasterProcedureEnv env)	Commit a merged region, making it ready for use.
private void	HRegionFileSystem.insertRegionFilesIntoStoreTracker(List<org.apache.hadoop.fs.Path> allFiles, MasterProcedureEnv env, HRegionFileSystem regionFs)

Uses of MasterProcedureEnv in org.apache.hadoop.hbase.regionserver.storefiletracker

Methods in org.apache.hadoop.hbase.regionserver.storefiletracker with parameters of type MasterProcedureEnv

Modifier and Type	Method	Description
protected StateMachineProcedure.Flow	ModifyStoreFileTrackerProcedure.executeFromState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.ModifyStoreFileTrackerState state)
private void	ModifyStoreFileTrackerProcedure.finish(MasterProcedureEnv env)
private void	ModifyStoreFileTrackerProcedure.migrate(MasterProcedureEnv env)
protected Optional<TableDescriptor>	InitializeStoreFileTrackerProcedure.modify(MasterProcedureEnv env, TableDescriptor current)
private StateMachineProcedure.Flow	ModifyStoreFileTrackerProcedure.preCheckAndTryRestoreSFT(MasterProcedureEnv env)
protected void	ModifyStoreFileTrackerProcedure.rollbackState(MasterProcedureEnv env, org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.ModifyStoreFileTrackerState state)

Constructors in org.apache.hadoop.hbase.regionserver.storefiletracker with parameters of type MasterProcedureEnv

Modifier	Constructor	Description
	InitializeStoreFileTrackerProcedure(MasterProcedureEnv env, TableName tableName)
	ModifyColumnFamilyStoreFileTrackerProcedure(MasterProcedureEnv env, TableName tableName, byte[] family, String dstSFT)
protected	ModifyStoreFileTrackerProcedure(MasterProcedureEnv env, TableName tableName, String dstSFT)
	ModifyTableStoreFileTrackerProcedure(MasterProcedureEnv env, TableName tableName, String dstSFT)

Uses of MasterProcedureEnv in org.apache.hadoop.hbase.rsgroup

Methods in org.apache.hadoop.hbase.rsgroup with parameters of type MasterProcedureEnv

Modifier and Type	Method	Description
protected Optional<TableDescriptor>	MigrateRSGroupProcedure.modify(MasterProcedureEnv env, TableDescriptor current)

Constructors in org.apache.hadoop.hbase.rsgroup with parameters of type MasterProcedureEnv

Modifier	Constructor	Description
	MigrateRSGroupProcedure(MasterProcedureEnv env, TableName tableName)