MasterProcedureScheduler (Apache HBase 1.4.11 API)

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)

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)` Inserts the specified element at the end of this queue.
`void`	`addFront(Procedure proc)` Inserts the specified element at the front of this queue.
`void`	`clear()` Removes all of the elements from this collection.
`void`	`completionCleanup(Procedure proc)` The procedure in execution completed.
`long`	`getNullPollCalls()`
`long`	`getPollCalls()`
`protected boolean`	`markTableAsDeleted(TableName table)` Tries to remove the queue and the table-lock of the specified table.
`Procedure`	`poll()` Fetch one Procedure from the queue
`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()` In case the class is blocking on poll() waiting for items to be added, this method should awake poll() and poll() should return.
`int`	`size()` Returns the number of elements in this collection.
`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)` The procedure can't run at the moment.

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)
```
    Description copied from interface: ProcedureRunnableSet
    
    Inserts the specified element at the front of this queue.
    
    Specified by:
    
    addFront in interface ProcedureRunnableSet
    
    Parameters:
    proc - the Procedure to add
  - addBack
```
public void addBack(Procedure proc)
```
    Description copied from interface: ProcedureRunnableSet
    
    Inserts the specified element at the end of this queue.
    
    Specified by:
    
    addBack in interface ProcedureRunnableSet
    
    Parameters:
    proc - the Procedure to add
  - yield
```
public void yield(Procedure proc)
```
    Description copied from interface: ProcedureRunnableSet
    
    The procedure can't run at the moment. add it back to the queue, giving priority to someone else.
    
    Specified by:
    
    yield in interface ProcedureRunnableSet
    
    Parameters:
    proc - the Procedure to add back to the list
  - poll
```
public Procedure poll()
```
    Description copied from interface: ProcedureRunnableSet
    
    Fetch one Procedure from the queue
    
    Specified by:
    
    poll in interface ProcedureRunnableSet
    
    Returns:
    the Procedure to execute, or null if nothing present.
  - clear
```
public void clear()
```
    Description copied from interface: ProcedureRunnableSet
    
    Removes all of the elements from this collection.
    
    Specified by:
    
    clear in interface ProcedureRunnableSet
  - signalAll
```
public void signalAll()
```
    Description copied from interface: ProcedureRunnableSet
    
    In case the class is blocking on poll() waiting for items to be added, this method should awake poll() and poll() should return.
    
    Specified by:
    
    signalAll in interface ProcedureRunnableSet
  - size
```
public int size()
```
    Description copied from interface: ProcedureRunnableSet
    
    Returns the number of elements in this collection.
    
    Specified by:
    
    size in interface ProcedureRunnableSet
    
    Returns:
    the number of elements in this collection.
  - completionCleanup
```
public void completionCleanup(Procedure proc)
```
    Description copied from interface: ProcedureRunnableSet
    
    The procedure in execution completed. This can be implemented to perform cleanups.
    
    Specified by:
    
    completionCleanup in interface ProcedureRunnableSet
    
    Parameters:
    proc - the Procedure that completed the execution.
  - 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)

Class MasterProcedureScheduler

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

MasterProcedureScheduler

Method Detail

addFront

addBack

yield

poll

clear

signalAll

size

completionCleanup

getPollCalls

getNullPollCalls

waitEvent

waitEvent

suspend

wake

tryAcquireTableExclusiveLock

releaseTableExclusiveLock

tryAcquireTableSharedLock

releaseTableSharedLock

markTableAsDeleted

tryAcquireNamespaceExclusiveLock

releaseNamespaceExclusiveLock

tryAcquireServerExclusiveLock

releaseServerExclusiveLock

tryAcquireServerSharedLock

releaseServerSharedLock