Java Code Examples for reactor.core.publisher.UnicastProcessor#sink()

protected InstanceEventPublisher() {
    UnicastProcessor<InstanceEvent> unicastProcessor = UnicastProcessor.create();
    this.publishedFlux = unicastProcessor.publish().autoConnect(0);
    this.sink = unicastProcessor.sink();
}
 

private TestEventHandler(Publisher<InstanceEvent> publisher) {
    super(publisher, InstanceRegisteredEvent.class);
    UnicastProcessor<InstanceEvent> processor = UnicastProcessor.create();
    this.sink = processor.sink();
    this.flux = processor;
}
 

@Override
public void triggerEvent(ObjectIdentifier objectIdentifier, T value)
{
    Flux<T> stream = null;
    FluxSink<T> sink;
    Set<FluxSink<Tuple2<ObjectIdentifier, Flux<T>>>> waiterSet = null;

    lock.lock();
    try
    {
        sink = sinks.get(objectIdentifier);
        if (sink == null)
        {
            UnicastProcessor<T> processor = UnicastProcessor.create();
            ConnectableFlux<T> publisher = processor.replay(1);
            publisher.connect();

            // Publish events signals on the main scheduler to detach the execution from this thread,
            // so that we don't react to events in the thread-local context where the event is triggered.
            stream = publisher.publishOn(scheduler);
            streams.put(objectIdentifier, stream);
            try
            {
                eventStreamStore.addEventStream(new EventIdentifier(null, objectIdentifier));
            }
            catch (LinStorDataAlreadyExistsException exc)
            {
                throw new ImplementationError(exc);
            }

            sink = processor.sink();
            sinks.put(objectIdentifier, sink);

            List<ObjectIdentifier> matchingWaitObjects = matchingObjects(objectIdentifier);

            waiterSet = new HashSet<>();
            for (ObjectIdentifier waitObject : matchingWaitObjects)
            {
                Set<FluxSink<Tuple2<ObjectIdentifier, Flux<T>>>> waitersForObject = waiters.get(waitObject);
                if (waitersForObject != null)
                {
                    waiterSet.addAll(waitersForObject);
                }
            }
        }
    }
    finally
    {
        lock.unlock();
    }

    if (waiterSet != null)
    {
        for (FluxSink<Tuple2<ObjectIdentifier, Flux<T>>> waiter : waiterSet)
        {
            waiter.next(Tuples.of(objectIdentifier, stream));
        }
    }

    sink.next(value);
}
 

protected TcpConnectorPeer(
    ErrorReporter errorReporterRef,
    CommonSerializer commonSerializerRef,
    String peerIdRef,
    TcpConnector connectorRef,
    SelectionKey key,
    AccessContext accCtx,
    Node nodeRef
)
{
    errorReporter = errorReporterRef;
    commonSerializer = commonSerializerRef;
    peerId = peerIdRef;
    connector = connectorRef;
    node = nodeRef;
    msgOutQueue = new LinkedList<>();

    // Do not use createMessage() here!
    // The SslTcpConnectorPeer has not initialized SSLEngine instance yet,
    // so a NullPointerException would be thrown in createMessage().
    // After initialization of the sslEngine, msgIn will be overwritten with
    // a reference to a valid instance.
    msgIn = new MessageData(false);

    selKey = key;
    peerAccCtx = accCtx;
    attachment = null;

    internalPingMsg = new TcpHeaderOnlyMessage(MessageTypes.PING);
    internalPongMsg = new TcpHeaderOnlyMessage(MessageTypes.PONG);

    serializerId = new AtomicLong(0);
    serializerLock = new ReentrantReadWriteLock(true);

    satelliteStateLock = new ReentrantReadWriteLock(true);
    if (node != null)
    {
        satelliteState = new SatelliteState();
    }

    finishedMsgInQueue = new LinkedList<>();

    UnicastProcessor<Tuple2<Long, Publisher<?>>> processor = UnicastProcessor.create();
    incomingMessageSink = processor.sink();
    processor
        .transform(OrderingFlux::order)
        .flatMap(Function.identity(), Integer.MAX_VALUE)
        .subscribe(
            ignored ->
            {
                // do nothing
            },
            exc -> errorReporterRef.reportError(
                exc, null, null, "Uncaught exception in processor for peer '" + this + "'")
        );
}
 

protected InstanceEventPublisher() {
	UnicastProcessor<InstanceEvent> unicastProcessor = UnicastProcessor.create();
	this.publishedFlux = unicastProcessor.publish().autoConnect(0);
	this.sink = unicastProcessor.sink();
}
 

private TestEventHandler(Publisher<InstanceEvent> publisher) {
	super(publisher, InstanceRegisteredEvent.class);
	UnicastProcessor<InstanceEvent> processor = UnicastProcessor.create();
	this.sink = processor.sink();
	this.flux = processor;
}