org.apache.hadoop.hbase.executor

Class EventHandler

java.lang.Object

org.apache.hadoop.hbase.executor.EventHandler

All Implemented Interfaces:

Comparable<EventHandler>, Runnable

Direct Known Subclasses:

AssignRegionHandler, CloseRegionHandler, CompactedHFilesDischargeHandler, OpenRegionHandler, ParallelSeekHandler, RegionReplicaFlushHandler, RSProcedureHandler, TakeSnapshotHandler, UnassignRegionHandler, WALSplitterHandler

@InterfaceAudience.Private
public abstract class EventHandler
extends Object
implements Runnable, Comparable<EventHandler>

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.

See Also:

ExecutorService

Field Summary

Fields

Modifier and Type	Field and Description
protected EventType	eventType
private static org.slf4j.Logger	LOG
private io.opentelemetry.api.trace.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.

Method Summary

Modifier and Type	Method and Description
int	compareTo(EventHandler 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.
int	getPriority() Get the priority level for this handler instance.
long	getSeqid() Returns This events' sequence id.
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()
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.slf4j.Logger LOG

eventType

protected EventType eventType

server

protected Server server

seqids

protected static final AtomicLong seqids

seqid

private final long seqid

waitingTimeForEvents

protected int waitingTimeForEvents

parent

private final io.opentelemetry.api.trace.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. n

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(EventHandler 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<EventHandler>

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