问可观察到的"retryWhen“延迟

EN

import {Http, Headers, Response} from '@angular/http';

http.get('http://jsonplaceholder.typicode.com/posts/1/commentsss')
    .retryWhen(e => e.scan<number>((errorCount, err) => {
        if (errorCount >= 10) {
            throw err;
        }
        return errorCount + 1;
    }, 0).delay(1000))
    .subscribe(r => console.log(`Sub: ${r}`))

// Class to intercept all network calls and retry for X number of times
export class ErrorInterceptor implements HttpInterceptor {
  //   private authService: UserAuthenticationService;
  private ngxLogger: NGXLogger;
  private errorHandlerService: ErrorHandlerService;
  constructor(injector: Injector) {
    this.ngxLogger = injector.get(NGXLogger);
    this.errorHandlerService = injector.get(ErrorHandlerService);
  }

  intercept(
    req: HttpRequest<any>,
    next: HttpHandler
  ): Observable<HttpEvent<any>> {


    const interceptObs$ = next.handle(req);
// you could filter for the URLS that this should be applied like this
    if (req.url.match(API_FETCH_TOKEN)) {
      let retryAttempts = 0;
      const httpInterceptor$ = interceptObs$.pipe(
        retryWhen(errorObs => {

          return errorObs.pipe(
            tap(errval => console.log(`Retrying because of err:${errval}`)),

            concatMap(errObsValue => {
              if (
                errObsValue instanceof HttpErrorResponse &&
                errObsValue.status != 404
              ) {
                console.log('inside concatMap', errObsValue);

                if (retryAttempts > APP_NET_RETRIES) {
                  return throwError(this.getErrorModel(errObsValue, req));
                } else {
                  retryAttempts++;
// this linearly increases the delay of attempts
                  delayWhen(() =>
                    timer(retryAttempts * APP_NET_RETRIES_DELAY * 1000)
                  );
                  return httpInterceptor$;
                }
              }
            })
          );
        })
      );
      return httpInterceptor$;
    } else {
      return interceptObs$;
    }
    // above is the notifier observable, with errors captured as input observable
    // so we could operate on this observable for retires
    // also make sure to return the error observable - i.e the notifier observable
    // reason being all errors should again be returned so as to capture them and
 // only when they are returned they can be retried
    // Also make sure after take() - no.of retries we just throw a last occuring error obs




  }

// I like to create a custom error model and handle that in Custom ErrorHandler
// Below is the sample implementation I use. but again this is your preference
// you can just rethrow the error alone
  async getErrorModel(errValue, req): Promise<ErrorModel> {
    const errModel = new ErrorModel();
    errModel.Error = errValue;
    errModel.ErrorMessage = 'Error in retrieving the token:' + errValue.message;
    errModel.ErrorStatus = 421;
    errModel.ErrorUrl = req.url;
    errModel.Timestamp = momentTimeZone
      .tz(DEFAULT_TIME_ZONE)
      .format(DEFAULT_TIME_ZONE);
    await this.errorHandlerService.handleError(errModel);
    return Promise.resolve(errModel);
  }
}

retryWhen(errors => errors.pipe(
  takeWhile((err, index) => {
    if (index === 3) throw new Error(err.toString());
    return true
  }),
  delay(1000),
))