@Override public void register(final Consumer<InboundSseEvent> onEvent, final Consumer<Throwable> onError) { this.subscribe(DEFAULT_SUBSCRIPTION_HANDLER, onEvent, onError, () -> { }); }
private void notify(final Collection<EventListener> listeners, final InboundEvent event) { for (EventListener listener : listeners) { notify(listener, event); } }
@Override public SseBroadcaster newBroadcaster() { return new JerseySseBroadcaster(executorService); } }
@Override public void open() { if (!state.compareAndSet(EventProcessor.State.READY, EventProcessor.State.OPEN)) { switch (state.get()) { case CLOSED: throw new IllegalStateException(LocalizationMessages.EVENT_SOURCE_ALREADY_CLOSED()); case OPEN: throw new IllegalStateException(LocalizationMessages.EVENT_SOURCE_ALREADY_CONNECTED()); } } EventProcessor processor = EventProcessor .builder(endpoint, state, clientExecutor, this::onEvent, this::close) .reconnectDelay(reconnectDelay, reconnectTimeUnit) .build(); clientExecutor.submit(processor); // return only after the first request to the SSE endpoint has been made processor.awaitFirstContact(); }
@Override public void onNext(final OutboundSseEvent item) { checkClosed(); if (item == null) { throw new NullPointerException(LocalizationMessages.PARAM_NULL("outboundSseEvent")); } try { write(item); } catch (final IOException e) { onError(e); } }
@Override public CompletionStage<?> send(OutboundSseEvent event) { checkClosed(); try { this.write(event); return CompletableFuture.completedFuture(null); } catch (IOException e) { return CompletableFuture.completedFuture(e); } }
public void onComplete() { checkClosed(); subscription.cancel(); close(); }
@Override public void onError(final Throwable throwable) { checkClosed(); if (throwable == null) { throw new NullPointerException(LocalizationMessages.PARAM_NULL("throwable")); } subscription.cancel(); }
/** * Build the {@link EventProcessor}. * * @return built Event processor instance. */ public EventProcessor build() { return new EventProcessor(this); } }
@Override public SseEventSink apply(ContainerRequest containerRequest) { return new JerseyEventSink(asyncContextSupplier); } }
/** * Create new Event processor builder. * * @param target web target to be used to call remote resource. * @param state state shared with the owner of event processor instance. * @param clientExecutor executor service used for consuming events and scheduling reconnects. * @param eventListener event listener. * @param shutdownHandler shutdown callback. * @return new {@link Builder} instance. */ public static Builder builder(WebTarget target, AtomicReference<State> state, ClientExecutor clientExecutor, EventListener eventListener, ShutdownHandler shutdownHandler) { return new Builder(target, state, clientExecutor, eventListener, shutdownHandler); }
@Override public void register(SseEventSink sseEventSink) { super.subscribe(new SseEventSinkWrapper(sseEventSink)); }
private void checkClosed() { if (isClosed()) { throw new IllegalStateException(LocalizationMessages.EVENT_SOURCE_ALREADY_CLOSED()); } } }
@Override public JerseySseEventSource build() { if (endpoint instanceof JerseyWebTarget) { return new JerseySseEventSource((JerseyWebTarget) endpoint, reconnectDelay, reconnectTimeUnit); } else { throw new IllegalArgumentException(LocalizationMessages.UNSUPPORTED_WEBTARGET_TYPE(endpoint)); } } }
@Override public CompletionStage<?> broadcast(final OutboundSseEvent event) { if (event == null) { throw new IllegalArgumentException(LocalizationMessages.PARAM_NULL("event")); } publish(event); // TODO JAX-RS 2.1 return null; }
@Override protected void configure() { bind(JerseySse.class) .to(Sse.class) .in(Singleton.class); } }
@Override protected Function<ContainerRequest, SseEventSink> createValueProvider(Parameter parameter) { if (parameter == null) { return null; } final Class<?> rawParameterType = parameter.getRawType(); if (rawParameterType == SseEventSink.class && parameter.isAnnotationPresent(Context.class)) { return new SseEventSinkValueSupplier(asyncContextSupplier); } return null; }
@Override public void register(final Consumer<InboundSseEvent> onEvent) { this.subscribe(DEFAULT_SUBSCRIPTION_HANDLER, onEvent, DEFAULT_ERROR_HANDLER, () -> { }); }
@Override public void onSubscribe(final Flow.Subscription subscription) { checkClosed(); if (subscription == null) { throw new NullPointerException(LocalizationMessages.PARAM_NULL("subscription")); } this.subscription = subscription; subscription.request(Long.MAX_VALUE); }
@Override public void register(final Consumer<InboundSseEvent> onEvent, final Consumer<Throwable> onError, final Runnable onComplete) { this.subscribe(DEFAULT_SUBSCRIPTION_HANDLER, onEvent, onError, onComplete); }