org.apache.hadoop.hbase.master.procedure

Class MasterProcedureScheduler

java.lang.Object

org.apache.hadoop.hbase.master.procedure.MasterProcedureScheduler

All Implemented Interfaces:

ProcedureRunnableSet

@InterfaceAudience.Private
@InterfaceStability.Evolving
public class MasterProcedureScheduler
extends Object
implements ProcedureRunnableSet

ProcedureRunnableSet for the Master Procedures. This RunnableSet tries to provide to the ProcedureExecutor procedures that can be executed without having to wait on a lock. Most of the master operations can be executed concurrently, if they are operating on different tables (e.g. two create table can be performed at the same, time assuming table A and table B) or against two different servers; say two servers that crashed at about the same time.

Each procedure should implement an interface providing information for this queue. for example table related procedures should implement TableProcedureInterface. each procedure will be pushed in its own queue, and based on the operation type we may take smarter decision. e.g. we can abort all the operations preceding a delete table, or similar.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	MasterProcedureScheduler.ProcedureEvent
static class	MasterProcedureScheduler.ServerQueue
static class	MasterProcedureScheduler.TableQueue

Constructor Summary

Constructors

Constructor and Description
MasterProcedureScheduler(org.apache.hadoop.conf.Configuration conf, TableLockManager lockManager)

Method Summary

Methods

Modifier and Type	Method and Description
void	addBack(Procedure proc)
void	addFront(Procedure proc)
void	clear()
void	completionCleanup(Procedure proc)
long	getNullPollCalls()
long	getPollCalls()
protected boolean	markTableAsDeleted(TableName table) Tries to remove the queue and the table-lock of the specified table.
Procedure	poll()
void	releaseNamespaceExclusiveLock(Procedure procedure, String nsName) Release the exclusive lock
void	releaseServerExclusiveLock(Procedure procedure, ServerName serverName) Release the exclusive lock
void	releaseServerSharedLock(Procedure procedure, ServerName serverName) Release the shared lock taken
void	releaseTableExclusiveLock(Procedure procedure, TableName table) Release the exclusive lock taken with tryAcquireTableWrite()
void	releaseTableSharedLock(Procedure procedure, TableName table) Release the shared lock taken with tryAcquireTableRead()
void	signalAll()
int	size()
void	suspend(MasterProcedureScheduler.ProcedureEvent event)
boolean	tryAcquireNamespaceExclusiveLock(Procedure procedure, String nsName) Try to acquire the exclusive lock on the specified namespace.
boolean	tryAcquireServerExclusiveLock(Procedure procedure, ServerName serverName) Try to acquire the exclusive lock on the specified server.
boolean	tryAcquireServerSharedLock(Procedure procedure, ServerName serverName) Try to acquire the shared lock on the specified server.
boolean	tryAcquireTableExclusiveLock(Procedure procedure, TableName table) Try to acquire the exclusive lock on the specified table.
boolean	tryAcquireTableSharedLock(Procedure procedure, TableName table) Try to acquire the shared lock on the specified table.
boolean	waitEvent(MasterProcedureScheduler.ProcedureEvent event, Procedure procedure)
boolean	waitEvent(MasterProcedureScheduler.ProcedureEvent event, Procedure procedure, boolean suspendQueue)
void	wake(MasterProcedureScheduler.ProcedureEvent event)
void	yield(Procedure proc)

Methods inherited from class java.lang.Object

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

Constructor Detail

MasterProcedureScheduler

public MasterProcedureScheduler(org.apache.hadoop.conf.Configuration conf,
                        TableLockManager lockManager)

Method Detail

addFront

public void addFront(Procedure proc)

Specified by:

addFront in interface ProcedureRunnableSet

addBack

public void addBack(Procedure proc)

Specified by:

addBack in interface ProcedureRunnableSet

yield

public void yield(Procedure proc)

Specified by:

yield in interface ProcedureRunnableSet

poll

public Procedure poll()

Specified by:

poll in interface ProcedureRunnableSet

clear

public void clear()

Specified by:

clear in interface ProcedureRunnableSet

signalAll

public void signalAll()

Specified by:

signalAll in interface ProcedureRunnableSet

size

public int size()

Specified by:

size in interface ProcedureRunnableSet

completionCleanup

public void completionCleanup(Procedure proc)

Specified by:

completionCleanup in interface ProcedureRunnableSet

getPollCalls

