/** * Observe a request execution and emit the response to the observer. * * @param supplier teh supplier * @return The hot observable (eagerly executes). */ public static Observable<Response> observe(final Func0<BoundRequestBuilder> supplier) { //use a ReplaySubject to buffer the eagerly subscribed-to Observable ReplaySubject<Response> subject = ReplaySubject.create(); //eagerly kick off subscription toObservable(supplier).subscribe(subject); //return the subject that can be subscribed to later while the execution has already started return subject; } }
protected HystrixCachedObservable(final Observable<R> originalObservable) { ReplaySubject<R> replaySubject = ReplaySubject.create(); this.originalSubscription = originalObservable .subscribe(replaySubject); this.cachedObservable = replaySubject .doOnUnsubscribe(new Action0() { @Override public void call() { outstandingSubscriptions--; if (outstandingSubscriptions == 0) { originalSubscription.unsubscribe(); } } }) .doOnSubscribe(new Action0() { @Override public void call() { outstandingSubscriptions++; } }); }
ReplaySubject<ResponseType> subject = ReplaySubject.create();
ReplaySubject<ResponseType> subject = ReplaySubject.create();
ReplaySubject<R> subject = ReplaySubject.create();
@Override public Observable<Delivery<View, T>> call(Observable<T> observable) { final ReplaySubject<Notification<T>> subject = ReplaySubject.create(); final Subscription subscription = observable .materialize()
@Override public Observable<Response> observe() { ReplaySubject<Response> subject = ReplaySubject.create(); final Subscription sourceSubscription = toObservable().subscribe(subject); return subject.doOnUnsubscribe(sourceSubscription::unsubscribe); }
@Override public final Subject<T, T> call() { return ReplaySubject.create(); } }, selector));
public StatRequest(final String key, final NetworkAddress hostname, final String bucket) { super(key, bucket, null, null, ReplaySubject.<CouchbaseResponse>create()); this.hostname = hostname; }
protected AbstractServiceChannel(STATE initState, StateMachineMetrics<STATE> metrics) { this.initState = initState; this.metrics = metrics; this.state = new AtomicReference<>(initState); // Since its of type void there isn't any caching of data. Its just the terminal state that is cached. this.lifecycle = ReplaySubject.create(); }
public static Observable<Result<Instrument>> fromString(final SearchContext ctx, final String... symbols) { final ReplaySubject<Result<Instrument>> sub = ReplaySubject.create(); executor.submit(runnableFromString(sub, ctx, symbols)); return sub; }
@Override public final Subject<T, T> call() { return OperatorReplay.createScheduledSubject(ReplaySubject.<T> create(), scheduler); } }, selector));
@Override public Observable<T> observe() { ReplaySubject<T> subject = ReplaySubject.create(); getObservable().subscribe(subject); return subject; }
@Override public Subject<? super T, ? extends T> call() { return OperatorReplay.createScheduledSubject(ReplaySubject.<T> create(), scheduler); }
public static Observable<Map<InstrumentID, Instrument>> fromID(final InstrumentID... ids) { final ReplaySubject<Map<InstrumentID, Instrument>> sub = ReplaySubject.create(); executor.submit(runnableFromIDs(sub, ids)); return sub; }
public Session create() { long id = counter.getAndIncrement(); Subject<byte[], byte[]> subject = ReplaySubject.create(); logger.debug("Creating new session: " + id); Session session = new Session(id, subject); sessions.put(id, session); return session; }
/** * Complete current notification subject, and create a new one. All interest subscribers will onComplete. */ public void reset() { fullRegistrySubject.onCompleted(); notificationSubjects.clear(); Mockito.reset(registry); fullRegistrySubject = ReplaySubject.create(); }
private RxObserverAdapter(Observable<R> source) { subject = ReplaySubject.create(); observable = subject.last(); if (source != null) source.subscribe(subject); observable.subscribe(new StateObserver()); }
@Override public Observable<Response> observe() { ReplaySubject<Response> subject = ReplaySubject.create(); final Subscription sourceSubscription = toObservable().subscribe(subject); return subject.doOnUnsubscribe(sourceSubscription::unsubscribe); }
@Test public void sj1ToFp2Backpressured() { rx.subjects.Subject<Integer, Integer> sj1 = rx.subjects.ReplaySubject.create(); io.reactivex.processors.FlowableProcessor<Integer> pp2 = toV2Processor(sj1); io.reactivex.subscribers.TestSubscriber<Integer> to = pp2.test(0L); assertTrue(sj1.hasObservers()); assertTrue(pp2.hasSubscribers()); pp2.onNext(1); pp2.onNext(2); pp2.onNext(3); pp2.onNext(4); to.assertNoValues().assertNoErrors().assertNotComplete(); to.requestMore(1).assertValue(1).assertNoErrors().assertNotComplete(); to.requestMore(2).assertValues(1, 2, 3).assertNoErrors().assertNotComplete(); pp2.onComplete(); to.assertValues(1, 2, 3).assertNoErrors().assertNotComplete(); assertFalse(sj1.hasObservers()); assertFalse(pp2.hasSubscribers()); assertTrue(pp2.hasComplete()); assertFalse(pp2.hasThrowable()); assertNull(pp2.getThrowable()); to .requestMore(1) .assertResult(1, 2, 3, 4); }