ParseInstallation crashes

[bcbeta]

I am getting a lot of crashes related to updating ParseInstallation.
crash.txt
crash2.txt

I can post code where I update the ParseInstallation but the crash reports don't seem to pinpoint the origin of the crashes.

[cbaker6]

Yes, can you post the code for when/how you are updating? Are you using the latest version. All saves to installation go synchronously to the Keychain, it seems like you might be saving on different threads, causing an issue somehow.

I’m assuming you only have a few places where you are updating the installation. You can try to wrap to wrap those in a DispatchQueue.main.async closure to see if that fixes the issue.

[bcbeta]

If the save function is called asynchronously, I'm not sure I understand how dispatching to main will help?

            if var currentInstallation = Installation.current, let name = state.name
            {
                currentInstallation.homeState = name
                DispatchQueue.main.async {
                    currentInstallation.save { results in
                        switch results {
                        case .success(let updatedInstallation):
                            print("Successfully saved Installation to ParseServer: \(updatedInstallation)")
                        case .failure(let error):
                            print("Failed to update installation: \(error)")
                        }
                    }
                }
            }

[cbaker6]

I'm not sure I understand how dispatching to main will help?

It matters where you are calling your code from. You will need to provide more information.

This is the only code that updates the Installation? Where is it being called and how often does it get called? Can you also post your complete ParseInstallation?

Also, what version of the SDK are you using?

[bcbeta]

I released an update 3 days ago with ParseSwift 4.16.2 and still getting the same crashes. Here is all the code that saves the ParseInstallation (apologies for the messy code, I am self-taught and this app has been a work in progress over 7 years):

