Intercept error in OAuth flow

[sorenu]

I am working against a backend which uses OAuth. I use a short-lived access token to request resources. When the token has expired I will receive an error response from the server. When receiving that error I must use a refresh token to send a request for a new access token. When I have the new token I can repeat the resource request.

My API calls are all RACSignals which I subscribe to to fetch resources. My problem is how to prevent the error received from the expired token request to propagate to the subscriber. In stead I want to intercept the error and send a new request to refresh the token and then use the new token to repeat the original request.

My current implementation looks something like this:

- (RACSignal *)fetchResource {
    RACSignal *requestSignal = [RACSignal createSignal:^RACDisposable *(id <RACSubscriber> subscriber) {
        // Do network request
        return nil;
    }];

    return [self tokenValidationWrapper:requestSignal];
}

- (RACSignal *)tokenValidationWrapper:(RACSignal *)requestSignal {
    [requestSignal subscribeError:^(NSError *error) {
        if (/*Error due to expired token*/) {
            [[self refreshToken] subscribeNext:^(id x) {
                // Send original request
                // Obviously this does not work because requestSignal has been terminated at this point
                [requestSignal subscribeNext:^(id x) {

                }];
            } error:^(NSError *err) {
                // Send error to subscriber of requestSignal
            }];
        } else {
            // Send error to subscriber of requestSignal
        }
    }];
    return [requestSignal replayLazily];
}

What would be the preferred way to implement this sort of conditional signal?

[joshaber]

This is such a great example for RAC. It'd be something like:

- (RACSignal *)tokenValidationWrapper:(RACSignal *)requestSignal {
    return [requestSignal catch:^(NSError *error) {
        // Catch the error, refresh the token, and then do the request again.
        return [[[self refreshToken] ignoreValues] concat:requestSignal];
    }];
}

So long as requestSignal is a cold signal (i.e., it does something on subscription, created using +createSignal: or +defer:), that -concat: will cause the request to be done again, after the token is refreshed.

[robb]

I'm totally going to steal this as an example for my talk 💖

[sorenu]

That works perfectly!

Thank you for your help and your great work with ReactiveCocoa.

[kkazuo]

Very impressive.
I had been wondering that why a signal invokes his block at every subscriptions.
I got the answer.
Thank you.

[sorenu]

@joshaber We just made a blog post about this issue. Have a look here: http://codeblog.shape.dk/blog/2013/12/02/transparent-oauth-token-refresh-using-reactivecocoa/

Once again, thanks for your help.

[SergeyBulyno]

@joshaber, is this example should work if I use [RACSignal combineLatest:@[ [api fetchResource:a], [api fetchResource:b]]]; or use [api fetchResource:a] and [api fetchResource:a] to kick off multiple simultaneous requests and that they will all implicitly wait for the token to be refreshed?
Thank you in advance.

[askarimov]

@sorenu, could you provide a sample code for [self refreshToken]. In my app, I am using your code from the blog, but cant do the request again with new access token. Thanks

[Doraemoe]

I'm new to ReactiveCocoa, can anyone explain this code to me? In this code:

- (RACSignal *)tokenValidationWrapper:(RACSignal *)requestSignal {
    return [requestSignal catch:^(NSError *error) {
        // Catch the error, refresh the token, and then do the request again.
        return [[[self refreshToken] ignoreValues] concat:requestSignal];
    }];
}

why ignoreValues method is used? Moreover, to my understanding, this code will execute when an error want caught, and return a new signal that first do refreshtoken then do the orignal signal. However, what will this method return if no error was caught?