EventHandler (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.hbase.executor.EventHandler

All Implemented Interfaces:

Comparable<Runnable>, Runnable

Direct Known Subclasses:

ClosedRegionHandler, CloseRegionHandler, CreateTableHandler, DisableTableHandler, DispatchMergingRegionHandler, EnableTableHandler, FinishRegionRecoveringHandler, OpenedRegionHandler, OpenRegionHandler, ParallelSeekHandler, RegionReplicaFlushHandler, TableEventHandler, TakeSnapshotHandler, WALSplitterHandler
```
@InterfaceAudience.Private
public abstract class EventHandler
extends Object
implements Runnable, Comparable<Runnable>
```
Abstract base class for all HBase event handlers. Subclasses should implement the process() and prepare() methods. Subclasses should also do all necessary checks up in their prepare() if possible -- check table exists, is disabled, etc. -- so they fail fast rather than later when process is running. Do it this way because process be invoked directly but event handlers are also run in an executor context -- i.e. asynchronously -- and in this case, exceptions thrown at process time will not be seen by the invoker, not till we implement a call-back mechanism so the client can pick them up later.
Event handlers have an EventType. EventType is a list of ALL handler event types. We need to keep a full list in one place -- and as enums is a good shorthand for an implemenations -- because event handlers can be passed to executors when they are to be run asynchronously. The hbase executor, see ExecutorService, has a switch for passing event type to executor.
Event listeners can be installed and will be called pre- and post- process if this EventHandler is run in a Thread (its a Runnable so if its run() method gets called). Implement EventHandler.EventHandlerListeners, and registering using setListener(EventHandlerListener).

See Also:
ExecutorService

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface EventHandler.EventHandlerListener
This interface provides pre- and post-process hooks for events.

Nested Classes
Modifier and Type	Class and Description
`static interface`	`EventHandler.EventHandlerListener` This interface provides pre- and post-process hooks for events.

Field Summary

Fields
Modifier and Type	Field and Description
`protected EventType`	`eventType`
`private EventHandler.EventHandlerListener`	`listener`
`private static org.apache.commons.logging.Log`	`LOG`
`private org.apache.htrace.Span`	`parent`
`private long`	`seqid`
`protected static AtomicLong`	`seqids`
`protected Server`	`server`
`protected int`	`waitingTimeForEvents`

Constructor Summary

Constructors
Constructor and Description

EventHandler(Server server, EventType eventType)
Default base class constructor.

Constructors
Constructor and Description
`EventHandler(Server server, EventType eventType)` Default base class constructor.

Method Summary

Methods
Modifier and Type	Method and Description
`int`	`compareTo(Runnable o)` Default prioritized runnable comparator which implements a FIFO ordering.
`EventType`	`getEventType()` Return the event type
`String`	`getInformativeName()` Event implementations should override thie class to provide an informative name about what event they are handling.
`EventHandler.EventHandlerListener`	`getListener()`
`int`	`getPriority()` Get the priority level for this handler instance.
`long`	`getSeqid()`
`protected void`	`handleException(Throwable t)` Event exception handler, may be overridden
`EventHandler`	`prepare()` Event handlers should do all the necessary checks in this method (rather than in the constructor, or in process()) so that the caller, which is mostly executed in the ipc context can fail fast.
`abstract void`	`process()` This method is the main processing loop to be implemented by the various subclasses.
`void`	`run()`
`void`	`setListener(EventHandler.EventHandlerListener listener)`
`String`	`toString()`

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

- Field Detail
  - LOG
```
private static final org.apache.commons.logging.Log LOG
```
  - eventType
```
protected EventType eventType
```
  - server
```
protected Server server
```
  - seqids
```
protected static final AtomicLong seqids
```
  - seqid
```
private final long seqid
```
  - listener
```
private EventHandler.EventHandlerListener listener
```
  - waitingTimeForEvents
```
protected int waitingTimeForEvents
```
  - parent
```
private final org.apache.htrace.Span parent
```
- Constructor Detail
  - EventHandler
```
public EventHandler(Server server,
            EventType eventType)
```
    Default base class constructor.
- Method Detail
  - prepare
```
public EventHandler prepare()
                     throws Exception
```
    Event handlers should do all the necessary checks in this method (rather than in the constructor, or in process()) so that the caller, which is mostly executed in the ipc context can fail fast. Process is executed async from the client ipc, so this method gives a quick chance to do some basic checks. Should be called after constructing the EventHandler, and before process().
    
    Returns:
    the instance of this class
    
    Throws:
    
    Exception - when something goes wrong
  - run
```
public void run()
```
    Specified by:
    
    run in interface Runnable
  - process
```
public abstract void process()
                      throws IOException
```
    This method is the main processing loop to be implemented by the various subclasses.
    
    Throws:
    
    IOException
  - getEventType
```
public EventType getEventType()
```
    Return the event type
    
    Returns:
    The event type.
  - getPriority
```
public int getPriority()
```
    Get the priority level for this handler instance. This uses natural ordering so lower numbers are higher priority.
    Lowest priority is Integer.MAX_VALUE. Highest priority is 0.
    Subclasses should override this method to allow prioritizing handlers.
    Handlers with the same priority are handled in FIFO order.
    
    Returns:
    Integer.MAX_VALUE by default, override to set higher priorities
  - getSeqid
```
public long getSeqid()
```
    Returns:
    This events' sequence id.
  - compareTo
```
public int compareTo(Runnable o)
```
    Default prioritized runnable comparator which implements a FIFO ordering.
    Subclasses should not override this. Instead, if they want to implement priority beyond FIFO, they should override getPriority().
    
    Specified by:
    
    compareTo in interface Comparable<Runnable>
  - getListener
```
public EventHandler.EventHandlerListener getListener()
```
    Returns:
    Current listener or null if none set.
  - setListener
```
public void setListener(EventHandler.EventHandlerListener listener)
```
    Parameters:
    listener - Listener to call pre- and post- process().
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getInformativeName
```
public String getInformativeName()
```
    Event implementations should override thie class to provide an informative name about what event they are handling. For example, event-specific information such as which region or server is being processed should be included if possible.
  - handleException
```
protected void handleException(Throwable t)
```
    Event exception handler, may be overridden
    
    Parameters:
    t - Throwable object

Class EventHandler

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

eventType

server

seqids

seqid

listener

waitingTimeForEvents

parent

Constructor Detail

EventHandler

Method Detail

prepare

run

process

getEventType

getPriority

getSeqid

compareTo

getListener

setListener

toString

getInformativeName

handleException