org.apache.hadoop.hbase.master.locking

Class LockProcedure

java.lang.Object

<any>

org.apache.hadoop.hbase.master.locking.LockProcedure

All Implemented Interfaces:

TableProcedureInterface

public final class LockProcedure
extends <any>
implements TableProcedureInterface

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. on table/namespace/regions. This procedure when scheduled, acquires specified locks, suspends itself and waits for:

• Call to unlock: if lock request came from the process itself, say master chore.
• Timeout : if lock request came from RPC. On timeout, evaluates if it should continue holding the lock or not based on last heartbeat timestamp.

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.hadoop.hbase.master.procedure.TableProcedureInterface

TableProcedureInterface.TableOperationType

Field Summary

Fields

Modifier and Type	Field and Description
static int	DEFAULT_LOCAL_MASTER_LOCKS_TIMEOUT_MS
static int	DEFAULT_REMOTE_LOCKS_TIMEOUT_MS
static java.lang.String	LOCAL_MASTER_LOCKS_TIMEOUT_MS_CONF
static java.lang.String	REMOTE_LOCKS_TIMEOUT_MS_CONF

Constructor Summary

Constructors

Constructor and Description
LockProcedure()
LockProcedure(Configuration conf, RegionInfo[] regionInfos, LockType type, java.lang.String description, java.util.concurrent.CountDownLatch lockAcquireLatch) Constructor for region lock(s).
LockProcedure(Configuration conf, java.lang.String namespace, LockType type, java.lang.String description, java.util.concurrent.CountDownLatch lockAcquireLatch) Constructor for namespace lock.
LockProcedure(Configuration conf, TableName tableName, LockType type, java.lang.String description, java.util.concurrent.CountDownLatch lockAcquireLatch) Constructor for table lock.

Method Summary

Modifier and Type	Method and Description
protected boolean	abort(MasterProcedureEnv env)
protected LockState	acquireLock(MasterProcedureEnv env)
protected void	beforeReplay(MasterProcedureEnv env) On recovery, re-execute from start to acquire the locks.
protected void	deserializeStateData(ProcedureStateSerializer serializer)
protected <any>[]	execute(MasterProcedureEnv env)
java.lang.String	getDescription()
TableName	getTableName()
TableProcedureInterface.TableOperationType	getTableOperationType() Given an operation type we can take decisions about what to do with pending operations.
LockType	getType()
boolean	hasLock(MasterProcedureEnv env)
boolean	holdLock(MasterProcedureEnv env)
boolean	isLocked()
protected void	releaseLock(MasterProcedureEnv env)
protected void	rollback(MasterProcedureEnv env)
protected void	serializeStateData(ProcedureStateSerializer serializer)
protected boolean	setTimeoutFailure(MasterProcedureEnv env) Re run the procedure after every timeout to write new WAL entries so we don't hold back old WALs.
protected void	toStringClassDetails(java.lang.StringBuilder builder)
void	unlock(MasterProcedureEnv env)
void	updateHeartBeat() Updates timeout deadline for the lock.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

DEFAULT_REMOTE_LOCKS_TIMEOUT_MS

public static final int DEFAULT_REMOTE_LOCKS_TIMEOUT_MS

See Also:

Constant Field Values

REMOTE_LOCKS_TIMEOUT_MS_CONF

public static final java.lang.String REMOTE_LOCKS_TIMEOUT_MS_CONF

See Also:

Constant Field Values

DEFAULT_LOCAL_MASTER_LOCKS_TIMEOUT_MS

public static final int DEFAULT_LOCAL_MASTER_LOCKS_TIMEOUT_MS

See Also:

Constant Field Values

LOCAL_MASTER_LOCKS_TIMEOUT_MS_CONF

public static final java.lang.String LOCAL_MASTER_LOCKS_TIMEOUT_MS_CONF

See Also:

Constant Field Values

Constructor Detail

LockProcedure

public LockProcedure()

LockProcedure

public LockProcedure(Configuration conf,
                     java.lang.String namespace,
                     LockType type,
                     java.lang.String description,
                     java.util.concurrent.CountDownLatch lockAcquireLatch)
              throws java.lang.IllegalArgumentException

Constructor for namespace lock.

Parameters:

lockAcquireLatch - if not null, the latch is decreased when lock is acquired.

Throws:

java.lang.IllegalArgumentException

LockProcedure

public LockProcedure(Configuration conf,
                     TableName tableName,
                     LockType type,
                     java.lang.String description,
                     java.util.concurrent.CountDownLatch lockAcquireLatch)
              throws java.lang.IllegalArgumentException

Constructor for table lock.

Parameters:

lockAcquireLatch - if not null, the latch is decreased when lock is acquired.

Throws:

java.lang.IllegalArgumentException

LockProcedure

public LockProcedure(Configuration conf,
                     RegionInfo[] regionInfos,
                     LockType type,
                     java.lang.String description,
                     java.util.concurrent.CountDownLatch lockAcquireLatch)
              throws java.lang.IllegalArgumentException

Constructor for region lock(s).

Parameters:

lockAcquireLatch - if not null, the latch is decreased when lock is acquired. Useful for locks acquired locally from master process.

Throws:

java.lang.IllegalArgumentException - if all regions are not from same table.

Method Detail

getTableName

public TableName getTableName()

Specified by:

getTableName in interface TableProcedureInterface

Returns:

the name of the table the procedure is operating on

getTableOperationType

public TableProcedureInterface.TableOperationType getTableOperationType()

Description copied from interface: TableProcedureInterface

Given an operation type we can take decisions about what to do with pending operations. e.g. if we get a delete and we have some table operation pending (e.g. add column) we can abort those operations.

Specified by:

getTableOperationType in interface TableProcedureInterface

Returns:

the operation type that the procedure is executing.

updateHeartBeat

public void updateHeartBeat()

Updates timeout deadline for the lock.

setTimeoutFailure

protected boolean setTimeoutFailure(MasterProcedureEnv env)

Re run the procedure after every timeout to write new WAL entries so we don't hold back old WALs.

Returns:

false, so procedure framework doesn't mark this procedure as failure.

unlock

public void unlock(MasterProcedureEnv env)

execute

protected <any>[] execute(MasterProcedureEnv env)
                   throws ProcedureSuspendedException

Throws:

ProcedureSuspendedException

rollback

protected void rollback(MasterProcedureEnv env)

abort

protected boolean abort(MasterProcedureEnv env)

serializeStateData

protected void serializeStateData(ProcedureStateSerializer serializer)
                           throws java.io.IOException

Throws:

java.io.IOException

deserializeStateData

protected void deserializeStateData(ProcedureStateSerializer serializer)
                             throws java.io.IOException

Throws:

java.io.IOException

acquireLock

protected LockState acquireLock(MasterProcedureEnv env)

releaseLock

protected void releaseLock(MasterProcedureEnv env)

beforeReplay

protected void beforeReplay(MasterProcedureEnv env)

On recovery, re-execute from start to acquire the locks. Need to explicitly set it to RUNNABLE because the procedure might have been in WAITING_TIMEOUT state when crash happened. In which case, it'll be sent back to timeout queue on recovery, which we don't want since we want to require locks.

toStringClassDetails

protected void toStringClassDetails(java.lang.StringBuilder builder)

getType

public LockType getType()

getDescription

public java.lang.String getDescription()

isLocked

public boolean isLocked()

holdLock

public boolean holdLock(MasterProcedureEnv env)

hasLock

public boolean hasLock(MasterProcedureEnv env)