org.nustaq.kontraktor.reactivestreams

Class KxReactiveStreams

java.lang.Object

org.nustaq.kontraktor.Actors

org.nustaq.kontraktor.reactivestreams.KxReactiveStreams

public class KxReactiveStreams
extends org.nustaq.kontraktor.Actors

Created by ruedi on 28/06/15. Factory class for reactive streams <=> Kontraktor interop. Note you rarely need use this directly. To publish / start a stream, see EventSink (offer() like feed in point), this also allows to publish it on network. For connecting a remote stream, see ReaktiveStreams.connectXXX methods. Note that RxPublisher extends the original Publisher interface. for interop use asRxPublisher()

Field Summary

Fields

Modifier and Type	Field and Description
protected int	batchSize
static int	DEFBATCHSIZE
static int	DEFQSIZE
protected static KxReactiveStreams	instance
static int	MAX_BATCH_SIZE
static int	REQU_NEXT_DIVISOR

Fields inherited from class org.nustaq.kontraktor.Actors

CONT, DEFAULT_TIMOUT, defaultScheduler, delayedCalls, exec, MAX_EXTERNAL_THREADS_POOL_SIZE, version

Constructor Summary

Constructors

Constructor and Description
KxReactiveStreams() each KxReactiveStreams instance has a dedicated thread which is used for all its processors.
KxReactiveStreams(boolean keepSchedulerAlive)
KxReactiveStreams(int batchSize, int queueSize, boolean keepSchedulerAlive)

Method Summary

Modifier and Type	Method and Description
<T> KxPublisher<T>	asKxPublisher(org.reactivestreams.Publisher<T> p) interop, obtain a RxPublisher from an arbitrary rxstreams publisher.
<T> KxPublisher<T>	connect(Class<T> eventType, org.nustaq.kontraktor.remoting.base.ConnectableActor connectable)
<T> org.nustaq.kontraktor.IPromise<KxPublisher<T>>	connect(Class<T> eventType, org.nustaq.kontraktor.remoting.base.ConnectableActor connectable, org.nustaq.kontraktor.Callback<org.nustaq.kontraktor.remoting.base.ActorClientConnector> disconHandler)
static KxReactiveStreams	get()
int	getBatchSize()
<T> Iterator<T>	iterator(org.reactivestreams.Publisher<T> pub) warning: blocks the calling thread.
<T> Iterator<T>	iterator(org.reactivestreams.Publisher<T> pub, int batchSize) warning: blocks the calling thread.
<IN,OUT> org.reactivestreams.Processor<IN,OUT>	newAsyncProcessor(Function<IN,OUT> processingFunction) create async processor.
<IN,OUT> org.reactivestreams.Processor<IN,OUT>	newAsyncProcessor(Function<IN,OUT> processingFunction, int batchSize) create async processor.
<IN,OUT> org.reactivestreams.Processor<IN,OUT>	newAsyncProcessor(Function<IN,OUT> processingFunction, org.nustaq.kontraktor.Scheduler sched, int batchSize) create async processor.
<T,OUT> org.reactivestreams.Processor<T,OUT>	newLossyProcessor(Function<T,OUT> processingFunction, int batchSize)
<IN,OUT> org.reactivestreams.Processor<IN,OUT>	newSyncProcessor(Function<IN,OUT> processingFunction) create sync processor.
<T> KxPublisher<T>	produce(Collection<T> collection)
KxPublisher<Double>	produce(DoubleStream stream)
<T> KxPublisher<T>	produce(int batchSize, Iterator<T> iter)
KxPublisher<Integer>	produce(IntStream stream)
<T> KxPublisher<T>	produce(int batchSize, Stream<T> stream)
<T> KxPublisher<T>	produce(Iterator<T> iter)
KxPublisher<Long>	produce(LongStream stream)
<T> KxPublisher<T>	produce(Stream<T> stream)
<OUT> org.nustaq.kontraktor.IPromise	serve(org.reactivestreams.Publisher<OUT> source, org.nustaq.kontraktor.remoting.base.ActorPublisher networRxPublisher, boolean closeConnectionOnCompleteOrError, Consumer<org.nustaq.kontraktor.Actor> disconCB) exposes a publisher on the network via kontraktor's generic remoting.
<T> Stream<T>	stream(org.reactivestreams.Publisher<T> pub) warning: blocks the calling thread.
<T> Stream<T>	stream(org.reactivestreams.Publisher pub, int batchSize) warning: blocks the calling thread.
<T> org.reactivestreams.Subscriber<T>	subscriber(org.nustaq.kontraktor.Callback<T> cb) consuming endpoint.
<T> org.reactivestreams.Subscriber<T>	subscriber(int batchSize, org.nustaq.kontraktor.Callback<T> cb) consuming endpoint.
void	terminateScheduler() tellMsg the execution thread to stop as soon no actors are scheduled on it.

