org.apache.river.outrigger

Class TakeIfExistsWatcher

java.lang.Object

org.apache.river.outrigger.TransitionWatcher

org.apache.river.outrigger.QueryWatcher

org.apache.river.outrigger.SingletonQueryWatcher

org.apache.river.outrigger.TakeIfExistsWatcher

All Implemented Interfaces:

Comparable<TransitionWatcher>, TransactionConstants, IfExistsWatcher, Transactable

class TakeIfExistsWatcher
extends SingletonQueryWatcher
implements IfExistsWatcher, Transactable

Subclass of QueryWatcher for takeIfExists queries. Resolves with the first matching transition where the entry is visible to the associated transaction and the entry is still available, or of the locked entry set goes empty.

Field Summary

Fields

Modifier and Type	Field and Description
private boolean	backlogFinished Set true once the query thread is done processing the backlog.
private Set<Uuid>	lockedEntries The set of entries that would match but are currently unavailable (e.g. they are locked).
private Set<EntryHandle>	provisionallyRemovedEntrySet Set of entries (represented by EntryHolders) that we would have liked to return, but have been provisionally removed.
private Txn	txn If non-null the transaction this query is being performed under.

Fields inherited from class org.apache.river.outrigger.TransitionWatcher

startOrdinal

Fields inherited from interface net.jini.core.transaction.server.TransactionConstants

ABORTED, ACTIVE, COMMITTED, NOTCHANGED, PREPARED, VOTING

Constructor Summary

Constructors

Constructor and Description
TakeIfExistsWatcher(long expiration, long timestamp, long startOrdinal, Set<Uuid> lockedEntries, Set<EntryHandle> provisionallyRemovedEntrySet, Txn txn) Create a new TakeIfExistsWatcher.

Method Summary

Modifier and Type	Method and Description
void	abort(TransactableMgr mgr, OutriggerServerImpl space) If a transaction ends in the middle of a query we want to throw an exception to the client making the query (not the Txn calling us here.)
(package private) boolean	catchUp(EntryTransition transition, long now) Process a transition which was posted before the watcher was placed in TransitionWatchers object.
void	caughtUp() Once the backlog is complete we can resolve if lockedEntries is/becomes empty.
void	commit(TransactableMgr mgr, OutriggerServerImpl space) This should never happen since we always return NOTCHANGED from prepare.
(package private) boolean	isInterested(EntryTransition transition, long ordinal) Return true if this watcher cares about a given visibility transition.
boolean	isLockedEntrySetEmpty() If the query has been resolved by the locked entry set becoming empty returns true, otherwise return false.
int	prepare(TransactableMgr mgr, OutriggerServerImpl space) If a transaction ends in the middle of a query we want to throw an exception to the client making the query not the Txn calling us here.)
(package private) void	process(EntryTransition transition, long now) Process the given transition.

Methods inherited from class org.apache.river.outrigger.SingletonQueryWatcher

addTemplateHandle, getServer, isResolved, resolve, resolvedWithEntry, resolvedWithThrowable, waitOnResolution

Methods inherited from class org.apache.river.outrigger.QueryWatcher

getExpiration, removeIfExpired

Methods inherited from class org.apache.river.outrigger.TransitionWatcher

compareTo

Methods inherited from class java.lang.Object

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

Field Detail

lockedEntries

private final Set<Uuid> lockedEntries

The set of entries that would match but are currently unavailable (e.g. they are locked). We only keep the ids, not the entries themselves.

backlogFinished

private boolean backlogFinished

Set true once the query thread is done processing the backlog. Once this is true it is ok to resolve if lockedEntries is empty.

txn

private final Txn txn

If non-null the transaction this query is being performed under. If null this query is not associated with a transaction.

provisionallyRemovedEntrySet

private final Set<EntryHandle> provisionallyRemovedEntrySet

Set of entries (represented by EntryHolders) that we would have liked to return, but have been provisionally removed.

Constructor Detail

TakeIfExistsWatcher

TakeIfExistsWatcher(long expiration,
                    long timestamp,
                    long startOrdinal,
                    Set<Uuid> lockedEntries,
                    Set<EntryHandle> provisionallyRemovedEntrySet,
                    Txn txn)

