StateMachineProcedure (Apache HBase 1.4.11 API)

java.lang.Object
- org.apache.hadoop.hbase.procedure2.Procedure<TEnvironment>
- - org.apache.hadoop.hbase.procedure2.StateMachineProcedure<TEnvironment,TState>

All Implemented Interfaces:

Comparable<Procedure>

Direct Known Subclasses:

AddColumnFamilyProcedure, CreateNamespaceProcedure, CreateTableProcedure, DeleteColumnFamilyProcedure, DeleteNamespaceProcedure, DeleteTableProcedure, DisableTableProcedure, EnableTableProcedure, ModifyColumnFamilyProcedure, ModifyNamespaceProcedure, ModifyTableProcedure, ServerCrashProcedure, TruncateTableProcedure
```
@InterfaceAudience.Private
@InterfaceStability.Evolving
public abstract class StateMachineProcedure<TEnvironment,TState>
extends Procedure<TEnvironment>
```
Procedure described by a series of steps. The procedure implementor must have an enum of 'states', describing the various step of the procedure. Once the procedure is running, the procedure-framework will call executeFromState() using the 'state' provided by the user. The first call to executeFromState() will be performed with 'state = null'. The implementor can jump between states using setNextState(MyStateEnum.ordinal()). The rollback will call rollbackState() for each state that was executed, in reverse order.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static class StateMachineProcedure.Flow

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`StateMachineProcedure.Flow`

Constructor Summary

Constructors
Constructor and Description

StateMachineProcedure()

