Package discord4j.core.event

Class ReplayingEventDispatcher

  • All Implemented Interfaces:
    EventDispatcher
    public class ReplayingEventDispatcher
extends Object
implements EventDispatcher
    Distributes events to active subscribers, while using a fallback storage if no subscribers are present that can be replayed to future late subscribers.

    Allows configuring the main FluxProcessor backend, its publishing Scheduler for thread affinity, the ReplayProcessor for storage and a Predicate to determine which events should be stored for replay.

    While under no subscribers, this event dispatcher will store all incoming events that match the given filter to its replay processor. Once the first subscriber has connected, the given stop trigger is subscribed and once it terminates or is cancelled, no further events will be stored for replay, until all existing subscribers have disconnected.

    During the replay window, late subscribers benefit from all events that are pushed to this dispatcher, therefore enabling scenarios where very early events are not missed despite connecting late.

    • Constructor Detail

      • ReplayingEventDispatcher

        public ReplayingEventDispatcher​(FluxProcessor<Event,​Event> eventProcessor,
                                FluxSink.OverflowStrategy overflowStrategy,
                                Scheduler eventScheduler,
                                ReplayProcessor<Event> replayEventProcessor,
                                FluxSink.OverflowStrategy replayEventOverflowStrategy,
                                Predicate<Event> replayEventFilter,
                                Scheduler timedTaskScheduler,
                                Publisher<?> stopReplayingTrigger)
        Creates a new event dispatcher that is able to retain events to replay to multiple late subscribers, using the given parameters.
        Parameters:
        eventProcessor - a processor used to bridge gateway events to the dispatcher connected subscribers
        overflowStrategy - an overflow strategy, see FluxSink.OverflowStrategy for the available strategies
        eventScheduler - a Scheduler to ensure a certain thread model on each published signal
        replayEventProcessor - a processor used to store events while no subscribers are connected and will be forwarded to all late subscribers
        replayEventOverflowStrategy - an overflow strategy while pushing events to the replay processor
        replayEventFilter - a filter used to decide whether an Event should be published to the replay processor
        timedTaskScheduler - a time-capable Scheduler used to detect whether all events have replayed to a subscriber
        stopReplayingTrigger - a trigger Publisher that is subscribed upon the first subscriber connects to this dispatcher. Upon completion, error or cancellation, the replaying window will be closed until all subscribers have disconnected

    • Method Detail

      • on

        public <E extends Event> Flux<E> on​(Class<E> eventClass)
        Description copied from interface: EventDispatcher
        Retrieves a Flux with elements of the given Event type. This Flux has to be subscribed to in order to start processing. See Event class for the list of possible event classes.

        Note: Errors occurring while processing events will terminate your sequence. If you wish to use a version capable of handling errors for you, use EventDispatcher.on(Class, Function). See Reactive Streams Spec explaining this behavior.

        A recommended pattern to use this method is wrapping your code that may throw exceptions within a flatMap block and use Mono.onErrorResume(Function), Flux.onErrorResume(Function) or equivalent methods to maintain the sequence active: 

         client.getEventDispatcher().on(MessageCreateEvent.class)
     .flatMap(event -> myCodeThatMightThrow(event)
             .onErrorResume(error -> {
                 // log and then discard the error to keep the sequence alive
                 log.error("Failed to handle event!", error);
                 return Mono.empty();
             }))
     .subscribe();

        For more alternatives to handling errors, please see Error Handling wiki page.

        Specified by:
        on in interface EventDispatcher
        Type Parameters:
        E - the type of the event class
        Parameters:
        eventClass - the event class to obtain events from
        Returns:
        a new Flux with the requested events

      • publish

        public void publish​(Event event)
        Description copied from interface: EventDispatcher
        Publishes an Event to the dispatcher. Might throw an unchecked exception if the dispatcher can't handle this event.
        Specified by:
        publish in interface EventDispatcher
        Parameters:
        event - the Event to publish

      • shutdown

        public void shutdown()
        Description copied from interface: EventDispatcher
        Signal that this event dispatcher must terminate and release its resources.
        Specified by:
        shutdown in interface EventDispatcher