Create a new TakeIfExistsWatcher.

Parameters:

expiration - the initial expiration time for this TransitionWatcher in milliseconds since the beginning of the epoch.

timestamp - the value that is used to sort TransitionWatchers.

startOrdinal - the highest ordinal associated with operations that are considered to have occurred before the operation associated with this watcher.

lockedEntries - Set of entries (by their IDs) that match but are unavailable. Must be non-empty. Keeps a reference to this object.

provisionallyRemovedEntrySet - If the watcher encounters an entry that can not be read/taken because it has been provisionally removed then its handle will be placed in this WeakHashMap as a key (with null as the value). May be null in which case provisionally removed entries will not be recorded. Ensures that object is only accessed by one thread at a time

txn - If the query is being performed under a transaction the Txn object associated with that transaction.

Throws:

NullPointerException - if lockedEntries is null.

Method Detail

isInterested

boolean isInterested(EntryTransition transition,
                     long ordinal)

Description copied from class: TransitionWatcher

Return true if this watcher cares about a given visibility transition. Assumes the transitioning entry matches the template in the TemplateHandle associated with this watcher. This method should return a value even if the expiration time has been reached or remove has been called. This call should not obtain any locks.

Specified by:

isInterested in class TransitionWatcher

Parameters:

transition - A EntryTransition that describes the transition and what entry is transitioning. This method will assume that transition.getHandle returns a non-null value.

ordinal - The ordinal associated with transition.

Returns:

true if this watcher is interested in the indicated transition and false otherwise.

process

void process(EntryTransition transition,
             long now)

Description copied from class: TransitionWatcher

Process the given transition. Assumes the passed entry matches the template in the TemplateHandle associated with this watcher and that isInterested returned true. This call may make changes to the passed EntryHandle that will prevent it from being used by other watchers. If remove has been called or the expiration time of this watcher has passed, this call should have no effect. This call may cause the watcher to be removed.

Specified by:

process in class TransitionWatcher

Parameters:

transition - A EntryTransition that describes the transition and what entry is transitioning. This method will assume that transition.getHandle returns a non-null value.

now - An estimate of the current time (not the time when the event occured).

catchUp

boolean catchUp(EntryTransition transition,
                long now)

Description copied from class: QueryWatcher

Process a transition which was posted before the watcher was placed in TransitionWatchers object. Assumes that the entry in the transition matches matches the template in the TemplateHandle associated with this watcher. Does not assume isInterested has been called.

Specified by:

catchUp in class QueryWatcher

Parameters:

transition - A EntryTransition that describes the transition and what entry is transitioning. This method will assume that transition.getHandle returns a non-null value.

now - An estimate of the current time (not the time when the event occured).

Returns:

true if the query has been resolved, and false otherwise. Note, even if this call returns true, waitOnResolution must still be called.

caughtUp

public void caughtUp()

Once the backlog is complete we can resolve if lockedEntries is/becomes empty.

Specified by:

caughtUp in interface IfExistsWatcher

isLockedEntrySetEmpty

public boolean isLockedEntrySetEmpty()

Description copied from interface: IfExistsWatcher

If the query has been resolved by the locked entry set becoming empty returns true, otherwise return false.

Specified by:

isLockedEntrySetEmpty in interface IfExistsWatcher

Returns:

true if locked entry set associated with this query is empty.

prepare

public int prepare(TransactableMgr mgr,
                   OutriggerServerImpl space)

If a transaction ends in the middle of a query we want to throw an exception to the client making the query not the Txn calling us here.)

Specified by:

prepare in interface Transactable

commit

public void commit(TransactableMgr mgr,
                   OutriggerServerImpl space)

This should never happen since we always return NOTCHANGED from prepare.

Specified by:

commit in interface Transactable

abort

public void abort(TransactableMgr mgr,
                  OutriggerServerImpl space)

If a transaction ends in the middle of a query we want to throw an exception to the client making the query (not the Txn calling us here.)

Specified by:

abort in interface Transactable