Subprocedure (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.hbase.procedure.Subprocedure

All Implemented Interfaces:

Callable<Void>

Direct Known Subclasses:

FlushSnapshotSubprocedure, FlushTableSubprocedure, Subprocedure.SubprocedureImpl
```
public abstract class Subprocedure
extends Object
implements Callable<Void>
```
Distributed procedure member's Subprocedure. A procedure is sarted on a ProcedureCoordinator which communicates with ProcedureMembers who create and start its part of the Procedure. This sub part is called a Subprocedure Users should subclass this and implement acquireBarrier() (get local barrier for this member), insideBarrier() (execute while globally barriered and release barrier) and cleanup(Exception) (release state associated with subprocedure.) When submitted to a ProcedureMemeber, the call method is executed in a separate thread. Latches are use too block its progress and trigger continuations when barrier conditions are met. Exception that makes it out of calls to acquireBarrier() or insideBarrier() gets converted into ForeignException, which will get propagated to the ProcedureCoordinator. There is a category of procedure (ex: online-snapshots), and a user-specified instance-specific barrierName. (ex: snapshot121126).

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Subprocedure.SubprocedureImpl
Empty Subprocedure for testing.

Nested Classes
Modifier and Type	Class and Description
`static class`	`Subprocedure.SubprocedureImpl` Empty Subprocedure for testing.

Field Summary

Fields
Modifier and Type	Field and Description
`private String`	`barrierName`
`private boolean`	`complete`
`protected TimeoutExceptionInjector`	`executionTimeoutTimer`
`private CountDownLatch`	`inGlobalBarrier` wait on before allowing the in barrier phase to proceed
`private static org.apache.commons.logging.Log`	`LOG`
`protected ForeignExceptionDispatcher`	`monitor` monitor to check for errors
`private CountDownLatch`	`releasedLocalBarrier` counted down when the Subprocedure has completed
`protected ProcedureMemberRpcs`	`rpcs`
`protected long`	`wakeFrequency` frequency to check for errors (ms)

Constructor Summary

Constructors
Constructor and Description
`Subprocedure(ProcedureMember member, String procName, ForeignExceptionDispatcher monitor, long wakeFrequency, long timeout)`

Method Summary

Methods
Modifier and Type	Method and Description
`abstract void`	`acquireBarrier()` The implementation of this method should gather and hold required resources (locks, disk space, etc) to satisfy the Procedures barrier condition.
`Void`	`call()` Execute the Subprocedure `acquireBarrier()` and `insideBarrier()` methods while keeping some state for other threads to access.
`void`	`cancel(String msg, Throwable cause)` Method to cancel the Subprocedure by injecting an exception from and external source.
`abstract void`	`cleanup(Exception e)` Users should override this method.
`(package private) ForeignExceptionSnare`	`getErrorCheckable()` exposed for testing.
`String`	`getMemberName()`
`String`	`getName()`
`abstract byte[]`	`insideBarrier()` The implementation of this method should act with the assumption that the barrier condition has been satisfied.
`(package private) boolean`	`isComplete()`
`void`	`receiveReachedGlobalBarrier()` Callback for the member rpcs to call when the global barrier has been reached.
`private void`	`rethrowException()`
`void`	`waitForLocallyCompleted()` Waits until the entire procedure has globally completed, or has been aborted.
`(package private) void`	`waitForReachedGlobalBarrier()` Wait for the reached global barrier notification.

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

- Field Detail
  - LOG
```
private static final org.apache.commons.logging.Log LOG
```
  - barrierName
```
private final String barrierName
```
  - inGlobalBarrier
```
private final CountDownLatch inGlobalBarrier
```
    wait on before allowing the in barrier phase to proceed
  - releasedLocalBarrier
```
private final CountDownLatch releasedLocalBarrier
```
    counted down when the Subprocedure has completed
  - monitor
```
protected final ForeignExceptionDispatcher monitor
```
    monitor to check for errors
  - wakeFrequency
```
protected final long wakeFrequency
```
    frequency to check for errors (ms)
  - executionTimeoutTimer
```
protected final TimeoutExceptionInjector executionTimeoutTimer
```
  - rpcs
```
protected final ProcedureMemberRpcs rpcs
```
  - complete
```
private volatile boolean complete
```
- Constructor Detail
  - Subprocedure
```
public Subprocedure(ProcedureMember member,
            String procName,
            ForeignExceptionDispatcher monitor,
            long wakeFrequency,
            long timeout)
```
    Parameters:
    member - reference to the member managing this subprocedure
    procName - name of the procedure this subprocedure is associated with
    monitor - notified if there is an error in the subprocedure
    wakeFrequency - time in millis to wake to check if there is an error via the monitor (in milliseconds).
    timeout - time in millis that will trigger a subprocedure abort if it has not completed
- Method Detail
  - getName
```
public String getName()
```
  - getMemberName
```
public String getMemberName()
```
  - rethrowException
```
private void rethrowException()
                       throws ForeignException
```
    Throws:
    
    ForeignException
  - call
```
public final Void call()
```
    Execute the Subprocedure acquireBarrier() and insideBarrier() methods while keeping some state for other threads to access. This would normally be executed by the ProcedureMemeber when a acquire message comes from the coordinator. Rpcs are used to spend message back to the coordinator after different phases are executed. Any exceptions caught during the execution (except for InterruptedException) get converted and propagated to coordinator via ProcedureMemberRpcs.sendMemberAborted( Subprocedure, ForeignException).
    
    Specified by:
    
    call in interface Callable<Void>
  - isComplete
```
boolean isComplete()
```
  - getErrorCheckable
```
ForeignExceptionSnare getErrorCheckable()
```
    exposed for testing.
  - acquireBarrier
```
public abstract void acquireBarrier()
                             throws ForeignException
```
    The implementation of this method should gather and hold required resources (locks, disk space, etc) to satisfy the Procedures barrier condition. For example, this would be where to make all the regions on a RS on the quiescent for an procedure that required all regions to be globally quiesed. Users should override this method. If a quiescent is not required, this is overkill but can still be used to execute a procedure on all members and to propagate any exceptions.
    
    Throws:
    
    ForeignException
  - insideBarrier
```
public abstract byte[] insideBarrier()
                              throws ForeignException
```
    The implementation of this method should act with the assumption that the barrier condition has been satisfied. Continuing the previous example, a condition could be that all RS's globally have been quiesced, and procedures that require this precondition could be implemented here. The implementation should also collect the result of the subprocedure as data to be returned to the coordinator upon successful completion. Users should override this method.
    
    Returns:
    the data the subprocedure wants to return to coordinator side.
    
    Throws:
    
    ForeignException
  - cleanup
```
public abstract void cleanup(Exception e)
```
    Users should override this method. This implementation of this method should rollback and cleanup any temporary or partially completed state that the acquireBarrier() may have created.
    
    Parameters:
    e -
  - cancel
```
public void cancel(String msg,
          Throwable cause)
```
    Method to cancel the Subprocedure by injecting an exception from and external source.
    
    Parameters:
    cause -
  - receiveReachedGlobalBarrier
```
public void receiveReachedGlobalBarrier()
```
    Callback for the member rpcs to call when the global barrier has been reached. This unblocks the main subprocedure exectuion thread so that the Subprocedure's insideBarrier() method can be run.
  - waitForReachedGlobalBarrier
```
void waitForReachedGlobalBarrier()
                           throws ForeignException,
                                  InterruptedException
```
    Wait for the reached global barrier notification. Package visibility for testing
    
    Throws:
    
    ForeignException
    
    InterruptedException
  - waitForLocallyCompleted
```
public void waitForLocallyCompleted()
                             throws ForeignException,
                                    InterruptedException
```
    Waits until the entire procedure has globally completed, or has been aborted.
    
    Throws:
    
    ForeignException
    
    InterruptedException

Class Subprocedure

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

barrierName

inGlobalBarrier

releasedLocalBarrier

monitor

wakeFrequency

executionTimeoutTimer

rpcs

complete

Constructor Detail

Subprocedure

Method Detail

getName

getMemberName

rethrowException

call

isComplete

getErrorCheckable

acquireBarrier

insideBarrier

cleanup

cancel

receiveReachedGlobalBarrier

waitForReachedGlobalBarrier

waitForLocallyCompleted