Constructors
Constructor and Description
`StateMachineProcedure()`

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`addChildProcedure(Procedure... subProcedure)` Add a child procedure to execute
`protected void`	`deserializeStateData(InputStream stream)` Called on store load to allow the user to decode the previously serialized state.
`protected Procedure[]`	`execute(TEnvironment env)` The main code of the procedure.
`protected abstract StateMachineProcedure.Flow`	`executeFromState(TEnvironment env, TState state)` called to perform a single step of the specified 'state' of the procedure
`protected abstract TState`	`getInitialState()` Return the initial state object that will be used for the first call to executeFromState().
`protected abstract TState`	`getState(int stateId)` Convert an ordinal (or state id) to an Enum (or more descriptive) state object.
`protected abstract int`	`getStateId(TState state)` Convert the Enum (or more descriptive) state object to an ordinal (or state id).
`protected boolean`	`isYieldAfterExecutionStep(TEnvironment env)` By default, the executor will try ro run procedures start to finish.
`protected boolean`	`isYieldBeforeExecuteFromState(TEnvironment env, TState state)` By default, the executor will try ro run all the steps of the procedure start to finish.
`protected void`	`rollback(TEnvironment env)` The code to undo what done by the execute() code.
`protected abstract void`	`rollbackState(TEnvironment env, TState state)` called to perform the rollback of the specified state
`protected void`	`serializeStateData(OutputStream stream)` The user-level code of the procedure may have some state to persist (e.g.
`protected void`	`setNextState(TState state)` Set the next state for the procedure.
`protected void`	`toStringState(StringBuilder builder)` Called from `Procedure.toString()` when interpolating `Procedure` state

Methods inherited from class org.apache.hadoop.hbase.procedure2.Procedure
abort, acquireLock, addStackIndex, beforeReplay, childrenCountDown, compareTo, completionCleanup, convert, convert, createProcedureInfo, doExecute, doRollback, elapsedTime, getException, getLastUpdate, getNonceKey, getOwner, getParentProcId, getProcId, getProcIdHashCode, getResult, getRootProcedureId, getStackIndexes, getStartTime, getState, getTimeout, getTimeRemaining, hasChildren, hasException, hasOwner, hasParent, hasTimeout, incChildrenLatch, isFailed, isFinished, isRunnable, isSuccess, isWaiting, newInstance, releaseLock, removeStackIndex, setAbortFailure, setChildrenLatch, setFailure, setFailure, setNonceKey, setOwner, setParentProcId, setProcId, setResult, setStackIndexes, setStartTime, setState, setTimeout, setTimeoutFailure, shouldWaitClientAck, toString, toStringClass, toStringClassDetails, toStringDetails, toStringSimpleSB, updateTimestamp, validateClass, wasExecuted

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - StateMachineProcedure
```
public StateMachineProcedure()
```
- Method Detail
  - executeFromState
```
protected abstract StateMachineProcedure.Flow executeFromState(TEnvironment env,
                                          TState state)
                                                        throws ProcedureYieldException,
                                                               InterruptedException
```
    called to perform a single step of the specified 'state' of the procedure
    
    Parameters:
    state - state to execute
    
    Returns:
    Flow.NO_MORE_STATE if the procedure is completed, Flow.HAS_MORE_STATE if there is another step.
    
    Throws:
    
    ProcedureYieldException
    
    InterruptedException
  - rollbackState
```
protected abstract void rollbackState(TEnvironment env,
                 TState state)
                               throws IOException,
                                      InterruptedException
```
    called to perform the rollback of the specified state
    
    Parameters:
    state - state to rollback
    
    Throws:
    
    IOException - temporary failure, the rollback will retry later
    
    InterruptedException
  - getState
```
protected abstract TState getState(int stateId)
```
    Convert an ordinal (or state id) to an Enum (or more descriptive) state object.
    
    Parameters:
    stateId - the ordinal() of the state enum (or state id)
    
    Returns:
    the state enum object
  - getStateId
```
protected abstract int getStateId(TState state)
```
    Convert the Enum (or more descriptive) state object to an ordinal (or state id).
    
    Parameters:
    state - the state enum object
    
    Returns:
    stateId the ordinal() of the state enum (or state id)
  - getInitialState
```
protected abstract TState getInitialState()
```
    Return the initial state object that will be used for the first call to executeFromState().
    
    Returns:
    the initial state enum object
  - setNextState
```
protected void setNextState(TState state)
```
    Set the next state for the procedure.
    
    Parameters:
    state - the state enum object
  - isYieldBeforeExecuteFromState
```
protected boolean isYieldBeforeExecuteFromState(TEnvironment env,
                                    TState state)
```
    By default, the executor will try ro run all the steps of the procedure start to finish. Return true to make the executor yield between execution steps to give other procedures time to run their steps.
    
    Parameters:
    state - the state we are going to execute next.
    
    Returns:
    Return true if the executor should yield before the execution of the specified step. Defaults to return false.
  - addChildProcedure
```
protected void addChildProcedure(Procedure... subProcedure)
```
    Add a child procedure to execute
    
    Parameters:
    subProcedure - the child procedure
  - execute
```
protected Procedure[] execute(TEnvironment env)
                       throws ProcedureYieldException,
                              InterruptedException
```
    Description copied from class: Procedure
    
    The main code of the procedure. It must be idempotent since execute() may be called multiple time in case of machine failure in the middle of the execution.
    
    Specified by:
    
    execute in class Procedure<TEnvironment>
    
    Parameters:
    env - the environment passed to the ProcedureExecutor
    
    Returns:
    a set of sub-procedures or null if there is nothing else to execute.
    
    Throws:
    
    ProcedureYieldException - the procedure will be added back to the queue and retried later
    
    InterruptedException - the procedure will be added back to the queue and retried later
  - rollback
```
protected void rollback(TEnvironment env)
                 throws IOException,
                        InterruptedException
```
    Description copied from class: Procedure
    
    The code to undo what done by the execute() code. It is called when the procedure or one of the sub-procedure failed or an abort was requested. It should cleanup all the resources created by the execute() call. The implementation must be idempotent since rollback() may be called multiple time in case of machine failure in the middle of the execution.
    
    Specified by:
    
    rollback in class Procedure<TEnvironment>
    
    Parameters:
    env - the environment passed to the ProcedureExecutor
    
    Throws:
    
    IOException - temporary failure, the rollback will retry later
    
    InterruptedException - the procedure will be added back to the queue and retried later
  - isYieldAfterExecutionStep
```
protected boolean isYieldAfterExecutionStep(TEnvironment env)
```
    Description copied from class: Procedure
    
    By default, the executor will try ro run procedures start to finish. Return true to make the executor yield between each execution step to give other procedures time to run their steps.
    
    Overrides:
    
    isYieldAfterExecutionStep in class Procedure<TEnvironment>
    
    Parameters:
    env - the environment passed to the ProcedureExecutor
    
    Returns:
    Return true if the executor should yield on completion of an execution step. Defaults to return false.
  - toStringState
```
protected void toStringState(StringBuilder builder)
```
    Description copied from class: Procedure
    
    Called from Procedure.toString() when interpolating Procedure state
    
    Overrides:
    
    toStringState in class Procedure<TEnvironment>
    
    Parameters:
    builder - Append current ProcedureProtos.ProcedureState
  - serializeStateData
```
protected void serializeStateData(OutputStream stream)
                           throws IOException
```
    Description copied from class: Procedure
    
    The user-level code of the procedure may have some state to persist (e.g. input arguments) to be able to resume on failure.
    
    Specified by:
    
    serializeStateData in class Procedure<TEnvironment>
    
    Parameters:
    stream - the stream that will contain the user serialized data
    
    Throws:
    
    IOException
  - deserializeStateData
```
protected void deserializeStateData(InputStream stream)
                             throws IOException
```
    Description copied from class: Procedure
    
    Called on store load to allow the user to decode the previously serialized state.
    
    Specified by:
    
    deserializeStateData in class Procedure<TEnvironment>
    
    Parameters:
    stream - the stream that contains the user serialized data
    
    Throws:
    
    IOException

Class StateMachineProcedure<TEnvironment,TState>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class org.apache.hadoop.hbase.procedure2.Procedure

Methods inherited from class java.lang.Object

Constructor Detail

StateMachineProcedure

Method Detail

executeFromState

rollbackState

getState

getStateId

getInitialState

setNextState

isYieldBeforeExecuteFromState

addChildProcedure

execute

rollback

isYieldAfterExecutionStep

toStringState

serializeStateData

deserializeStateData