public abstract class EventHandler
extends java.lang.Object
implements java.lang.Runnable, java.lang.Comparable<java.lang.Runnable>
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.
ExecutorService
Modifier and Type | Field and Description |
---|---|
protected EventType |
eventType |
protected static java.util.concurrent.atomic.AtomicLong |
seqids |
protected Server |
server |
protected int |
waitingTimeForEvents |
Constructor and Description |
---|
EventHandler(Server server,
EventType eventType)
Default base class constructor.
|
Modifier and Type | Method and Description |
---|---|
int |
compareTo(java.lang.Runnable o)
Default prioritized runnable comparator which implements a FIFO ordering.
|
EventType |
getEventType()
Return the event type
|
java.lang.String |
getInformativeName()
Event implementations should override thie class to provide an
informative name about what event they are handling.
|
int |
getPriority()
Get the priority level for this handler instance.
|
long |
getSeqid() |
protected void |
handleException(java.lang.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() |
java.lang.String |
toString() |
protected EventType eventType
protected Server server
protected static final java.util.concurrent.atomic.AtomicLong seqids
protected int waitingTimeForEvents
public EventHandler prepare() throws java.lang.Exception
java.lang.Exception
- when something goes wrongpublic void run()
run
in interface java.lang.Runnable
public abstract void process() throws java.io.IOException
java.io.IOException
public EventType getEventType()
public int getPriority()
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.
public long getSeqid()
public int compareTo(java.lang.Runnable o)
Subclasses should not override this. Instead, if they want to implement
priority beyond FIFO, they should override getPriority()
.
compareTo
in interface java.lang.Comparable<java.lang.Runnable>
public java.lang.String toString()
toString
in class java.lang.Object
public java.lang.String getInformativeName()
protected void handleException(java.lang.Throwable t)
t
- Throwable object