docs: public <T> ListenableFuture<T> invokeAsync(Callable<ListenableFuture<T>> callable) throws Exception {
  
          final SettableListenableFuture<T> response = new SettableListenableFuture<T>();
          ListenableFutureCallback<T> callback = new ListenableFutureCallback<T>() {
              @Override
              public void onSuccess(T result) {
                  close();
                  response.set(result);
              }
  
              @Override
              public void onFailure(Throwable ex) {
                  try {
                      handleFailure(ex);
                  } catch (Exception e) {
                      response.setException(e);
                  }
              }
          };
  
          if (!byPass) {
              if (!allowRequest()) {
                  throw mapException(new CircuitBreakerException());
              }
  
              try {
                  isAttemptLive = true;
                  callable.call().addCallback(callback);
                  return response;
              } catch (Throwable cause) {
                  // This shouldn't happen because Throwables are handled in the async onFailure callback
                  handleFailure(cause);
              }
              throw new IllegalStateException("not possible");
          }
          else {
              callable.call().addCallback(callback);
              return response;
          }
      }