Parallel URLSession requests w/ DispatchGroup call completion handler twice on 1 request

Question

Using DispatchGroup I am trying to run 2 network requests against my client, returning the results when both have completed.

I am having an issue in that sometimes the completion handler for one of DispatchGroup requests is called twice and the other is not called at all.

An example would be -

    func fetchProfileWithRelatedArticle(onSuccess: @escaping (User, [RelatedArticle]) -> Void, onError: @escaping (Error) -> Void) {
        let dispatchGroup = DispatchGroup()

        var user: User?
        var articles: [RelatedArticle] = []

        var errors: [Error] = []

        dispatchGroup.enter()
        fetchProfileForUser(onSuccess: {
            user = $0
            print("fetchProfile:",$0)
            print("123")
            dispatchGroup.leave()
        }, onError: { error in
            errors.append(error)
            dispatchGroup.leave()
        })

        dispatchGroup.enter()
        getArticlesForUser(onSuccess: {
            articles = $0
            print("getArticlesForUser:",$0)
            print("456")
            dispatchGroup.leave()
        }, onError: { error in
            errors.append(error)
            dispatchGroup.leave()
        })

        dispatchGroup.notify(queue: .main) {
            guard let user = user, errors.isEmpty else { return }

            onSuccess(user, articles)
        }
    }

Here I fetch a user profile and also fetch a list of articles they have written. These are returned via a completion handler and presented elsewhere.

Most of the time this works, however it appears on occasion either one of those requests will call its own completion handler twice and the other request wont.

I suspect this may be down to when my access token expires as it occurs if I leave the app for a short time. My access token has a life of 2 minutes.

Should a request receive a 401 response, I have the following method in my network client that requests a new token, then invokes the call again. I believe this may not be working as I'd like.

            if response.statusIs401() {
                self?.refreshHandler { success in
                    guard success else { completion(.failure(TokenError.refused)); return }
                    self?.request(resource, completion)
                }
                return
            }

I suspect calling the method again after the update is doing something to the requests my dispatch group is returning.

Is it possible to chain requests in this fashion?

struct NoContent: Codable { }
typealias RefreshHandler = (@escaping (Bool) -> Void) -> ()
typealias TokenGetter = () -> [String: String]

protocol ClientType: class {
    associatedtype Route: RouterType
    func request<T: Codable>(_ resource: Route, _ completion: @escaping  (Result<T>)-> Void)
}

class Client<Route: RouterType>: ClientType {

    enum APIError: Error {
        case unknown, badResponse, jsonDecoder, other
    }

    enum TokenError: String, Error {
        case expired = "Access Token Expired"
        case refused = "Refresh Token Failed"
    }

    private(set) var session: SessionType
    private(set) var tokenGetter: TokenGetter
    private(set) var refreshHandler: RefreshHandler

    private lazy var decoder: JSONDecoder = {
        let decoder = JSONDecoder()
        decoder.dateDecodingStrategy = .iso8601withFractionalSeconds
        return decoder
    }()

    init(session: SessionType, tokenGetter: @escaping TokenGetter, refreshHandler: @escaping RefreshHandler) {
        self.session = session
        self.tokenGetter = tokenGetter
        self.refreshHandler = refreshHandler
    }

    func request<T: Codable>(_ resource: Route, _ completion: @escaping  (Result<T>)-> Void) {

        let request = URLRequest(
            resource: resource,
            headers: tokenGetter()
        )

        URLSession.shared.dataTask(with: request) { [weak self] data, response, error in
            guard error == nil else { completion(.failure(APIError.unknown)); return }
            guard let response = response as? HTTPURLResponse else { completion(.failure(APIError.badResponse)); return }

            if response.statusIs401() {
                self?.refreshHandler { success in
                    guard success else { completion(.failure(TokenError.refused)); return }
                    self?.request(resource, completion)
                }
                return
            }

            if response.statusIsSuccess() {
                guard let self = self, let data = self.deserializeNoContentResponse(data: data) else { completion(.failure(APIError.badResponse)); return }
                do {
                    let value = try self.decoder.decode(T.self, from: data)
                    DispatchQueue.main.async {
                        completion(.success(value))
                    }
                } catch let error {
                    print(error)
                }
                return
            }

            completion(.failure(APIError.other))
        }.resume()
    }

    // some calls return a 200/201 with no data
    private func deserializeNoContentResponse(data: Data?) -> Data? {

        if data?.count == 0 {
            return "{ }".data(using: .utf8)
        }

        return data
    }
}

Answer 1

Sounds like you would need to something like the following in your networking client:

func makeTheRequest(_ completion: CompletionHandler) {
  URLSession.shared.dataTask(with: someURL) { data, response, error in 
    guard let httpResponse = response as? HTTPURLResponse else {
      return
    }

    if httpResponse.statusCode == 401 {
      self.refreshToken { success in
        if success { self.makeTheRequest(completion) }
      }
    }

    // handle response
    completion(whateverDataYouNeedToPass)
  }
}

That would make the call, check the response code, refresh the token is needed and if that succeeds it calls the method that should make the response again with the completion handler that was passed to in the first place without calling it first. So the completion handler wouldn't be called until after the API call is made the second time.

Of course, adopt this for your own code, shouldn't be too hard to do