@InterfaceAudience.Private public class FlushRegionProcedure extends Procedure<MasterProcedureEnv> implements TableProcedureInterface, RemoteProcedureDispatcher.RemoteProcedure<MasterProcedureEnv,ServerName>
Procedure.LockState
TableProcedureInterface.TableOperationType
Modifier and Type | Field and Description |
---|---|
private List<byte[]> |
columnFamilies |
private boolean |
dispatched |
private ProcedureEvent<?> |
event |
private static org.slf4j.Logger |
LOG |
private RegionInfo |
region |
private RetryCounter |
retryCounter |
private boolean |
succ |
NO_PROC_ID, NO_TIMEOUT
DUMMY_NAMESPACE_TABLE_NAME
Constructor and Description |
---|
FlushRegionProcedure() |
FlushRegionProcedure(RegionInfo region) |
FlushRegionProcedure(RegionInfo region,
List<byte[]> columnFamilies) |
Modifier and Type | Method and Description |
---|---|
protected boolean |
abort(MasterProcedureEnv env)
The abort() call is asynchronous and each procedure must decide how to deal with it, if they
want to be abortable.
|
private void |
complete(MasterProcedureEnv env,
Throwable error) |
protected void |
deserializeStateData(ProcedureStateSerializer serializer)
Called on store load to allow the user to decode the previously serialized state.
|
protected Procedure<MasterProcedureEnv>[] |
execute(MasterProcedureEnv env)
The main code of the procedure.
|
TableName |
getTableName()
Returns the name of the table the procedure is operating on
|
TableProcedureInterface.TableOperationType |
getTableOperationType()
Given an operation type we can take decisions about what to do with pending operations.
|
Optional<RemoteProcedureDispatcher.RemoteOperation> |
remoteCallBuild(MasterProcedureEnv env,
ServerName serverName)
For building the remote operation.
|
void |
remoteCallFailed(MasterProcedureEnv env,
ServerName serverName,
IOException e)
Called when the executeProcedure call is failed.
|
void |
remoteOperationCompleted(MasterProcedureEnv env)
Called when RS tells the remote procedure is succeeded through the
reportProcedureDone method. |
void |
remoteOperationFailed(MasterProcedureEnv env,
RemoteProcedureException error)
Called when RS tells the remote procedure is failed through the
reportProcedureDone
method. |
protected void |
rollback(MasterProcedureEnv env)
The code to undo what was done by the execute() code.
|
protected void |
serializeStateData(ProcedureStateSerializer serializer)
The user-level code of the procedure may have some state to persist (e.g.
|
protected boolean |
setTimeoutFailure(MasterProcedureEnv env)
Called by the ProcedureExecutor when the timeout set by setTimeout() is expired.
|
private void |
setTimeoutForSuspend(MasterProcedureEnv env,
String reason) |
protected boolean |
waitInitialized(MasterProcedureEnv env)
The
Procedure.doAcquireLock(Object, ProcedureStore) will be split into two steps, first, it will
call us to determine whether we need to wait for initialization, second, it will call
Procedure.acquireLock(Object) to actually handle the lock for this procedure. |
acquireLock, addStackIndex, afterReplay, beforeReplay, bypass, compareTo, completionCleanup, doExecute, doRollback, elapsedTime, getChildrenLatch, getException, getLastUpdate, getNonceKey, getOwner, getParentProcId, getProcedureMetrics, getProcId, getProcIdHashCode, getProcName, getResult, getRootProcedureId, getRootProcId, getStackIndexes, getState, getSubmittedTime, getTimeout, getTimeoutTimestamp, hasChildren, hasException, hasLock, hasOwner, hasParent, hasTimeout, haveSameParent, holdLock, incChildrenLatch, isBypass, isFailed, isFinished, isInitializing, isLockedWhenLoading, isRollbackSupported, isRunnable, isSuccess, isWaiting, isYieldAfterExecutionStep, releaseLock, removeStackIndex, setAbortFailure, setChildrenLatch, setExecuted, setFailure, setFailure, setLastUpdate, setNonceKey, setOwner, setOwner, setParentProcId, setProcId, setResult, setRootProcId, setStackIndexes, setState, setSubmittedTime, setTimeout, shouldWaitClientAck, skipPersistence, suspend, toString, toStringClass, toStringClassDetails, toStringDetails, toStringSimpleSB, toStringState, updateMetricsOnFinish, updateMetricsOnSubmit, updateTimestamp, wasExecuted
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
storeInDispatchedQueue
private static final org.slf4j.Logger LOG
private RegionInfo region
private List<byte[]> columnFamilies
private ProcedureEvent<?> event
private boolean dispatched
private boolean succ
private RetryCounter retryCounter
public FlushRegionProcedure()
public FlushRegionProcedure(RegionInfo region)
public FlushRegionProcedure(RegionInfo region, List<byte[]> columnFamilies)
protected Procedure<MasterProcedureEnv>[] execute(MasterProcedureEnv env) throws ProcedureYieldException, ProcedureSuspendedException, InterruptedException
Procedure
execute
in class Procedure<MasterProcedureEnv>
env
- the environment passed to the ProcedureExecutorProcedureYieldException
- the procedure will be added back to the queue and retried
later.ProcedureSuspendedException
- Signal to the executor that Procedure has suspended itself
and has set itself up waiting for an external event to wake
it back up again.InterruptedException
- the procedure will be added back to the queue and retried
later.protected boolean setTimeoutFailure(MasterProcedureEnv env)
Procedure
WAITING_TIMEOUT
by calling setState
method, and throw a
ProcedureSuspendedException
to halt the execution of the procedure, and do not forget a
call Procedure.setTimeout(int)
method to set the timeout. And you should also override this
method to wake up the procedure, and also return false to tell the ProcedureExecutor that the
timeout event has been handled.setTimeoutFailure
in class Procedure<MasterProcedureEnv>
protected void rollback(MasterProcedureEnv env) throws IOException, InterruptedException
Procedure
rollback
in class Procedure<MasterProcedureEnv>
env
- the environment passed to the ProcedureExecutorIOException
- temporary failure, the rollback will retry laterInterruptedException
- the procedure will be added back to the queue and retried laterprotected boolean abort(MasterProcedureEnv env)
Procedure
NOTE: abort() is not like Thread.interrupt(). It is just a notification that allows the procedure implementor abort.
abort
in class Procedure<MasterProcedureEnv>
public void remoteCallFailed(MasterProcedureEnv env, ServerName serverName, IOException e)
RemoteProcedureDispatcher.RemoteProcedure
remoteCallFailed
in interface RemoteProcedureDispatcher.RemoteProcedure<MasterProcedureEnv,ServerName>
public void remoteOperationCompleted(MasterProcedureEnv env)
RemoteProcedureDispatcher.RemoteProcedure
reportProcedureDone
method.remoteOperationCompleted
in interface RemoteProcedureDispatcher.RemoteProcedure<MasterProcedureEnv,ServerName>
public void remoteOperationFailed(MasterProcedureEnv env, RemoteProcedureException error)
RemoteProcedureDispatcher.RemoteProcedure
reportProcedureDone
method.remoteOperationFailed
in interface RemoteProcedureDispatcher.RemoteProcedure<MasterProcedureEnv,ServerName>
private void complete(MasterProcedureEnv env, Throwable error)
private void setTimeoutForSuspend(MasterProcedureEnv env, String reason)
protected void serializeStateData(ProcedureStateSerializer serializer) throws IOException
Procedure
serializeStateData
in class Procedure<MasterProcedureEnv>
serializer
- stores the serializable stateIOException
protected void deserializeStateData(ProcedureStateSerializer serializer) throws IOException
Procedure
deserializeStateData
in class Procedure<MasterProcedureEnv>
serializer
- contains the serialized stateIOException
public Optional<RemoteProcedureDispatcher.RemoteOperation> remoteCallBuild(MasterProcedureEnv env, ServerName serverName)
RemoteProcedureDispatcher.RemoteProcedure
remoteCallBuild
in interface RemoteProcedureDispatcher.RemoteProcedure<MasterProcedureEnv,ServerName>
public TableProcedureInterface.TableOperationType getTableOperationType()
TableProcedureInterface
getTableOperationType
in interface TableProcedureInterface
protected boolean waitInitialized(MasterProcedureEnv env)
Procedure
Procedure.doAcquireLock(Object, ProcedureStore)
will be split into two steps, first, it will
call us to determine whether we need to wait for initialization, second, it will call
Procedure.acquireLock(Object)
to actually handle the lock for this procedure.
This is because that when master restarts, we need to restore the lock state for all the
procedures to not break the semantic if Procedure.holdLock(Object)
is true. But the
ProcedureExecutor
will be started before the master finish initialization(as it is part
of the initialization!), so we need to split the code into two steps, and when restore, we just
restore the lock part and ignore the waitInitialized part. Otherwise there will be dead lock.waitInitialized
in class Procedure<MasterProcedureEnv>
public TableName getTableName()
TableProcedureInterface
getTableName
in interface TableProcedureInterface
Copyright © 2007–2020 The Apache Software Foundation. All rights reserved.