Updating from objC in the AppDelegate (called from didFinishLaunchingWithOptions):

        coreDataController.loadSharedStore(withCompletionHandler: { error in
...
                            User.loginUsingObjCKeychain(completion: { result in
                                print(result)
                                
                                let objCConfiguration = ParseClientConfiguration { config in
                                    config.applicationId = "***"
                                    config.clientKey = "***"
                                    config.server = "https://parseapi.back4app.com/"
                                }
                                
                                Parse.initialize(with: objCConfiguration)
                                if let installationId = PFInstallation.current()?.objectId {
                                    Task {
                                        do {
                                            _ = try await Installation.become(installationId)
                                            print("updated installation")
                                            
                                        } catch {
                                            
                                            print(error)
                                        }
                                    }
                                }
                            })

Registering for notifications:

  func application(_ application: UIApplication,
                    didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
       createInstallationOnParse(deviceTokenData: deviceToken)
   }
       
   func createInstallationOnParse(deviceTokenData:Data){
       if var installation = Installation.current{
           installation.setDeviceToken(deviceTokenData)
           if let currentUser = User.current {
               installation.user = currentUser
           }
           let userDefaults = UserDefaults.standard
           if userDefaults.object(forKey: kHomeState) != nil {
               installation.homeState = userDefaults.string(forKey: kHomeState) ?? ""
           }
               installation.save { results in
                   switch results {
                   case .success(let updatedInstallation):
                       print("Successfully saved Installation to ParseServer: \(updatedInstallation)")
                   case .failure(let error):
                       print("Failed to update installation: \(error)")
                   }
               }
       }
   }
   

Updating installation after making purchase with RevenueCat

            Purchases.shared.purchase(package: annualSubscriptionPackage, completion: { (transaction, purchaserInfo, error, userCancelled) in
                if let purchaserInfo = purchaserInfo, let entitlement = purchaserInfo.entitlements["pro"] {
                    if entitlement.isActive == true {
                        self.subscriptionStatus = .active
                        if var currentInstallation = Installation.current
                        {
                             ...
                            currentInstallation.expirationDate = entitlement.expirationDate
                            currentInstallation.subscriptionDate = entitlement.originalPurchaseDate
                                currentInstallation.save { results in
                                    switch results {
                                    case .success(let updatedInstallation):
                                        print("Successfully saved Installation to ParseServer: \(updatedInstallation)")
                                    case .failure(let error):
                                        print("Failed to update installation: \(error)")
                                    }
                                }
                        }
                        if completionBlock != nil
                        {
                            completionBlock!(true)
                        }
                        return
                    }
                }
                if completionBlock != nil
                {
                    completionBlock!(false)
                }
            })

After user logs in (adapted from SnapCat onboarding):

  @MainActor
    func completeOnboarding() {
        Self.setDefaultACL()
        saveInstallation()
        registerForNotifications()
        isLoggedOut = false
    }

    func saveInstallation() {
        // Setup installation to receive push notifications
        guard var currentInstallation = Installation.current else {
            return
        }
        currentInstallation.user = User.current
        currentInstallation.channels = ["global"] // Subscribe to particular channels
        let installation = currentInstallation
        Task {
            do {
                let installation = try await installation.save()
                Logger.installation.debug("""Parse Installation saved, can now receive push notificaitons. \(installation, privacy: .private)""")
            } catch {
                Logger.installation.debug("Error saving Parse Installation saved: \(error.localizedDescription)")
            }
        }
    }

Updating the users home state and saving to installation:

    func stateSelected(_ stateObjectID: NSManagedObjectID) {
        let coreDataController = CoreDataController.shared()
        let viewContext: NSManagedObjectContext = coreDataController.viewContext
        if let state = try? viewContext.existingObject(with: stateObjectID) as? State
        {
            if var currentUser = User.current{
                if let name = state.name {
                    currentUser.homeState = name
                }
                currentUser.save{result in}
            }
            if var currentInstallation = Installation.current, let name = state.name
            {
                currentInstallation.homeState = name
                    currentInstallation.save { results in
                        switch results {
                        case .success(let updatedInstallation):
                            print("Successfully saved Installation to ParseServer: \(updatedInstallation)")
                        case .failure(let error):
                            print("Failed to update installation: \(error)")
                        }
                    }
            }
            NotificationCenter.default.post(name: NSNotification.Name("HomeStateChanged"), object: state.objectID)
        }
    }
    

[cbaker6]

An improvement to your code which may fix your crash and have the functionality you desire is below (I didn't test this, but looks close enough):

Task {
  do {
    _ = try await User.loginUsingObjCKeychain()
    let objCConfiguration = ParseClientConfiguration { config in
                                    config.applicationId = "***"
                                    config.clientKey = "***"
                                    config.server = "https://parseapi.back4app.com/"
    }
    Parse.initialize(with: objCConfiguration)
    guard let installationId = PFInstallation.current()?.objectId,
       installationId != Installation.current?.objectId else {
      // Already migrated Installation
      return                               
    }
    do {
      _ = try await Installation.become(installationId)
      print("updated installation")                                        
    } catch {
      // Handle installation error                                      
      print(error)
    }
  } catch {
    // Handle login error
  }
}

[cbaker6]

The issue I believe you are having is you keep migrating where I put // Already migrated Installation. A migration should ever only occur one time.

[bcbeta]

I do check the app version so the migration is only called once when updating from an older objC version. I will give your code a try.

I'm also wondering if the issue could be that the migration occurs while the ParseInstallation is being modified elsewhere (registering for notifications for example)?

[cbaker6]

From skimming the rest of your code, your updates to the Installation for notifications seem correct...

Other potential issues I see that could still cause the crash you mentioned is that you are making "many" updates to the Installation when you probably shouldn't. An Installation is per device, and IMO, you should treat it for meaning, "an individual installation of your app on a device". A user can delete and reinstall your app which technically should create a new "installation". I recommend saving items like "purchases" and others in your example to a different Parse table (not User, this will have the same issues as Installation) which is a better architecture design for Parse. If you want to link "purchases" or to "users" or "installations", you add properties for them:

  struct Purchase: ParseObject {
    ...
    var item: String?
    var user: User?
    var installation: Installation?
  }

Lastly, I see CoreData references in your code which means you probably have some form of local storage. CoreData typically runs and returns on background threads which are slower. Here, the original problem/solution I mentioned comes into play with User and Installation (you may not have to worry about this as much if you use the Purchase object I suggested) as you are starting on a background queue and returning to a different. You can either dispatch back to the main like I suggested previously, or you can use the callbackQueue each ParseSwift save/update provides to return to the current queue.

[cbaker6]

I'm also wondering if the issue could be that the migration occurs while the ParseInstallation is being modified elsewhere (registering for notifications for example)?

Though this can be the culprit, updates to the deviceToken in app delegate are not frequent from my experience. I suspect your other code from the looks of it updates a lot more frequently.

[bcbeta]

Ok this all makes sense. I'm pretty sure I followed an old Parse tutorial saving the User and Purchase info in the installation, but it makes sense not to do that. I will strip out all the extraneous updates and see if that resolves the crashes. Thanks so much for your help again!

[bcbeta]

I removed most of my ParseInstallation saves and am no longer getting this crash (although it seems less than ideal that updating and saving the installation causes a crash?). I am getting some similar looking crashes with ParseUser. I update the ParseUser in numerous classes so it would be difficult to pinpoint where this is coming from (crash report attached).

2023-01-05_11-24-25.3129_-0700-9355e523b9043dd47dfa334345eb3ea27b4c1524.txt

[cbaker6]

I'm not able to tell what's causing your crash and I haven't seen this replicated on my side.

I will mention that the test suite has 1500+ tests that makes various updates/deletes to the User and Installation in the keychain asynchronously. Since I’ve never seen this error show up the test-suite either, I believe your problem has something to do with your code structure. If you can you can replicate your problem in the test suite, I will take a closer look.

[cbaker6]

For those running into this issue, #45 should address the problem.

[cbaker6]

So I have managed to replicate this in one of my apps. Some details about my app that may be similar to yours: it was an older app (originally designed for iOS9 that has been upgraded to the latest Swift), it still depends on the older AppDelegate life-cycle instead of the new SwiftUI life-cycle. I didn't see the problem until I updated to using SceneDelegate, before, it worked without issue with 5.0.0.beta.2. My guess is the SceneDelegate addition to apps modified the entry point for AppDelegate and it's causing issues. I haven't seen this issue at all any of SwiftUI life-cycle based apps.

To remedy the crashes, I added some delays in the AppDelegate calls that are related to accessing ParseInstallation and ParseUser. For example, based on your code:

func application(_ application: UIApplication,
                     didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        // If you have other calls coming from AppDelegate related the ParseInstallation and ParseUser, you should stagger the delay, next one would be .now()+4
        DispatchQueue.main.asyncAfter(.now() + 3) {
          createInstallationOnParse(deviceTokenData: deviceToken)
        }
}

@MainActor // This will ensure the save returns to the main queue
func createInstallationOnParse(deviceTokenData:Data){
    Task{
        if var installation = Installation.current {
            installation.setDeviceToken(deviceTokenData)
            do {
                _ = try await installation.save()
            }
            catch {
                print(error)
            }
        }
    }
}

Another way (works, but probably not preferred) is to use synchronous networking calls in your AppDelegate calls related to ParseInstallation and ParseUser:

func createInstallationOnParse(deviceTokenData:Data){
    if var installation = Installation.current{
        installation.setDeviceToken(deviceTokenData)
            do {
                _ = try installation.save()
            }
            catch {
                print(error)
            }
    }
}

Lastly, you didn't show in which part of the AppDelegate you are initializing the Swift SDK. The Swift SDK should be initialized on the main queue and well before any calls began to be made to the Parse Keychain (basically any Parse.current calls). If you are doing this on a background queue or accessing around the same time as initialization, it could be contributing to your crashes.

[bcbeta]

My app is an older project updated to Swift. It uses AppDelegate but not SceneDelegate. I will add the pause and see if that resolves the issue.

Parse is initialized here:

func application(_ application: UIApplication, willFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
        try? ParseSwift.initialize(applicationId: "***", clientKey: "***", serverURL: URL(string: "https://parseapi.back4app.com/")!)

[bcbeta]

I'm looking forward to trying 5.0. I have still been getting crashes on Installation and User.save()

[cbaker6]

@bcbeta 5.0.1 will definitely fix the issue. The problem was AppDelegate and other parts of your app may fire asynchronously and attempt to access objects in the Parse Keychain (User.current() or Installation.current()) before the ParseSwift SDK has finished initialization. 5.0.1 will automatically suspend any queue attempting to access .current() until the SDK finishes initialization. After initialization, all calls to .current() will resume in their respective context.

The only way to do this properly in older versions of ParseSwift is to add a flag to your app that changes from false to true when the initialization function finishes (tedious). You would then have to check that flag before accessing .current. Note, this should only be an issue if you had code that didn't wait on ParseSwift to finish its synchronous initialization, such as in your case. You can also move the ParseSwift SDK initialization to an earlier part of AppDelegate (or earliest part of your app) that fires earlier in hopes that the initialization completes before your code randomly calls .current.

[cbaker6]

@ellekadfur you are using the old repo which is out-of-date and I don’t support. If you would like help you will need to migrate to this repo (you should have another github notification), upgrade to the latest version, and open an issue/discussion if you are still running into problems