private Observable<R> getUserExecutionObservable(final AbstractCommand<R> _cmd) { Observable<R> userObservable; try { userObservable = getExecutionObservable(); } catch (Throwable ex) { // the run() method is a user provided implementation so can throw instead of using Observable.onError // so we catch it here and turn it into Observable.error userObservable = Observable.error(ex); } return userObservable .lift(new ExecutionHookApplication(_cmd)) .lift(new DeprecatedOnRunHookApplication(_cmd)); }
private <X> Observable<Void> _write(final Observable<X> msgs, Func1<X, Boolean> flushSelector) { return _write(msgs.lift(new FlushSelectorOperator<>(flushSelector, this))); }
@Override public void start() throws Exception { HttpClient client = vertx.createHttpClient(); HttpClientRequest req = client.request(HttpMethod.GET, 8080, "localhost", "/"); req.toObservable(). flatMap(HttpClientResponse::toObservable). // Unmarshall the response to the Data object via Jackon lift(io.vertx.rxjava.core.RxHelper.unmarshaller(Data.class)). subscribe( data -> { System.out.println("Got response " + data.message); }); // End request req.end(); } }
@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); } });
return Observable.<Channel>just(embeddedChannel); }).lift(new Operator<Channel, Channel>() { @Override public Subscriber<? super Channel> call(final Subscriber<? super Channel> subscriber) {
if (properties.executionTimeoutEnabled().get()) { execution = executeCommandWithSpecifiedIsolation(_cmd) .lift(new HystrixObservableTimeoutOperator<R>(_cmd)); } else { execution = executeCommandWithSpecifiedIsolation(_cmd);
/** * Returns the nearest k entries (k=maxCount) to the given rectangle where the * entries are strictly less than a given maximum distance from the rectangle. * * @param r * rectangle * @param maxDistance * max distance of returned entries from the rectangle * @param maxCount * max number of entries to return * @return nearest entries to maxCount, in ascending order of distance */ public Observable<Entry<T, S>> nearest(final Rectangle r, final double maxDistance, int maxCount) { return search(r, maxDistance).lift(new OperatorBoundedPriorityQueue<Entry<T, S>>(maxCount, Comparators.<T, S>ascendingDistance(r))); }
@Test public void fo2ToFo1Crash() { FlowableOperator<Integer, Integer> transformer = new FlowableOperator<Integer, Integer>() { @Override public org.reactivestreams.Subscriber<? super Integer> apply(final org.reactivestreams.Subscriber<? super Integer> o) { throw new IllegalArgumentException(); } }; Observable.just(1) .lift(toV1Operator(transformer)) .test() .assertFailure(IllegalArgumentException.class); }
@Test public void fo2ToFo1() { FlowableOperator<Integer, Integer> transformer = new FlowableOperator<Integer, Integer>() { @Override public org.reactivestreams.Subscriber<? super Integer> apply(final org.reactivestreams.Subscriber<? super Integer> o) { return new org.reactivestreams.Subscriber<Integer>() { @Override public void onSubscribe(Subscription s) { o.onSubscribe(s); } @Override public void onNext(Integer t) { o.onNext(t + 1); } @Override public void onError(Throwable e) { o.onError(e); } @Override public void onComplete() { o.onComplete(); } }; } }; Observable.just(1) .lift(toV1Operator(transformer)) .test() .assertResult(2); }
@SuppressWarnings("unchecked") @Override public Observable<ObservableConnection<O, I>> connect() { return super.connect().lift(HANDSHAKE_OPERATOR); }
@Override public Observable<T> call(Observable<T> o) { return o.lift(OperatorDoOnNth.create(action, n)); } };
@Override public Observable<T> call(Observable<T> o) { return o.lift(new OperatorBufferToFile<T>(serializer, scheduler, options)); } };
@Override public Observable<T> call(Observable<T> source) { return source.lift(new OperatorSampleFirst<T>(duration, unit, scheduler)); } };
@Override public Observable<ResultSet> querySet(String sql, Object... params) { return sendQuery(sql, params) .lift(toResultSet(dataConverter)); }
@Override public Observable<Row> queryRows(String sql, Object... params) { return sendQuery(sql, params) .lift(toRow(dataConverter)); }
@Override public JsonPipeline handleException(JsonPipelineExceptionHandler handler) { Observable<JsonPipelineOutput> exceptionHandlingObservable = observable.lift(new HandleExceptionOperator(requests, handler)); return cloneWith(exceptionHandlingObservable, null, "HANDLE_EXCEPTION"); }
private void subscribeToInterest(Interest<InstanceInfo> newInterest) { BreakerSwitchOperator breaker = new BreakerSwitchOperator(); upgrades.onNext(eurekaRegistry.forInterest(newInterest).lift(breaker)); subscriptionBreakers.put(newInterest, breaker); }
@Override public Observable<T> call() { final OperatorPassThroughAdjustedRequest<T> op = new OperatorPassThroughAdjustedRequest<T>(); return o.lift(op).onBackpressureBuffer().doOnRequest(new Action1<Long>() { @Override public void call(Long n) { op.requestMore(n); } }); } });
private Observable<CaravanHttpResponse> createServletClientResponse(Context ctx, Observable<CaravanHttpResponse> ribbonResponse) { Observable<CaravanHttpResponse> localhostResponse = servletClient.execute(ctx.request) .lift(new ErrorDisassembleroperator(ctx, ribbonResponse)); return addHystrixAndErrorMapperAndMetrics(ctx, localhostResponse); }