Methods inherited from class org.nustaq.kontraktor.Actors

AddDeadLetter, all, all, all, allMapped, AsActor, AsActor, AsActor, AsActor, AsUntypedActor, awaitAll, awaitAll, awaitAll, awaitAll, complete, complete, DeadLetters, flow, InThread, isComplete, isCont, isError, isErrorOrComplete, isResult, isTimeout, promise, race, race, reject, resolve, resolve, stream, SubmitDelayed, yield, yield, yieldCallbacks

Methods inherited from class java.lang.Object

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

Field Detail

MAX_BATCH_SIZE

public static final int MAX_BATCH_SIZE

See Also:

Constant Field Values

DEFQSIZE

public static final int DEFQSIZE

See Also:

Constant Field Values

DEFBATCHSIZE

public static final int DEFBATCHSIZE

See Also:

Constant Field Values

REQU_NEXT_DIVISOR

public static int REQU_NEXT_DIVISOR

instance

protected static KxReactiveStreams instance

batchSize

protected int batchSize

Constructor Detail

KxReactiveStreams

public KxReactiveStreams()

each KxReactiveStreams instance has a dedicated thread which is used for all its processors. Its recommended to use the singleton for normal use cases. Only start using multiple KxReactiveStreams instances if you need to scale out for throughput. Note that frequently increase of cache misses can lead to an effective degrade of throughput, so you need to choose wisely which part of your processing pipeling shares a thread. Because of Kontraktor's explicit scheduling model, load balancing cannot be done automatically currently.

KxReactiveStreams

public KxReactiveStreams(boolean keepSchedulerAlive)

KxReactiveStreams

public KxReactiveStreams(int batchSize,
                         int queueSize,
                         boolean keepSchedulerAlive)

Method Detail

get

public static KxReactiveStreams get()

getBatchSize

public int getBatchSize()

terminateScheduler

public void terminateScheduler()

tellMsg the execution thread to stop as soon no actors are scheduled on it.

asKxPublisher

public <T> KxPublisher<T> asKxPublisher(org.reactivestreams.Publisher<T> p)

interop, obtain a RxPublisher from an arbitrary rxstreams publisher. RxPublisher inherits rxtreams.Publisher and adds some sugar like map, network publish etc. via default methods

Type Parameters:

T -

Parameters:

p -

Returns:

subscriber

public <T> org.reactivestreams.Subscriber<T> subscriber(org.nustaq.kontraktor.Callback<T> cb)

