Throwing a non-IOException from an OkHttp interceptor cancels a call without an event on the Rx stream

If a non-IOException-derived exception is thrown from an OkHttp interceptor, an RxJava3 call adapter stalls indefinitely and does not signal the exception downstream. (This used to work with the RxJava2 call adapter.)

This is a quick reproducer: https://gist.github.com/realdadfish/c7c0d8cb123c583acd3e683b68afbfa5

The current workaround is to simply make all custom exceptions thrown from within interceptors derive from IOException.

Retrofit: 2.9.0 OkHttp: 4.8.1 RxJava: 3.0.6

[realdadfish]

Also, I think the real culprit is really okhttp, look at the implementation of RealCall.java:

  @Override protected void execute() {
      boolean signalledCallback = false;
      transmitter.timeoutEnter();
      try {
        Response response = getResponseWithInterceptorChain();
        signalledCallback = true;
        responseCallback.onResponse(RealCall.this, response);
      } catch (IOException e) {
        if (signalledCallback) {
          // Do not signal the callback twice!
          Platform.get().log(INFO, "Callback failure for " + toLoggableString(), e);
        } else {
          responseCallback.onFailure(RealCall.this, e);
        }
      } catch (Throwable t) {
        cancel();       // <-- this is IMHO too early
        if (!signalledCallback) {
          IOException canceledException = new IOException("canceled due to " + t);
          canceledException.addSuppressed(t);
          responseCallback.onFailure(RealCall.this, canceledException);
        }
        throw t;
      } finally {
        client.dispatcher().finished(this);
      }

and here of the CallEnqueueObservable.java where it exits after it realizes the call is already canceled:

 @Override
    public void onFailure(Call<T> call, Throwable t) {
      if (call.isCanceled()) return;          // <-- yeah, we're canceled and do not process the error, leading to an indefinite open stream

      try {
        observer.onError(t);
      } catch (Throwable inner) {
        Exceptions.throwIfFatal(inner);
        RxJavaPlugins.onError(new CompositeException(t, inner));
      }
    }

[YaowenGuo]

If a non-IOException-derived exception is thrown from an OkHttp interceptor, an RxJava3 call adapter stalls indefinitely and does not signal the exception downstream. (This used to work with the RxJava2 call adapter.)

This is a quick reproducer: https://gist.github.com/realdadfish/c7c0d8cb123c583acd3e683b68afbfa5

The current workaround is to simply make all custom exceptions thrown from within interceptors derive from IOException.

Retrofit: 2.9.0 OkHttp: 4.8.1 RxJava: 3.0.6

@realdadfish

I think this error is not caused by retrofit or OkHttp. I have seen several version OkHttp and Retrofit. They all not catch non-IoException derived exception, Because OkHttp only throw IOException internal. It is cased by RxJava adapter. When use Retrofit.Builder().addCallAdapterFactory(RxJava3CallAdapterFactory.create()) to execute network call. it will call subscribeActual() function in CallEnqueueObservable. It not catch non-IoException derived exception thrown by OkHttp.

  @Override
  protected void subscribeActual(Observer<? super Response<T>> observer) {
    // Since Call is a one-shot type, clone it for each new observer.
    Call<T> call = originalCall.clone();
    CallCallback<T> callback = new CallCallback<>(call, observer);
    observer.onSubscribe(callback);
    if (!callback.isDisposed()) {
      call.enqueue(callback);  // <---------not catch other exception.
    }
  }

You can use RxJava3CallAdapterFactory.createWithScheduler() or RxJava3CallAdapterFactory.createSynchronous() like this.

val retrofit = Retrofit.Builder()
      .client(okhttp)
      .addCallAdapterFactory(RxJava3CallAdapterFactory.createSynchronous())
       // Or 
       // .addCallAdapterFactory(RxJava3CallAdapterFactory.createWithScheduler(Schedulers.io()))
      .baseUrl(server.url("/"))
      .build()

It will use CallExecuteObservable to execute http request. It will catch the non-IoException derived exception and call Rxjava downstream’s onError function.

  protected void subscribeActual(Observer<? super Response<T>> observer) {
   ...
    try {
      Response<T> response = call.execute();
      ...
    } catch (Throwable t) {
      Exceptions.throwIfFatal(t);
      if (terminated) {
        ...
      } else if (!disposable.isDisposed()) {
        try {
          observer.onError(t);
        } catch (Throwable inner) {
          ...
        }
      }
    }
  }