public long getPollCalls()

getNullPollCalls

public long getNullPollCalls()

waitEvent

public boolean waitEvent(MasterProcedureScheduler.ProcedureEvent event,
                Procedure procedure)

waitEvent

public boolean waitEvent(MasterProcedureScheduler.ProcedureEvent event,
                Procedure procedure,
                boolean suspendQueue)

suspend

public void suspend(MasterProcedureScheduler.ProcedureEvent event)

wake

public void wake(MasterProcedureScheduler.ProcedureEvent event)

tryAcquireTableExclusiveLock

public boolean tryAcquireTableExclusiveLock(Procedure procedure,
                                   TableName table)

Try to acquire the exclusive lock on the specified table. other operations in the table-queue will be executed after the lock is released.

Parameters:

procedure - the procedure trying to acquire the lock

table - Table to lock

Returns:

true if we were able to acquire the lock on the table, otherwise false.

releaseTableExclusiveLock

public void releaseTableExclusiveLock(Procedure procedure,
                             TableName table)

Release the exclusive lock taken with tryAcquireTableWrite()

Parameters:

procedure - the procedure releasing the lock

table - the name of the table that has the exclusive lock

tryAcquireTableSharedLock

public boolean tryAcquireTableSharedLock(Procedure procedure,
                                TableName table)

Try to acquire the shared lock on the specified table. other "read" operations in the table-queue may be executed concurrently,

Parameters:

procedure - the procedure trying to acquire the lock

table - Table to lock

Returns:

true if we were able to acquire the lock on the table, otherwise false.

releaseTableSharedLock

public void releaseTableSharedLock(Procedure procedure,
                          TableName table)

Release the shared lock taken with tryAcquireTableRead()

Parameters:

procedure - the procedure releasing the lock

table - the name of the table that has the shared lock

markTableAsDeleted

protected boolean markTableAsDeleted(TableName table)

Tries to remove the queue and the table-lock of the specified table. If there are new operations pending (e.g. a new create), the remove will not be performed.

Parameters:

table - the name of the table that should be marked as deleted

Returns:

true if deletion succeeded, false otherwise meaning that there are other new operations pending for that table (e.g. a new create).

tryAcquireNamespaceExclusiveLock

public boolean tryAcquireNamespaceExclusiveLock(Procedure procedure,
                                       String nsName)

Try to acquire the exclusive lock on the specified namespace.

Parameters:

procedure - the procedure trying to acquire the lock

nsName - Namespace to lock

Returns:

true if we were able to acquire the lock on the namespace, otherwise false.

See Also:

releaseNamespaceExclusiveLock(Procedure,String)

releaseNamespaceExclusiveLock

public void releaseNamespaceExclusiveLock(Procedure procedure,
                                 String nsName)

Release the exclusive lock

Parameters:

procedure - the procedure releasing the lock

nsName - the namespace that has the exclusive lock

See Also:

tryAcquireNamespaceExclusiveLock(Procedure,String)

tryAcquireServerExclusiveLock

public boolean tryAcquireServerExclusiveLock(Procedure procedure,
                                    ServerName serverName)

Try to acquire the exclusive lock on the specified server.

Parameters:

procedure - the procedure trying to acquire the lock

serverName - Server to lock

Returns:

true if we were able to acquire the lock on the server, otherwise false.

See Also:

releaseServerExclusiveLock(Procedure,ServerName)

releaseServerExclusiveLock

public void releaseServerExclusiveLock(Procedure procedure,
                              ServerName serverName)

Release the exclusive lock

Parameters:

procedure - the procedure releasing the lock

serverName - the server that has the exclusive lock

See Also:

tryAcquireServerExclusiveLock(Procedure,ServerName)

tryAcquireServerSharedLock

public boolean tryAcquireServerSharedLock(Procedure procedure,
                                 ServerName serverName)

Try to acquire the shared lock on the specified server.

Parameters:

procedure - the procedure releasing the lock

serverName - Server to lock

Returns:

true if we were able to acquire the lock on the server, otherwise false.

See Also:

releaseServerSharedLock(Procedure,ServerName)

releaseServerSharedLock

public void releaseServerSharedLock(Procedure procedure,
                           ServerName serverName)

Release the shared lock taken

Parameters:

procedure - the procedure releasing the lock

serverName - the server that has the shared lock

See Also:

tryAcquireServerSharedLock(Procedure,ServerName)