ai.grakn.redisq

Class Redisq<T extends Document>

java.lang.Object

ai.grakn.redisq.Redisq<T>

All Implemented Interfaces:

Queue<T>

public class Redisq<T extends Document>
extends Object
implements Queue<T>

Constructor Summary

Constructors

Constructor and Description
Redisq(String name, java.time.Duration timeout, java.time.Duration ttlStateInfo, java.time.Duration lockTime, java.time.Duration discardTime, java.util.function.Consumer<T> consumer, Class<T> klass, redis.clients.util.Pool<redis.clients.jedis.Jedis> jedisPool, ExecutorService threadPool, com.codahale.metrics.MetricRegistry metricRegistry)

Method Summary

Modifier and Type	Method and Description
void	close() Sets a flag and waits for all the running threads to terminate
QueueConsumer<T>	getConsumer() Getter for the consumer being used
Future<Void>	getFutureForDocumentStateWait(Set<State> state, String id) It returns a future that waits for a document to reach a certain state Note that this works for DONE and FAILED since they are terminal states.
Future<Void>	getFutureForDocumentStateWait(Set<State> state, String id, long timeout, TimeUnit unit, redis.clients.util.Pool<redis.clients.jedis.Jedis> pool)
String	getName() Getter for the name of the queue
Names	getNames()
Optional<StateInfo>	getState(String id) Retrieves the state for the given id
java.util.stream.Stream<Optional<ExtendedStateInfo>>	getStates() Retrieves all the states.
void	push(T document) Put a document in the queue
void	pushAndWait(T dummyObject, long waitTimeout, TimeUnit waitTimeoutUnit) Same as push but it waits for the state of the document to be DONE i.e.
void	setState(redis.clients.jedis.Jedis jedis, long timestampMs, String id, State state, String info)
void	setState(String id, State state, String info) Sets a state "manually"
void	startConsumer() Starts the comsumer for this queue.

Methods inherited from class java.lang.Object

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

Methods inherited from interface ai.grakn.redisq.Queue

setState

Constructor Detail

Redisq

public Redisq(String name,
              java.time.Duration timeout,
              java.time.Duration ttlStateInfo,
              java.time.Duration lockTime,
              java.time.Duration discardTime,
              java.util.function.Consumer<T> consumer,
              Class<T> klass,
              redis.clients.util.Pool<redis.clients.jedis.Jedis> jedisPool,
              ExecutorService threadPool,
              com.codahale.metrics.MetricRegistry metricRegistry)

Method Detail

push

public void push(T document)

Description copied from interface: Queue

Put a document in the queue

Specified by:

push in interface Queue<T extends Document>

Parameters:

document - Document to be pushed to the queue. It must be serialisable.

startConsumer

public void startConsumer()

Description copied from interface: Queue

Starts the comsumer for this queue. The consumer takes care of the whole lifecycle, so e.g. in the Redisq implementation this includes a thread that consumes the elements in the queue and a thread that makes sure there are no dead jobs in the inflight queue.

Specified by:

startConsumer in interface Queue<T extends Document>

getFutureForDocumentStateWait

public Future<Void> getFutureForDocumentStateWait(Set<State> state,
                                                  String id)
                                           throws StateFutureInitializationException

Description copied from interface: Queue

It returns a future that waits for a document to reach a certain state Note that this works for DONE and FAILED since they are terminal states.

Specified by:

getFutureForDocumentStateWait in interface Queue<T extends Document>

Parameters:

state - Desired state

id - Id of the document we are watching

Returns:

A future that blocks on the state being equal to the given state

Throws:

StateFutureInitializationException - Thrown if it fails to subscribe to the state

getFutureForDocumentStateWait

public Future<Void> getFutureForDocumentStateWait(Set<State> state,
                                                  String id,
                                                  long timeout,
                                                  TimeUnit unit,
                                                  redis.clients.util.Pool<redis.clients.jedis.Jedis> pool)
                                           throws StateFutureInitializationException

Specified by:

getFutureForDocumentStateWait in interface Queue<T extends Document>

timeout - How long to wait until failing the subscription

unit - Unit of the timeout

Throws:

StateFutureInitializationException

See Also:

Also takes a jedis pool

setState

public void setState(String id,
                     State state,
                     String info)

Description copied from interface: Queue

Sets a state "manually"

Specified by:

setState in interface Queue<T extends Document>

Parameters:

id - Id of the document

state - State (e.g. DONE, FAILED)

info - Extra info to be stored (e.g. the exception message for the failure)

setState

public void setState(redis.clients.jedis.Jedis jedis,
                     long timestampMs,
                     String id,
                     State state,
                     String info)

getState

public Optional<StateInfo> getState(String id)

Description copied from interface: Queue

Retrieves the state for the given id

Specified by:

getState in interface Queue<T extends Document>

Parameters:

id - Id of the document

Returns:

Current state of the document. Empty if not available

getStates

public java.util.stream.Stream<Optional<ExtendedStateInfo>> getStates()

Description copied from interface: Queue

Retrieves all the states. It gives a snapshot of the keys at the time the method is called. If the returned state is empty it means it's not available any longer (the key was available when first invoked though).

Specified by:

getStates in interface Queue<T extends Document>

Returns:

A stream with all the states currently stored. The stream is null if finished.

close

public void close()
           throws InterruptedException

Description copied from interface: Queue

Sets a flag and waits for all the running threads to terminate

Specified by:

close in interface Queue<T extends Document>

Throws:

InterruptedException - if the operation is interrupted

getName

public String getName()

Description copied from interface: Queue

Getter for the name of the queue

Specified by:

getName in interface Queue<T extends Document>

Returns:

The name of the queue

getConsumer

public QueueConsumer<T> getConsumer()

Description copied from interface: Queue

Getter for the consumer being used

Specified by:

getConsumer in interface Queue<T extends Document>

Returns:

The comsumer

pushAndWait

public void pushAndWait(T dummyObject,
                        long waitTimeout,
                        TimeUnit waitTimeoutUnit)
                 throws WaitException

Description copied from interface: Queue

Same as push but it waits for the state of the document to be DONE i.e. the consumer successfully completed working on it.

Specified by:

pushAndWait in interface Queue<T extends Document>

Parameters:

dummyObject - Document to be pushed to the queue. It must be serialisable.

waitTimeout - Timeout for the wait. A WaitException is thrown when expired

waitTimeoutUnit - Unit for the timeout

Throws:

WaitException - Thrown if a timeout occurs while waiting for the consumer to be acknowledged in Redis or if the waitTimeout expires

getNames

public Names getNames()