@Override public void call(Subscriber<? super T> subscriber) { source.unsafeSubscribe(subscriber); } });
@Override public void call(Subscriber<? super PooledConnection<R, W>> subscriber) { final IdleConnectionsHolder<W, R> holderForThisEL = perElHolder.get(); if (null == holderForThisEL) { /*Caller is not an eventloop*/ PreferCurrentEventLoopHolder.super.pollThisEventLoopConnections().unsafeSubscribe(subscriber); } else { holderForThisEL.poll().unsafeSubscribe(subscriber); } } });
@Override public void call(Subscriber<? super T> subscriber) { if (disposed.get()) { subscriber.onError(new IllegalStateException("Content source is already disposed.")); } boolean connectNow = false; synchronized (this) { if (!subscribed) { connectNow = true; subscribed = true; } } source.doOnNext(new Action1<T>() { @Override public void call(T msg) { ReferenceCountUtil.retain(msg); } }).unsafeSubscribe(subscriber); if (connectNow) { source.connect(); } } }
/* package */ HystrixThreadEventStream(Thread thread) { this.threadId = thread.getId(); this.threadName = thread.getName(); writeOnlyCommandStartSubject = PublishSubject.create(); writeOnlyCommandCompletionSubject = PublishSubject.create(); writeOnlyCollapserSubject = PublishSubject.create(); writeOnlyCommandStartSubject .onBackpressureBuffer() .doOnNext(writeCommandStartsToShardedStreams) .unsafeSubscribe(Subscribers.empty()); writeOnlyCommandCompletionSubject .onBackpressureBuffer() .doOnNext(writeCommandCompletionsToShardedStreams) .unsafeSubscribe(Subscribers.empty()); writeOnlyCollapserSubject .onBackpressureBuffer() .doOnNext(writeCollapserExecutionsToShardedStreams) .unsafeSubscribe(Subscribers.empty()); }
@Override public void call(Subscriber<? super Void> subscriber) { if (!isUsable()) { PooledConnection.this.owner.discard(PooledConnection.this) .unsafeSubscribe(subscriber); } else { Long keepAliveTimeout = unsafeNettyChannel().attr(DYNAMIC_CONN_KEEP_ALIVE_TIMEOUT_MS).get(); if (null != keepAliveTimeout) { PooledConnection.this.maxIdleTimeMillis = keepAliveTimeout; } markAwarePipeline.reset(); // Reset pipeline state, if changed, on release. PooledConnection.this.owner.release(PooledConnection.this) .doOnCompleted(new Action0() { @Override public void call() { releasedAtLeastOnce = true; lastReturnToPoolTimeMillis = System.currentTimeMillis(); } }) .unsafeSubscribe(subscriber); } } }).onErrorResumeNext(discard());
@Override public void call(Subscriber<? super PooledConnection<R, W>> subscriber) { final long startTimeNanos = Clock.newStartTimeNanos(); if (limitDeterminationStrategy.acquireCreationPermit(startTimeNanos, NANOSECONDS)) { Observable<Connection<R, W>> newConnObsv = hostConnector.getConnectionProvider() .newConnectionRequest(); newConnObsv.map(new Func1<Connection<R, W>, PooledConnection<R, W>>() { @Override public PooledConnection<R, W> call(Connection<R, W> connection) { return PooledConnection.create(PooledConnectionProviderImpl.this, maxIdleTimeMillis, connection); } }).doOnError(new Action1<Throwable>() { @Override public void call(Throwable throwable) { limitDeterminationStrategy.releasePermit(); /*Before connect we acquired.*/ } }).unsafeSubscribe(subscriber); } else { idleConnectionsHolder.poll() .switchIfEmpty(Observable.<PooledConnection<R, W>>error( new PoolExhaustedException("Client connection pool exhausted."))) .unsafeSubscribe(subscriber); } } });
@Override public void call(Subscriber<? super Connection<R, W>> subscriber) { if (isShutdown) { subscriber.onError(new IllegalStateException("Connection provider is shutdown.")); } idleConnectionsHolder.pollThisEventLoopConnections() .concatWith(connectIfAllowed()) .filter(new Func1<PooledConnection<R, W>, Boolean>() { @Override public Boolean call(PooledConnection<R, W> c) { boolean isUsable = c.isUsable(); if (!isUsable) { discardNow(c); } return isUsable; } }) .take(1) .lift(new ReuseSubscriberLinker()) .lift(new ConnectMetricsOperator()) .unsafeSubscribe(subscriber); } });
@Override protected void subscribeActual(org.reactivestreams.Subscriber<? super T> s) { ObservableSubscriber<T> parent = new ObservableSubscriber<T>(s); ObservableSubscriberSubscription parentSubscription = new ObservableSubscriberSubscription(parent); s.onSubscribe(parentSubscription); source.unsafeSubscribe(parent); }
@Override protected void subscribeActual(io.reactivex.Observer<? super T> s) { ObservableSubscriber<T> parent = new ObservableSubscriber<T>(s); s.onSubscribe(parent); source.unsafeSubscribe(parent); }
@Override public void call(Subscriber<? super T> t1) { target.unsafeSubscribe(t1); } };
@Override public void onCompleted() { if (!subscribed) { subscribed = true; delayed.unsafeSubscribe(s); } } };
.execute(query.returnGeneratedKeysFunction()); Subscriber<T> sub = createSubscriber(subscriber); o.unsafeSubscribe(sub);
@Override public void call(Subscriber<? super T> subscriber) { if (refresh.compareAndSet(true, false)) { current = source.cache(); } current.unsafeSubscribe(subscriber); }
@Override public void call() { if (!s.isUnsubscribed()) { source.unsafeSubscribe(s); } } }, time, unit);
@Override public void call(final Subscriber<? super T> child) { Subscriber<T> parent = createSubscriber(child, onEmpty); observable.unsafeSubscribe(parent); }
@Override protected void subscribeActual(org.reactivestreams.Subscriber<? super T> s) { ObservableSubscriber<T> parent = new ObservableSubscriber<T>(s); ObservableSubscriberSubscription parentSubscription = new ObservableSubscriberSubscription(parent); s.onSubscribe(parentSubscription); source.unsafeSubscribe(parent); }
@Override public void call(Subscriber<? super T> s) { Observable<? extends T> o; try { o = observableFactory.call(); } catch (Throwable t) { s.onError(t); return; } o.unsafeSubscribe(s); }
@Override public void call(Subscriber<? super T> child) { final MapLastSubscriber<T> parent = new MapLastSubscriber<T>(child, function); child.add(parent); child.setProducer(new Producer() { @Override public void request(long n) { parent.requestMore(n); } }); source.unsafeSubscribe(parent); }
@Override public Subscriber<? super T> call(Subscriber<? super R> subscriber) { final ParentSubscriber<T> parent = new ParentSubscriber<T>(); Observable<T> middle = Observable.create(new ForwarderOnSubscribe<T>(parent)); subscriber.add(parent); operation.call(middle).unsafeSubscribe(subscriber); return parent; }
@Override public void call(Subscriber<? super T> t) { OnTerminateResumeSubscriber<T> parent = new OnTerminateResumeSubscriber<T>(t, onError, onCompleted); t.add(parent); t.setProducer(parent.arbiter); o.unsafeSubscribe(parent); } });