Modifier and Type | Method and Description |
---|---|
(package private) List<Procedure> |
SplitWALManager.createSplitWALProcedures(List<org.apache.hadoop.fs.FileStatus> splittingWALs,
ServerName crashedServer) |
List<Procedure<?>> |
MasterServices.getProcedures()
Get procedures
|
List<Procedure<?>> |
HMaster.getProcedures() |
List<Procedure> |
SplitWALManager.splitWALs(ServerName crashedServer,
boolean splitMeta) |
Modifier and Type | Method and Description |
---|---|
ServerName |
SplitWALManager.acquireSplitWALWorker(Procedure<?> procedure)
Acquire a split WAL worker
|
private long |
ClusterSchemaServiceImpl.submitProcedure(Procedure<MasterProcedureEnv> procedure,
NonceKey nonceKey) |
void |
SplitWALManager.SplitWorkerAssigner.suspend(Procedure<?> proc) |
Modifier and Type | Method and Description |
---|---|
void |
MasterCoprocessorHost.postGetProcedures(List<Procedure<?>> procInfoList) |
Modifier and Type | Class and Description |
---|---|
private static class |
AssignmentManager.DeadServerMetricRegionChore |
private static class |
AssignmentManager.RegionInTransitionChore |
class |
AssignProcedure
Deprecated.
Do not use any more.
|
class |
CloseRegionProcedure
The remote procedure used to close a region.
|
class |
GCMergedRegionsProcedure
Deprecated.
2.3.0 Use
GCMultipleMergedRegionsProcedure . |
class |
GCMultipleMergedRegionsProcedure
GC regions that have been Merged.
|
class |
GCRegionProcedure
GC a Region that is no longer in use.
|
class |
MergeTableRegionsProcedure
The procedure to Merge regions in a table.
|
class |
MoveRegionProcedure
Deprecated.
Do not use any more.
|
class |
OpenRegionProcedure
The remote procedure used to open a region.
|
class |
RegionRemoteProcedureBase
The base class for the remote procedures used to open/close a region.
|
class |
RegionTransitionProcedure
Deprecated.
Do not use any more.
|
class |
SplitTableRegionProcedure
The procedure to split a region in a table.
|
class |
TransitRegionStateProcedure
The procedure to deal with the state transition of a region.
|
class |
UnassignProcedure
Deprecated.
Do not use any more.
|
Modifier and Type | Method and Description |
---|---|
protected Procedure[] |
TransitRegionStateProcedure.execute(MasterProcedureEnv env) |
protected Procedure<MasterProcedureEnv>[] |
RegionRemoteProcedureBase.execute(MasterProcedureEnv env) |
protected Procedure[] |
RegionTransitionProcedure.execute(MasterProcedureEnv env)
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
boolean |
AssignmentManager.waitMetaAssigned(Procedure<?> proc,
RegionInfo regionInfo)
Notice that this event does not mean the AM has already finished region state rebuilding.
|
boolean |
AssignmentManager.waitMetaLoaded(Procedure<?> proc)
Wait until AM finishes the meta loading, i.e, the region states rebuilding.
|
Modifier and Type | Class and Description |
---|---|
class |
LockProcedure
Procedure to allow blessed clients and external admin tools to take our internal Schema locks
used by the procedure framework isolating procedures doing creates/deletes etc.
|
Modifier and Type | Method and Description |
---|---|
protected Procedure<MasterProcedureEnv>[] |
LockProcedure.execute(MasterProcedureEnv env) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractStateMachineNamespaceProcedure<TState>
Base class for all the Namespace procedures that want to use a StateMachineProcedure.
|
class |
AbstractStateMachineRegionProcedure<TState>
Base class for all the Region procedures that want to use a StateMachine.
|
class |
AbstractStateMachineTableProcedure<TState>
Base class for all the Table procedures that want to use a StateMachineProcedure.
|
class |
CloneSnapshotProcedure |
class |
CreateNamespaceProcedure
The procedure to create a new namespace.
|
class |
CreateTableProcedure |
class |
DeleteNamespaceProcedure
The procedure to remove a namespace.
|
class |
DeleteTableProcedure |
class |
DisableTableProcedure |
class |
EnableTableProcedure |
class |
HBCKServerCrashProcedure
Acts like the super class in all cases except when no Regions found in the current Master
in-memory context.
|
class |
InitMetaProcedure
This procedure is used to initialize meta table for a new hbase deploy.
|
class |
ModifyNamespaceProcedure
The procedure to add a namespace to an existing table.
|
class |
ModifyTableDescriptorProcedure
The procedure will only update the table descriptor without reopening all the regions.
|
class |
ModifyTableProcedure |
class |
RecoverMetaProcedure
Deprecated.
Do not use any more, leave it here only for compatible. The recovery work will be
done in
ServerCrashProcedure directly, and the initial work for meta table
will be done by InitMetaProcedure . |
class |
ReopenTableRegionsProcedure
Used for reopening the regions for a table.
|
class |
RestoreSnapshotProcedure |
class |
ServerCrashProcedure
Handle crashed server.
|
class |
ServerRemoteProcedure |
class |
SplitWALProcedure
The procedure is to split a WAL.
|
class |
SplitWALRemoteProcedure
A remote procedure which is used to send split WAL request to region server.
|
class |
SwitchRpcThrottleProcedure
The procedure to switch rpc throttle
|
class |
SwitchRpcThrottleRemoteProcedure
The procedure to switch rpc throttle on region server
|
class |
TruncateTableProcedure |
Modifier and Type | Field and Description |
---|---|
private Procedure<?> |
ProcedureSyncWait.ProcedureFuture.proc |
Modifier and Type | Field and Description |
---|---|
private Function<Long,Procedure<?>> |
SchemaLocking.procedureRetriever |
Modifier and Type | Method and Description |
---|---|
private Procedure[] |
ServerCrashProcedure.createSplittingWalProcedures(MasterProcedureEnv env,
boolean splitMeta) |
protected Procedure |
MasterProcedureScheduler.dequeue() |
private <T extends Comparable<T>> |
MasterProcedureScheduler.doPoll(FairQueue<T> fairq) |
protected Procedure<MasterProcedureEnv>[] |
ServerRemoteProcedure.execute(MasterProcedureEnv env) |
Procedure<?> |
Queue.peek() |
Procedure<?> |
Queue.poll() |
Modifier and Type | Method and Description |
---|---|
void |
Queue.add(Procedure<?> proc,
boolean addToFront) |
void |
MasterProcedureScheduler.completionCleanup(Procedure proc) |
protected abstract void |
ProcedurePrepareLatch.countDown(Procedure proc) |
protected void |
ProcedurePrepareLatch.NoopLatch.countDown(Procedure proc) |
protected void |
ProcedurePrepareLatch.CompatibilityLatch.countDown(Procedure proc) |
static String |
ProcedureDescriber.describe(Procedure<?> proc) |
static String |
ProcedureDescriber.describeParameters(Procedure<?> proc) |
private <T extends Comparable<T>> |
MasterProcedureScheduler.doAdd(FairQueue<T> fairq,
Queue<T> queue,
Procedure<?> proc,
boolean addFront) |
protected void |
MasterProcedureScheduler.enqueue(Procedure proc,
boolean addFront) |
private static String |
MasterProcedureScheduler.getPeerId(Procedure<?> proc) |
private static ServerName |
MasterProcedureScheduler.getServerName(Procedure<?> proc) |
private static TableName |
MasterProcedureScheduler.getTableName(Procedure<?> proc) |
private <T extends Comparable<T>> |
MasterProcedureScheduler.isLockReady(Procedure<?> proc,
Queue<T> rq) |
private static boolean |
MasterProcedureScheduler.isMetaProcedure(Procedure<?> proc) |
private static boolean |
MasterProcedureScheduler.isPeerProcedure(Procedure<?> proc) |
private static boolean |
MasterProcedureScheduler.isServerProcedure(Procedure<?> proc) |
private static boolean |
MasterProcedureScheduler.isTableProcedure(Procedure<?> proc) |
(package private) boolean |
MasterProcedureScheduler.markTableAsDeleted(TableName table,
Procedure<?> procedure)
Tries to remove the queue and the table-lock of the specified table.
|
private static Object |
ProcedureDescriber.parametersToObject(Procedure<?> proc) |
static void |
ProcedurePrepareLatch.releaseLatch(ProcedurePrepareLatch latch,
Procedure proc) |
(package private) boolean |
MetaQueue.requireExclusiveLock(Procedure<?> proc)
Deprecated.
|
(package private) abstract boolean |
Queue.requireExclusiveLock(Procedure<?> proc) |
boolean |
ServerQueue.requireExclusiveLock(Procedure<?> proc) |
boolean |
PeerQueue.requireExclusiveLock(Procedure<?> proc) |
boolean |
TableQueue.requireExclusiveLock(Procedure<?> 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) |
private void |
MasterProcedureScheduler.tryCleanupPeerQueue(String peerId,
Procedure procedure) |
private void |
MasterProcedureScheduler.tryCleanupServerQueue(ServerName serverName,
Procedure<?> proc) |
static IOException |
MasterProcedureUtil.unwrapRemoteIOException(Procedure proc)
This is a version of unwrapRemoteIOException that can do DoNotRetryIOE.
|
static byte[] |
ProcedureSyncWait.waitForProcedureToComplete(ProcedureExecutor<MasterProcedureEnv> procExec,
Procedure<?> proc,
long timeout) |
static byte[] |
ProcedureSyncWait.waitForProcedureToCompleteIOE(ProcedureExecutor<MasterProcedureEnv> procExec,
Procedure<?> proc,
long timeout) |
boolean |
MasterProcedureEnv.waitInitialized(Procedure<?> proc) |
boolean |
MasterProcedureScheduler.waitMetaExclusiveLock(Procedure<?> procedure)
Deprecated.
only used for
RecoverMetaProcedure . Should be removed along with
RecoverMetaProcedure . |
boolean |
MasterProcedureScheduler.waitNamespaceExclusiveLock(Procedure<?> procedure,
String namespace)
Suspend the procedure if the specified namespace is already locked.
|
boolean |
MasterProcedureScheduler.waitPeerExclusiveLock(Procedure<?> procedure,
String peerId)
Try to acquire the exclusive lock on the specified peer.
|
boolean |
MasterProcedureScheduler.waitRegion(Procedure<?> procedure,
RegionInfo regionInfo)
Suspend the procedure if the specified region is already locked.
|
boolean |
MasterProcedureScheduler.waitRegions(Procedure<?> procedure,
TableName table,
RegionInfo... regionInfos)
Suspend the procedure if the specified set of regions are already locked.
|
boolean |
MasterProcedureScheduler.waitServerExclusiveLock(Procedure<?> procedure,
ServerName serverName)
Try to acquire the exclusive lock on the specified server.
|
boolean |
MasterProcedureScheduler.waitTableExclusiveLock(Procedure<?> procedure,
TableName table)
Suspend the procedure if the specified table is already locked.
|
private TableQueue |
MasterProcedureScheduler.waitTableQueueSharedLock(Procedure<?> procedure,
TableName table) |
boolean |
MasterProcedureScheduler.waitTableSharedLock(Procedure<?> procedure,
TableName table)
Suspend the procedure if the specified table is already locked.
|
void |
MasterProcedureScheduler.wakeMetaExclusiveLock(Procedure<?> procedure)
Deprecated.
only used for
RecoverMetaProcedure . Should be removed along with
RecoverMetaProcedure . |
void |
MasterProcedureScheduler.wakeNamespaceExclusiveLock(Procedure<?> procedure,
String namespace)
Wake the procedures waiting for the specified namespace
|
void |
MasterProcedureScheduler.wakePeerExclusiveLock(Procedure<?> procedure,
String peerId)
Wake the procedures waiting for the specified peer
|
void |
MasterProcedureScheduler.wakeRegion(Procedure<?> procedure,
RegionInfo regionInfo)
Wake the procedures waiting for the specified region
|
void |
MasterProcedureScheduler.wakeRegions(Procedure<?> procedure,
TableName table,
RegionInfo... regionInfos)
Wake the procedures waiting for the specified regions
|
void |
MasterProcedureScheduler.wakeServerExclusiveLock(Procedure<?> procedure,
ServerName serverName)
Wake the procedures waiting for the specified server
|
void |
MasterProcedureScheduler.wakeTableExclusiveLock(Procedure<?> procedure,
TableName table)
Wake the procedures waiting for the specified table
|
void |
MasterProcedureScheduler.wakeTableSharedLock(Procedure<?> procedure,
TableName table)
Wake the procedures waiting for the specified table
|
void |
MasterProcedureScheduler.yield(Procedure proc) |
Constructor and Description |
---|
ProcedureFuture(ProcedureExecutor<MasterProcedureEnv> procExec,
Procedure<?> proc) |
Constructor and Description |
---|
MasterProcedureScheduler(Function<Long,Procedure<?>> procedureRetriever) |
SchemaLocking(Function<Long,Procedure<?>> procedureRetriever) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractPeerProcedure<TState>
The base class for all replication peer related procedure.
|
class |
AddPeerProcedure
The procedure for adding a new replication peer.
|
class |
ClaimReplicationQueueRemoteProcedure |
class |
ClaimReplicationQueuesProcedure
Used to assign the replication queues of a dead server to other region servers.
|
class |
DisablePeerProcedure
The procedure for disabling a replication peer.
|
class |
EnablePeerProcedure
The procedure for enabling a replication peer.
|
class |
ModifyPeerProcedure
The base class for all replication peer related procedure except sync replication state
transition.
|
class |
RefreshPeerProcedure |
class |
RemovePeerProcedure
The procedure for removing a replication peer.
|
class |
UpdatePeerConfigProcedure
The procedure for updating the config for a replication peer.
|
Modifier and Type | Method and Description |
---|---|
protected Procedure<MasterProcedureEnv>[] |
ClaimReplicationQueuesProcedure.execute(MasterProcedureEnv env) |
Modifier and Type | Class and Description |
---|---|
(package private) class |
CompletedProcedureCleaner<TEnvironment>
Internal cleaner that removes the completed procedure results after a TTL.
|
class |
FailedProcedure<TEnvironment> |
class |
OnePhaseProcedure<TEnvironment> |
class |
ProcedureInMemoryChore<TEnvironment>
Special procedure used as a chore.
|
class |
SequentialProcedure<TEnvironment>
A SequentialProcedure describes one step in a procedure chain:
|
class |
StateMachineProcedure<TEnvironment,TState>
Procedure described by a series of steps.
|
class |
TwoPhaseProcedure<TEnvironment> |
Modifier and Type | Field and Description |
---|---|
private Procedure<TEnvironment> |
ProcedureExecutor.WorkerThread.activeProcedure |
private Procedure<?> |
LockedResource.exclusiveLockOwnerProcedure |
private Procedure<?> |
LockAndQueue.exclusiveLockOwnerProcedure |
private Procedure<TEnvironment> |
CompletedProcedureRetainer.procedure |
Modifier and Type | Field and Description |
---|---|
private Function<Long,Procedure<?>> |
LockAndQueue.procedureRetriever |
private ConcurrentHashMap<Long,Procedure<TEnvironment>> |
ProcedureExecutor.procedures
Helper map to lookup the live procedures by ID.
|
private List<Procedure<TEnvironment>> |
StateMachineProcedure.subProcList |
private Set<Procedure<TEnvironment>> |
RootProcedureState.subprocs |
private ArrayList<Procedure<TEnvironment>> |
RootProcedureState.subprocStack |
private List<Procedure<?>> |
LockedResource.waitingProcedures |
Modifier and Type | Method and Description |
---|---|
protected <T extends Procedure<TEnvironment>> |
StateMachineProcedure.addChildProcedure(T... subProcedure)
Add a child procedure to execute
|
<T extends Procedure<TEnvironment>> |
ProcedureExecutor.getProcedure(Class<T> clazz,
long procId) |
Modifier and Type | Method and Description |
---|---|
static Procedure<?> |
ProcedureUtil.convertToProcedure(org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.Procedure proto)
Helper to convert the protobuf procedure.
|
protected abstract Procedure |
AbstractProcedureScheduler.dequeue()
Fetch one Procedure from the queue NOTE: this method is called with the sched lock held.
|
protected Procedure |
SimpleProcedureScheduler.dequeue() |
protected Procedure<TEnvironment>[] |
Procedure.doExecute(TEnvironment env)
Internal method called by the ProcedureExecutor that starts the user-level code execute().
|
protected Procedure[] |
SequentialProcedure.doExecute(TEnvironment env) |
protected Procedure[] |
StateMachineProcedure.execute(TEnvironment env) |
protected abstract Procedure<TEnvironment>[] |
Procedure.execute(TEnvironment env)
The main code of the procedure.
|
protected Procedure<TEnvironment>[] |
FailedProcedure.execute(TEnvironment env) |
protected Procedure<TEnvironment>[] |
ProcedureInMemoryChore.execute(TEnvironment env) |
Procedure<?> |
LockedResource.getExclusiveLockOwnerProcedure() |
Procedure<?> |
LockAndQueue.getExclusiveLockOwnerProcedure() |
Procedure<?> |
LockStatus.getExclusiveLockOwnerProcedure()
Get the procedure which holds the exclusive lock.
|
Procedure<TEnvironment> |
CompletedProcedureRetainer.getProcedure() |
Procedure<TEnvironment> |
ProcedureExecutor.getProcedure(long procId) |
Procedure<TEnvironment> |
ProcedureExecutor.getResult(long procId) |
Procedure<TEnvironment> |
ProcedureExecutor.getResultOrProcedure(long procId) |
private Procedure<TEnvironment>[] |
ProcedureExecutor.initializeChildren(RootProcedureState<TEnvironment> procStack,
Procedure<TEnvironment> procedure,
Procedure<TEnvironment>[] subprocs) |
private static Procedure<?> |
ProcedureUtil.newProcedure(String className) |
Procedure |
AbstractProcedureScheduler.poll() |
Procedure |
ProcedureScheduler.poll()
Fetch one Procedure from the queue
|
Procedure |
AbstractProcedureScheduler.poll(long nanos) |
Procedure |
AbstractProcedureScheduler.poll(long timeout,
TimeUnit unit) |
Procedure |
ProcedureScheduler.poll(long timeout,
TimeUnit unit)
Fetch one Procedure from the queue
|
private Procedure<TEnvironment> |
ProcedureExecutor.prepareProcedure(Procedure<TEnvironment> proc) |
Procedure<?> |
LockAndQueue.removeFirst() |
Modifier and Type | Method and Description |
---|---|
Stream<Procedure> |
LockAndQueue.filterWaitingQueue(Predicate<Procedure> predicate) |
Collection<Procedure<TEnvironment>> |
ProcedureExecutor.getActiveProceduresNoCopy()
Should only be used when starting up, where the procedure workers have not been started.
|
List<Procedure<TEnvironment>> |
ProcedureExecutor.getProcedures()
Get procedures.
|
protected List<Procedure<TEnvironment>> |
RootProcedureState.getSubproceduresStack() |
List<Procedure<?>> |
LockedResource.getWaitingProcedures() |
Modifier and Type | Method and Description |
---|---|
protected boolean |
RootProcedureState.acquire(Procedure<TEnvironment> proc)
Called by the ProcedureExecutor to mark the procedure step as running.
|
private Procedure.LockState |
ProcedureExecutor.acquireLock(Procedure<TEnvironment> proc) |
void |
TimeoutExecutorThread.add(Procedure<TEnvironment> procedure) |
void |
AbstractProcedureScheduler.addBack(Procedure procedure) |
void |
ProcedureScheduler.addBack(Procedure proc)
Inserts the specified element at the end of this queue.
|
void |
AbstractProcedureScheduler.addBack(Procedure procedure,
boolean notify) |
void |
ProcedureScheduler.addBack(Procedure proc,
boolean notify)
Inserts the specified element at the end of this queue.
|
protected <T extends Procedure<TEnvironment>> |
StateMachineProcedure.addChildProcedure(T... subProcedure)
Add a child procedure to execute
|
void |
AbstractProcedureScheduler.addFront(Procedure procedure) |
void |
ProcedureScheduler.addFront(Procedure proc)
Inserts the specified element at the front of this queue.
|
void |
AbstractProcedureScheduler.addFront(Procedure procedure,
boolean notify) |
void |
ProcedureScheduler.addFront(Procedure proc,
boolean notify)
Inserts the specified element at the front of this queue.
|
void |
LockAndQueue.addLast(Procedure<?> proc) |
protected void |
RootProcedureState.addRollbackStep(Procedure<TEnvironment> proc)
Called by the ProcedureExecutor after the procedure step is completed, to add the step to the
rollback list (or procedure stack)
|
protected void |
RootProcedureState.addSubProcedure(Procedure<TEnvironment> proc) |
private void |
ProcedureExecutor.cleanupAfterRollbackOneStep(Procedure<TEnvironment> proc) |
int |
Procedure.compareTo(Procedure<TEnvironment> other) |
void |
SimpleProcedureScheduler.completionCleanup(Procedure proc) |
void |
ProcedureScheduler.completionCleanup(Procedure proc)
The procedure in execution completed.
|
static org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.Procedure |
ProcedureUtil.convertToProtoProcedure(Procedure<?> proc)
Helper to convert the procedure to protobuf.
|
private void |
ProcedureExecutor.countDownChildren(RootProcedureState<TEnvironment> procStack,
Procedure<TEnvironment> procedure) |
protected abstract void |
AbstractProcedureScheduler.enqueue(Procedure procedure,
boolean addFront)
Add the procedure to the queue.
|
protected void |
SimpleProcedureScheduler.enqueue(Procedure procedure,
boolean addFront) |
private void |
ProcedureExecutor.execCompletionCleanup(Procedure<TEnvironment> proc) |
private void |
ProcedureExecutor.execProcedure(RootProcedureState<TEnvironment> procStack,
Procedure<TEnvironment> procedure)
Executes
procedure
Calls the doExecute() of the procedure
If the procedure execution didn't fail (i.e. |
private void |
ProcedureExecutor.executeProcedure(Procedure<TEnvironment> proc) |
private Procedure.LockState |
ProcedureExecutor.executeRollback(Procedure<TEnvironment> proc)
Execute the rollback of the procedure step.
|
protected void |
TimeoutExecutorThread.executeTimedoutProcedure(Procedure<TEnvironment> proc) |
protected static <T> Long |
Procedure.getRootProcedureId(Map<Long,Procedure<T>> procedures,
Procedure<T> proc)
Helper to lookup the root Procedure ID given a specified procedure.
|
(package private) Long |
ProcedureExecutor.getRootProcedureId(Procedure<TEnvironment> proc) |
private void |
ProcedureExecutor.handleInterruptedException(Procedure<TEnvironment> proc,
InterruptedException e) |
boolean |
LockAndQueue.hasLockAccess(Procedure<?> proc) |
boolean |
LockStatus.hasLockAccess(Procedure<?> proc)
Return true if the procedure itself holds the exclusive lock, or any ancestors of the give
procedure hold the exclusive lock.
|
static boolean |
Procedure.haveSameParent(Procedure<?> a,
Procedure<?> b) |
static boolean |
Procedure.haveSameParent(Procedure<?> a,
Procedure<?> b) |
private Procedure<TEnvironment>[] |
ProcedureExecutor.initializeChildren(RootProcedureState<TEnvironment> procStack,
Procedure<TEnvironment> procedure,
Procedure<TEnvironment>[] subprocs) |
private Procedure<TEnvironment>[] |
ProcedureExecutor.initializeChildren(RootProcedureState<TEnvironment> procStack,
Procedure<TEnvironment> procedure,
Procedure<TEnvironment>[] subprocs) |
private boolean |
ProcedureExecutor.isRootFinished(Procedure<?> proc) |
protected void |
RootProcedureState.loadStack(Procedure<TEnvironment> proc)
Called on store load by the ProcedureExecutor to load part of the stack.
|
private Procedure<TEnvironment> |
ProcedureExecutor.prepareProcedure(Procedure<TEnvironment> proc) |
private void |
ProcedureExecutor.procedureFinished(Procedure<TEnvironment> proc) |
protected void |
AbstractProcedureScheduler.push(Procedure procedure,
boolean addFront,
boolean notify) |
private long |
ProcedureExecutor.pushProcedure(Procedure<TEnvironment> proc) |
protected void |
RootProcedureState.release(Procedure<TEnvironment> proc)
Called by the ProcedureExecutor to mark the procedure step as finished.
|
boolean |
LockAndQueue.releaseExclusiveLock(Procedure<?> proc)
Returns whether we should wake the procedures waiting on the lock here.
|
private void |
ProcedureExecutor.releaseLock(Procedure<TEnvironment> proc,
boolean force) |
boolean |
TimeoutExecutorThread.remove(Procedure<TEnvironment> procedure) |
private void |
ProcedureExecutor.restoreLock(Procedure<TEnvironment> proc,
Set<Long> restored) |
private void |
ProcedureExecutor.submitChildrenProcedures(Procedure<TEnvironment>[] subprocs) |
long |
ProcedureExecutor.submitProcedure(Procedure<TEnvironment> proc)
Add a new root-procedure to the executor.
|
long |
ProcedureExecutor.submitProcedure(Procedure<TEnvironment> proc,
NonceKey nonceKey)
Add a new root-procedure to the executor.
|
void |
ProcedureExecutor.submitProcedures(Procedure<TEnvironment>[] procs)
Add a set of new root-procedure to the executor.
|
boolean |
ProcedureEvent.suspendIfNotReady(Procedure proc)
Returns true if event is not ready and adds procedure to suspended queue, else returns false.
|
boolean |
LockAndQueue.tryExclusiveLock(Procedure<?> proc) |
boolean |
LockAndQueue.trySharedLock(Procedure<?> proc)
Returns whether we have succesfully acquired the shared lock.
|
private void |
ProcedureExecutor.updateStoreOnExec(RootProcedureState<TEnvironment> procStack,
Procedure<TEnvironment> procedure,
Procedure<TEnvironment>[] subprocs) |
private void |
ProcedureExecutor.updateStoreOnExec(RootProcedureState<TEnvironment> procStack,
Procedure<TEnvironment> procedure,
Procedure<TEnvironment>[] subprocs) |
(package private) static void |
ProcedureUtil.validateClass(Procedure<?> proc) |
protected void |
AbstractProcedureScheduler.waitProcedure(LockAndQueue lockAndQueue,
Procedure proc) |
boolean |
ProcedureEvent.wakeIfSuspended(AbstractProcedureScheduler procedureScheduler,
Procedure<?> proc)
Wakes up the suspended procedures only if the given
proc is waiting on this event. |
protected void |
AbstractProcedureScheduler.wakeProcedure(Procedure procedure) |
void |
SimpleProcedureScheduler.yield(Procedure proc) |
void |
ProcedureScheduler.yield(Procedure proc)
The procedure can't run at the moment.
|
private void |
ProcedureExecutor.yieldProcedure(Procedure<TEnvironment> proc) |
Modifier and Type | Method and Description |
---|---|
void |
AbstractProcedureScheduler.addFront(Iterator<Procedure> procedureIterator) |
void |
ProcedureScheduler.addFront(Iterator<Procedure> procedureIterator)
Inserts all elements in the iterator at the front of this queue.
|
Stream<Procedure> |
LockAndQueue.filterWaitingQueue(Predicate<Procedure> predicate) |
protected static <T> Long |
Procedure.getRootProcedureId(Map<Long,Procedure<T>> procedures,
Procedure<T> proc)
Helper to lookup the root Procedure ID given a specified procedure.
|
private void |
ProcedureExecutor.restoreLocks(Deque<Procedure<TEnvironment>> stack,
Set<Long> restored) |
Constructor and Description |
---|
CompletedProcedureRetainer(Procedure<TEnvironment> procedure) |
DelayedProcedure(Procedure<TEnvironment> procedure) |
LockedResource(LockedResourceType resourceType,
String resourceName,
LockType lockType,
Procedure<?> exclusiveLockOwnerProcedure,
int sharedLockCount,
List<Procedure<?>> waitingProcedures) |
Constructor and Description |
---|
LockAndQueue(Function<Long,Procedure<?>> procedureRetriever) |
LockedResource(LockedResourceType resourceType,
String resourceName,
LockType lockType,
Procedure<?> exclusiveLockOwnerProcedure,
int sharedLockCount,
List<Procedure<?>> waitingProcedures) |
Modifier and Type | Field and Description |
---|---|
private Procedure<?> |
ProtoAndProcedure.proc |
Modifier and Type | Method and Description |
---|---|
Procedure<?> |
ProtoAndProcedure.getProcedure() |
Procedure<?> |
InMemoryProcedureIterator.next() |
Procedure |
ProcedureStore.ProcedureIterator.next()
Returns the next procedure in the iteration.
|
Modifier and Type | Method and Description |
---|---|
void |
ProcedureStore.delete(Procedure<?> parentProc,
long[] subProcIds)
The parent procedure completed.
|
void |
NoopProcedureStore.delete(Procedure<?> proc,
long[] subprocs) |
void |
ProcedureStore.insert(Procedure<?>[] procs)
Serialize a set of new procedures.
|
void |
NoopProcedureStore.insert(Procedure<?>[] proc) |
void |
ProcedureStore.insert(Procedure<?> proc,
Procedure<?>[] subprocs)
When a procedure is submitted to the executor insert(proc, null) will be called.
|
void |
ProcedureStore.insert(Procedure<?> proc,
Procedure<?>[] subprocs)
When a procedure is submitted to the executor insert(proc, null) will be called.
|
void |
NoopProcedureStore.insert(Procedure<?> proc,
Procedure<?>[] subprocs) |
void |
NoopProcedureStore.insert(Procedure<?> proc,
Procedure<?>[] subprocs) |
void |
ProcedureStore.update(Procedure<?> proc)
The specified procedure was executed, and the new state should be written to the store.
|
void |
NoopProcedureStore.update(Procedure<?> proc) |
Modifier and Type | Method and Description |
---|---|
void |
RegionProcedureStore.delete(Procedure<?> parentProc,
long[] subProcIds) |
void |
RegionProcedureStore.insert(Procedure<?>[] procs) |
void |
RegionProcedureStore.insert(Procedure<?> proc,
Procedure<?>[] subProcs) |
void |
RegionProcedureStore.insert(Procedure<?> proc,
Procedure<?>[] subProcs) |
private void |
RegionProcedureStore.serializePut(Procedure<?> proc,
List<Mutation> mutations,
List<byte[]> rowsToLock) |
void |
RegionProcedureStore.update(Procedure<?> proc) |
Modifier and Type | Method and Description |
---|---|
private void |
RegionProcedureStore.checkUnsupportedProcedure(Map<Class<?>,List<Procedure<?>>> procsByType)
In HBASE-20811, we have introduced a new TRSP to assign/unassign/move regions, and it is
incompatible with the old AssignProcedure/UnassignProcedure/MoveRegionProcedure.
|
Modifier and Type | Method and Description |
---|---|
void |
WALProcedureStore.delete(Procedure<?> proc,
long[] subProcIds)
Deprecated.
|
void |
WALProcedureStore.insert(Procedure<?>[] procs)
Deprecated.
|
void |
WALProcedureStore.insert(Procedure<?> proc,
Procedure<?>[] subprocs)
Deprecated.
|
void |
WALProcedureStore.insert(Procedure<?> proc,
Procedure<?>[] subprocs)
Deprecated.
|
private void |
ProcedureWALPrettyPrinter.printProcedure(Procedure<?> proc)
Deprecated.
|
void |
WALProcedureStore.update(Procedure<?> proc)
Deprecated.
|
static void |
ProcedureWALFormat.writeDelete(ByteSlot slot,
Procedure<?> proc,
long[] subprocs)
Deprecated.
|
static void |
ProcedureWALFormat.writeEntry(ByteSlot slot,
org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureWALEntry.Type type,
Procedure<?> proc,
Procedure<?>[] subprocs)
Deprecated.
|
static void |
ProcedureWALFormat.writeEntry(ByteSlot slot,
org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureWALEntry.Type type,
Procedure<?> proc,
Procedure<?>[] subprocs)
Deprecated.
|
static void |
ProcedureWALFormat.writeInsert(ByteSlot slot,
Procedure<?> proc)
Deprecated.
|
static void |
ProcedureWALFormat.writeInsert(ByteSlot slot,
Procedure<?> proc,
Procedure<?>[] subprocs)
Deprecated.
|
static void |
ProcedureWALFormat.writeInsert(ByteSlot slot,
Procedure<?> proc,
Procedure<?>[] subprocs)
Deprecated.
|
static void |
ProcedureWALFormat.writeUpdate(ByteSlot slot,
Procedure<?> proc)
Deprecated.
|
Constructor and Description |
---|
ProcedureSpanBuilder(Procedure<?> proc) |
Modifier and Type | Class and Description |
---|---|
class |
InitializeStoreFileTrackerProcedure
Procedure for setting StoreFileTracker information to table descriptor.
|
class |
ModifyColumnFamilyStoreFileTrackerProcedure |
class |
ModifyStoreFileTrackerProcedure
This procedure is used to change the store file tracker implementation.
|
class |
ModifyTableStoreFileTrackerProcedure |
Copyright © 2007–2020 The Apache Software Foundation. All rights reserved.