consuming endpoint. requests data from publisher immediately after receiving onSubscribe callback. Maps from reactive streams Subscriber to Kontraktor Callback all events are routed to the callback e.g.

            subscriber( (event, err) -> {
                if (Actors.isComplete(err)) {
                    System.out.println("complete");
                } else if (Actors.isError(err)) {
                    System.out.println("ERROR");
                } else {
                    // process event
                }
            }
       

Type Parameters:

T -

subscriber

public <T> org.reactivestreams.Subscriber<T> subscriber(int batchSize,
                                                        org.nustaq.kontraktor.Callback<T> cb)

consuming endpoint. requests data from publisher immediately after receiving onSubscribe callback. Maps from reactive streams Subscriber to Kontraktor Callback all events are routed to the callback e.g.

            subscriber( (event, err) -> {
                if (Actors.isComplete(err)) {
                    System.out.println("complete");
                } else if (Actors.isError(err)) {
                    System.out.println("ERROR");
                } else {
                    // process event
                }
            }
       

Type Parameters:

T -

connect

public <T> KxPublisher<T> connect(Class<T> eventType,
                                  org.nustaq.kontraktor.remoting.base.ConnectableActor connectable)

produce

public <T> KxPublisher<T> produce(Stream<T> stream)

produce

public <T> KxPublisher<T> produce(Collection<T> collection)

produce

public KxPublisher<Integer> produce(IntStream stream)

produce

public KxPublisher<Long> produce(LongStream stream)

produce

public KxPublisher<Double> produce(DoubleStream stream)

produce

public <T> KxPublisher<T> produce(int batchSize,
                                  Stream<T> stream)

produce

public <T> KxPublisher<T> produce(Iterator<T> iter)

produce

public <T> KxPublisher<T> produce(int batchSize,
                                  Iterator<T> iter)

stream

public <T> Stream<T> stream(org.reactivestreams.Publisher<T> pub)

warning: blocks the calling thread. Need to execute in a separate thread if called from within a callback

stream

public <T> Stream<T> stream(org.reactivestreams.Publisher pub,
                            int batchSize)

warning: blocks the calling thread. Need to execute in a separate thread if called from within a callback

iterator

public <T> Iterator<T> iterator(org.reactivestreams.Publisher<T> pub)

warning: blocks the calling thread. Need to execute in a separate thread if called from within a callback

iterator

public <T> Iterator<T> iterator(org.reactivestreams.Publisher<T> pub,
                                int batchSize)

warning: blocks the calling thread. Need to execute in a separate thread if called from within a callback

connect

public <T> org.nustaq.kontraktor.IPromise<KxPublisher<T>> connect(Class<T> eventType,
                                                                  org.nustaq.kontraktor.remoting.base.ConnectableActor connectable,
                                                                  org.nustaq.kontraktor.Callback<org.nustaq.kontraktor.remoting.base.ActorClientConnector> disconHandler)

Type Parameters:

T -

Parameters:

eventType -

connectable -

disconHandler - - can be null

Returns:

serve

public <OUT> org.nustaq.kontraktor.IPromise serve(org.reactivestreams.Publisher<OUT> source,
                                                  org.nustaq.kontraktor.remoting.base.ActorPublisher networRxPublisher,
                                                  boolean closeConnectionOnCompleteOrError,
                                                  Consumer<org.nustaq.kontraktor.Actor> disconCB)

exposes a publisher on the network via kontraktor's generic remoting. Usually not called directly (see EventSink+RxPublisher)

Type Parameters:

OUT -

Parameters:

source -

networRxPublisher - - the appropriate network publisher (TCP,TCPNIO,WS)

disconCB - - called once a client disconnects/stops. can be null

Returns:

newAsyncProcessor

public <IN,OUT> org.reactivestreams.Processor<IN,OUT> newAsyncProcessor(Function<IN,OUT> processingFunction)

create async processor. Usually not called directly (see EventSink+RxPublisher)

Type Parameters:

IN -

OUT -

Parameters:

processingFunction -

Returns:

newAsyncProcessor

public <IN,OUT> org.reactivestreams.Processor<IN,OUT> newAsyncProcessor(Function<IN,OUT> processingFunction,
                                                                        int batchSize)

create async processor. Usually not called directly (see EventSink+RxPublisher). The resulting processor is Publisher allowing for multiple subscribers, having a slowest-subscriber-dominates policy.

Type Parameters:

IN -

OUT -

Parameters:

processingFunction -

batchSize -

Returns:

newAsyncProcessor

public <IN,OUT> org.reactivestreams.Processor<IN,OUT> newAsyncProcessor(Function<IN,OUT> processingFunction,
                                                                        org.nustaq.kontraktor.Scheduler sched,
                                                                        int batchSize)

create async processor. Usually not called directly (see EventSink+RxPublisher) The resulting processor is Publisher allowing for multiple subscribers, having a slowest-subscriber-dominates policy.

Type Parameters:

IN -

OUT -

Parameters:

processingFunction -

sched -

batchSize -

Returns:

newSyncProcessor

public <IN,OUT> org.reactivestreams.Processor<IN,OUT> newSyncProcessor(Function<IN,OUT> processingFunction)

create sync processor. Usually not called directly (see EventSink+RxPublisher) does not support dropping elements by returning null from processor, does not support multiple subscribers. Prefer map() unless you are aware of the implications.

Type Parameters:

IN -

OUT -

Parameters:

processingFunction -

Returns:

newLossyProcessor

public <T,OUT> org.reactivestreams.Processor<T,OUT> newLossyProcessor(Function<T,OUT> processingFunction,
                                                                      int batchSize)