Realm iOS: How to handle Client Reset

Question

Basically, I want to handle a case where any device got SyncError with type ClientResetError then, want my device to re-login to realm again. but as per documentation, we have to closeRealmSafely before I login to realm again, but I am not sure how to close realm safely.

I am going through the doc (https://docs.realm.io/sync/using-synced-realms/errors#client-reset) to handle client reset error and found it's very confusing . I want help to understand about the following code.

1. First there is no method available to closeRealmsafely. Please help me understand how can I close the realm safely?
2. How can I backup and when I will use it? Should I skip the reset error because in documentation it's mentions if the client reset process is not manually initiated, it will instead automatically take place after the next time the app is launched, upon first accessing the SyncManager singleton. It is the app’s responsibility to persist the location of the backup copy if needed, so that the backup copy can be found later."

Below is the error handler sample code from the doc.

 let syncError = error as! SyncError
 switch syncError.code {
 case .clientResetError:
 if let (path, clientResetToken) = syncError.clientResetInfo() {
 closeRealmSafely()
 saveBackupRealmPath(path)
 SyncSession.immediatelyHandleError(clientResetToken)
 }
 default:
 // Handle other errors...
 ()
 }
}```

Answer 1

Finally we figured out how to handle the client reset error. We have taken following steps To avoid the data loss incase user is offline and came online and got reset error.

1. Save the local realm to another directory

2. Invalidate and nil the realm

3. Initiate realm manual reset - Call SyncSession.immediatelyHandleError with clientResetToken passed and it will delete the existing realm from directory

4. Show client reset alert - This will intimate user to relaunch the app.

5. On next launch realm creates a fresh realm from ROS.

6. After new realm connects, restore the realm records (if any) from the old realm saved in backup directory above.

7. Delete the backup realm(old realm) from directory.

    switch syncError.code {
    case .clientResetError:
    if let (path, clientResetToken) = syncError.clientResetInfo() {
    // taking backup
    backUpRealm(realm: yourLocalRealm)
    // making realm nil and invalidating
    yourLocalRealm?.invalidate()
    yourLocalRealm = nil
   //Initiate realm manual reset  - Call `SyncSession.immediatelyHandleError` with `clientResetToken` passed and it will delete the existing realm from directory
    SyncSession.immediatelyHandleError(clientResetToken)
    // can show alert to user to relaunch the app
    showAlertforAppRelaunch()
    }
    default:
    // Handle other errors...
    ()
    }
   }```
   
   

The back up realm code look like this:

func backUpRealm(realm: Realm?) {
        do {
            try realm?.writeCopy(toFile: backupUrl)
        } catch {
            print("Error backing up data")
        }
    }

After doing this backup will be available at backup path. On next launch device will connect and download a fresh realm from ROS so after device connects restore the realm records from the backup realm saved in the backup path.

The restore merge backup code will look like this. place the below method when realm connects after relauch.The ```restoredRealm`` is fresh downloaded realm on launch

func restoreAndMergeFromBackup(restoredRealm: Realm?) {
        let realmBackUpFilePath = isRealmBackupExits()
        // check if backup exists or not
        if realmBackUpFilePath.exists {
            let config = Realm.Configuration(
                fileURL: URL(fileURLWithPath: realmBackUpFilePath.path),
                readOnly: true)
            
            let realm = try? Realm(configuration: config)
            
            guard let backupRealm = realm else { return }
            
            //Get your realm Objects
            let objects = backupRealm.objects(YourRealmObject.self)
            
           try? restoredRealm?.safeWrite {
        
                for object in objects {
                // taking local changes to the downloaded realm if it has
                    restoredRealm?.create(YourRealmObject.self, value: object, update: .modified)
                }

                self.removeRealmFiles(path: realmBackUpFilePath.path)
            }
        } else {
            debug("backup realm does not exists")
        }
    }
    
    private func isRealmBackupExits() -> (exists: Bool, path: String) {
        let documentsPath = URL(fileURLWithPath: NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0])
        
        let realmPathComponent =  documentsPath.appendingPathComponent("your_backup.realm")
        
        let filePath = realmPathComponent.path
        let fileManager = FileManager.default
        
        if fileManager.fileExists(atPath: filePath) {
            return (true, filePath)
        }
        
        return (false, "")
    }


    private func removeRealmFiles(path: String) {
        let realmURL = URL(fileURLWithPath: path)
        
        let realmURLs = [
            realmURL,
            realmURL.appendingPathExtension("lock"),
            realmURL.appendingPathExtension("realm"),
            realmURL.appendingPathExtension("management")
        ]
        for URL in realmURLs {
            do {
                try FileManager.default.removeItem(at: URL)
            } catch {
                debug("error while deleting realm urls")
            }
        }
    }```

In our testing we have found that there is a backup made by realm automatically so we deleted it for safety purpose. the path argument you will get in the if let (path, clientResetToken) = syncError.clientResetInfo()

func removeAutoGeneratedRealmBackUp(path: String) {
    do {
        try FileManager.default.removeItem(at: URL(fileURLWithPath: path))
    } catch {
        debug("error while deleting realm backUp path \(path)")
    }
}