Package org.apache.hadoop.hbase.procedure

Class Subprocedure

java.lang.Object

org.apache.hadoop.hbase.procedure.Subprocedure

All Implemented Interfaces:

Callable<Void>

Direct Known Subclasses:

FlushSnapshotSubprocedure, FlushTableSubprocedure, LogRollBackupSubprocedure, Subprocedure.SubprocedureImpl

@Private
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 ProcedureMember, 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	Description
static class	Subprocedure.SubprocedureImpl	Empty Subprocedure for testing.

Field Summary

Fields

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

Constructor Summary

Constructors

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

Method Summary

Modifier and Type	Method	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.
final 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 Details

LOG

private static final org.slf4j.Logger 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 Details

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 Details

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 ProcedureMember 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.

cancel

public void cancel(String msg,
 Throwable cause)

Method to cancel the Subprocedure by injecting an exception from and external source.

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