public static void main(String... args) { /* * retry(n) can be used to immediately retry n times */ Observable.create(s -> { System.out.println("1) subscribing"); s.onError(new RuntimeException("1) always fails")); }).retry(3).subscribe(System.out::println, t -> System.out.println("1) Error: " + t)); System.out.println(""); /* * retryWhen allows custom behavior on when and if a retry should be done */ Observable.create(s -> { System.out.println("2) subscribing"); s.onError(new RuntimeException("2) always fails")); }).retryWhen(attempts -> { return attempts.zipWith(Observable.range(1, 3), (n, i) -> i).flatMap(i -> { System.out.println("2) delay retry by " + i + " second(s)"); return Observable.timer(i, TimeUnit.SECONDS); }).concatWith(Observable.error(new RuntimeException("Failed after 3 retries"))); }).toBlocking().forEach(System.out::println); } }
@OnClick(R.id.btn_eb_retry) public void startRetryingWithExponentialBackoffStrategy() { _logs = new ArrayList<>(); _adapter.clear(); _subscriptions.add(// Observable// .error(new RuntimeException("testing")) // always fails .retryWhen(new RetryWithDelay(5, 1000))// .doOnSubscribe(new Action0() { @Override public void call() { _log("Attempting the impossible 5 times in intervals of 1s"); } })// .subscribe(new Observer<Object>() { @Override public void onCompleted() { Timber.d("on Completed"); } @Override public void onError(Throwable e) { _log("Error: I give up!"); } @Override public void onNext(Object aVoid) { Timber.d("on Next"); } })); }
}).retryWhen(attempts -> { return attempts.zipWith(Observable.range(1, 3), (throwable, i) -> i) .flatMap(i -> {
/** * Wrap an {@link Observable} so that it will retry on some errors. The retry will occur for a maximum number of * attempts and with a provided {@link Delay} between each attempt represented by the {@link RetryWithDelayHandler}, * which can also filter on errors and stop the retry cycle for certain type of errors. * * @param source the {@link Observable} to wrap. * @param handler the {@link RetryWithDelayHandler}, describes maximum number of attempts, delay and fatal errors. * @param <T> the type of items emitted by the source Observable. * @return the wrapped retrying Observable. */ public static <T> Observable<T> wrapForRetry(Observable<T> source, final RetryWithDelayHandler handler) { return source.retryWhen(new RetryWhenFunction(handler)); }
@Override public void startReplication() { if (stateRef.compareAndSet(STATE.Idle, STATE.Replicating)) { // TODO better retry func? connection.getRetryableLifecycle() .retryWhen(new RetryStrategyFunc(retryWaitMillis)) .subscribe(replicationSubscriber); } }
public static <T> Observable.Transformer<T, T> applySchedulersWithToken() { return tObservable -> tObservable .subscribeOn(Schedulers.io()) .observeOn(Schedulers.io()) .onErrorResumeNext(errorResumeFunc()) .retryWhen(new RetryWhenNetworkException()) .observeOn(AndroidSchedulers.mainThread()); }
@Nonnull @Override public Observable<RxObjectEvent> connection() { return sockets.webSocketObservable() .retryWhen(repeatDuration(1, TimeUnit.SECONDS)); }
@Override public void loadCalendarEvents(int updateDelay, Subscriber<String> subscriber) { compositeSubscription.add(Observable.interval(0, updateDelay, TimeUnit.MINUTES) .flatMap(ignore -> googleCalendarService.getCalendarEvents()) .retryWhen(Observables.exponentialBackoff(AMOUNT_OF_RETRIES, DELAY_IN_SECONDS, TimeUnit.SECONDS)) .observeOn(AndroidSchedulers.mainThread()) .subscribeOn(Schedulers.io()) .unsubscribeOn(Schedulers.io()) .subscribe(subscriber)); }
@Override public void loadTopRedditPost(String subreddit, int updateDelay, Subscriber<RedditPost> subscriber) { compositeSubscription.add(Observable.interval(0, updateDelay, TimeUnit.MINUTES) .flatMap(ignore -> redditService.getApi().getTopRedditPostForSubreddit(subreddit, Constants.REDDIT_LIMIT)) .flatMap(redditService::getRedditPost) .retryWhen(Observables.exponentialBackoff(AMOUNT_OF_RETRIES, DELAY_IN_SECONDS, TimeUnit.SECONDS)) .observeOn(AndroidSchedulers.mainThread()) .subscribeOn(Schedulers.io()) .unsubscribeOn(Schedulers.io()) .subscribe(subscriber)); }
@Override public void loadWeather(String location, boolean celsius, int updateDelay, String apiKey, Subscriber<Weather> subscriber) { final String query = celsius ? Constants.WEATHER_QUERY_SECOND_CELSIUS : Constants.WEATHER_QUERY_SECOND_FAHRENHEIT; compositeSubscription.add(Observable.interval(0, updateDelay, TimeUnit.MINUTES) .flatMap(ignore -> forecastIOService.getApi().getCurrentWeatherConditions(apiKey, location, query)) .flatMap(response -> forecastIOService.getCurrentWeather(response, weatherIconGenerator, application, celsius)) .retryWhen(Observables.exponentialBackoff(AMOUNT_OF_RETRIES, DELAY_IN_SECONDS, TimeUnit.SECONDS)) .observeOn(AndroidSchedulers.mainThread()) .subscribeOn(Schedulers.io()) .unsubscribeOn(Schedulers.io()) .subscribe(subscriber)); }
public static <T> Observable.Transformer<T, T> retryDelay(Action1<Attempt> onAttempt, int maxRetry) { return o -> o.retryWhen(attempts -> attempts .zipWith(Observable.range(1, maxRetry), (err, i) -> new Attempt(i, err)) .flatMap((Attempt x) -> { if (x.idx > maxRetry) return error(x.err); onAttempt.call(x); return timer(min(x.idx * x.idx, MAX_RETRY_TIME), SECONDS); })); }
@Override public void call(Pipeline pipeline) { if (enabled) { log.warn("Triggering {} due to {}", pipeline, pipeline.getTrigger()); counter.increment("orca.requests"); createTriggerObservable(pipeline) .retryWhen(new RetryWithDelay(retryCount, retryDelayMillis)) .subscribe(this::onOrcaResponse, throwable -> onOrcaError(pipeline, throwable)); } else { log.info("Would trigger {} due to {} but triggering is disabled", pipeline, pipeline.getTrigger()); } }
public void init() { Observable<InstanceInfo> selfInfoStream = resolve().distinctUntilChanged(); subscription = connect(selfInfoStream).retryWhen(new RetryStrategyFunc(500)).subscribe(); }
private Observable<DocumentServiceResponse> doReplace(RxDocumentServiceRequest request) { Observable<DocumentServiceResponse> responseObservable = Observable.defer(() -> { try { return this.gatewayProxy.doReplace(request).doOnNext(response -> { this.captureSessionToken(request, response); }); } catch (Exception e) { return Observable.error(e); } }).retryWhen(createExecuteRequestRetryHandler(request)); return createPutMoreContentObservable(request, HttpConstants.HttpMethods.PUT) .doOnNext(r -> applySessionToken(request)).flatMap(req -> responseObservable); }
private <T> Observable<T> handleRestart(final Observable<T> observable) { return observable.retryWhen(o -> o.compose(zipWithFlatMap("retry"))).repeatWhen(o -> o.compose(zipWithFlatMap("repeat"))); }
@Test public void test() { Observable.error(new IOException()) .retryWhen(new RetryWhenObservable(5, 1)) .test() .awaitTerminalEvent() .assertFailure(IOException.class); } }
@Test public void sample_74() throws Exception { risky() .timeout(1, SECONDS) .retryWhen(failures -> failures .zipWith(Observable.range(1, ATTEMPTS), (err, attempt) -> attempt < ATTEMPTS ? Observable.timer(1, SECONDS) : Observable.error(err)) .flatMap(x -> x) ); }
@Test public void sample_89() throws Exception { risky() .timeout(1, SECONDS) .retryWhen(failures -> failures .zipWith(Observable.range(1, ATTEMPTS), this::handleRetryAttempt) .flatMap(x -> x) ); }
@Test public void sample_66() throws Exception { risky() .timeout(1, SECONDS) // .retryWhen(failures -> failures.take(10)) .retryWhen(failures -> failures.delay(1, SECONDS)); }
@Test public void sample_28() throws Exception { Observable<String> retried = new BlockingCmd() .toObservable() .doOnError(ex -> log.warn("Error ", ex)) .retryWhen(ex -> ex.delay(500, MILLISECONDS)) .timeout(3, SECONDS); }