Check for schema version before client reset callbacks

CHANGELOG.md

@@ -5,7 +5,7 @@ x.y.z Release notes (yyyy-MM-dd)
 
 ### Fixed
 * <How to hit and notice issue? what was the impact?> ([#????](https://github.com/realm/realm-swift/issues/????), since v?.?.?)
-* None.
+* The client reset callbacks no longer attempt to open a realm without an initialized schema ([PR #8125](https://github.com/realm/realm-swift/pull/8125))
 
 <!-- ### Breaking Changes - ONLY INCLUDE FOR NEW MAJOR version -->
 

Realm/ObjectServerTests/RLMObjectServerTests.mm

@@ -27,18 +27,20 @@
 #import "RLMObjectSchema_Private.hpp"
 #import "RLMRealm+Sync.h"
 #import "RLMRealmConfiguration_Private.h"
+#import "RLMRealmConfiguration_Private.hpp"
 #import "RLMRealmUtil.hpp"
 #import "RLMRealm_Dynamic.h"
 #import "RLMRealm_Private.hpp"
 #import "RLMSchema_Private.h"
-#import "RLMSyncConfiguration_Private.h"
+#import "RLMSyncConfiguration_Private.hpp"
 #import "RLMSyncManager_Private.hpp"
 #import "RLMSyncUtil_Private.h"
 #import "RLMUser_Private.hpp"
 #import "RLMWatchTestUtility.h"
 
 #import <realm/object-store/shared_realm.hpp>
 #import <realm/object-store/sync/sync_manager.hpp>
+#import <realm/object-store/thread_safe_reference.hpp>
 #import <realm/util/file.hpp>
 
 #import <atomic>
@@ -1510,6 +1512,65 @@ - (void)testSetClientResetCallbacks {
 
 }
 
+- (void)testBeforeClientResetCallbackNotVersioned {
+ // Setup a realm with a versioned schema
+ RLMRealmConfiguration *config = [RLMRealmConfiguration defaultConfiguration];
+ config.fileURL = RLMTestRealmURL();
+ // Need to open the realm once to get a version.
+ @autoreleasepool {
+ RLMRealm *versioned = [RLMRealm realmWithConfiguration:config error:nil];
+ XCTAssertEqual(0U, versioned->_realm->schema_version());
+ }
+ std::shared_ptr<realm::Realm> versioned = realm::Realm::get_shared_realm(config.config);
+
+ // Create a config that's not versioned.
+ RLMRealmConfiguration *configUnversioned = [RLMRealmConfiguration defaultConfiguration];
+ configUnversioned.configRef.schema_version = RLMNotVersioned; // Not strictly necessary. Already has no version because the realm's never been opened.
+ std::shared_ptr<realm::Realm> unversioned = realm::Realm::get_shared_realm(configUnversioned.config);
+
+ XCTestExpectation *beforeExpectation = [self expectationWithDescription:@"block called once"];
+ beforeExpectation.assertForOverFulfill = true; // asserts that fulfill isn't called more than once.
+
+ realm::BeforeClientResetWrapper beforeWrapper = {
+ .block = ^(RLMRealm * _Nonnull beforeFrozen) {
+ XCTAssertNotEqual(RLMNotVersioned, beforeFrozen->_realm->schema_version());
+ [beforeExpectation fulfill];
+ }
+ };
+
+ XCTAssertNotEqual(versioned->schema_version(), RLMNotVersioned);
+ XCTAssertEqual(unversioned->schema_version(), RLMNotVersioned);
+ beforeWrapper(versioned); // one realm should invoke the block
+ beforeWrapper(unversioned); // while the other should not invoke the block
+
+ [self waitForExpectationsWithTimeout:5 handler:nil];
+}
+
+- (void)testAfterClientResetCallbackNotVersioned {
+ // Create a config that's not versioned.
+ RLMRealmConfiguration *configUnversioned = [RLMRealmConfiguration defaultConfiguration];
+ configUnversioned.configRef.schema_version = RLMNotVersioned; // Not strictly necessary. Already has no version because the realm's never been opened.
+ std::shared_ptr<realm::Realm> unversioned = realm::Realm::get_shared_realm(configUnversioned.config);
+
+ XCTestExpectation *afterExpectation = [self expectationWithDescription:@"block called once"];
+ afterExpectation.inverted = true;
+
+ #pragma clang diagnostic push
+ #pragma clang diagnostic ignored "-Wunused-parameter"
+ realm::AfterClientResetWrapper afterWrapper = {
+ .block = ^(RLMRealm * _Nonnull beforeFrozen, RLMRealm * _Nonnull after) {
+ [afterExpectation fulfill];
+ }
+ };
+ #pragma clang diagnostic pop // unused parameter warning
+
+ auto unversionedTsr = realm::ThreadSafeReference(unversioned);
+ XCTAssertEqual(unversioned->schema_version(), RLMNotVersioned);
+ afterWrapper(unversioned, std::move(unversionedTsr), false);
+
+ [self waitForExpectationsWithTimeout:1 handler:nil];
+}
+
 #pragma mark - Progress Notifications
 
 static const NSInteger NUMBER_OF_BIG_OBJECTS = 2;

Realm/RLMSyncConfiguration.h

@@ -120,7 +120,7 @@ typedef NS_ENUM(NSUInteger, RLMClientResetMode) {
  A block type used to report before a client reset will occur.
  The `beforeFrozen` is a frozen copy of the local state prior to client reset.
  */
-RLM_SWIFT_SENDABLE // invoked on a backgroun thread
+RLM_SWIFT_SENDABLE // invoked on a background thread
 typedef void(^RLMClientResetBeforeBlock)(RLMRealm * _Nonnull beforeFrozen);
 
 /**

Realm/RLMSyncConfiguration.mm

@@ -61,36 +61,31 @@ RLMSyncError errorKindForSyncError(SyncError error) {
  return RLMSyncErrorClientSessionError;
  return RLMSyncErrorClientInternalError;
 }
+} // anonymous namespace
 
-struct CallbackSchema {
- bool dynamic;
- std::string path;
- RLMSchema *customSchema;
+namespace realm {
 
- RLMSchema *getSchema(Realm& realm) {
- if (dynamic) {
- return [RLMSchema dynamicSchemaFromObjectStoreSchema:realm.schema()];
- }
- if (auto cached = RLMGetAnyCachedRealmForPath(path)) {
- return cached.schema;
- }
- return customSchema ?: RLMSchema.sharedSchema;
+RLMSchema *CallbackSchema::getSchema(Realm& realm) {
+ if (dynamic) {
+ return [RLMSchema dynamicSchemaFromObjectStoreSchema:realm.schema()];
  }
-};
+ if (auto cached = RLMGetAnyCachedRealmForPath(path)) {
+ return cached.schema;
+ }
+ return customSchema ?: RLMSchema.sharedSchema;
+}
 
-struct BeforeClientResetWrapper : CallbackSchema {
- RLMClientResetBeforeBlock block;
- void operator()(std::shared_ptr<Realm> local) {
- @autoreleasepool {
+void BeforeClientResetWrapper::operator ()(std::shared_ptr<realm::Realm> local) {
+ @autoreleasepool {
+ if (local->schema_version() != RLMNotVersioned) {
  block([RLMRealm realmWithSharedRealm:local schema:getSchema(*local) dynamic:false]);
  }
  }
-};
+}
 
-struct AfterClientResetWrapper : CallbackSchema {
- RLMClientResetAfterBlock block;
- void operator()(std::shared_ptr<Realm> local, ThreadSafeReference remote, bool) {
- @autoreleasepool {
+void AfterClientResetWrapper::operator()(std::shared_ptr<realm::Realm> local, realm::ThreadSafeReference remote, bool) {
+ @autoreleasepool {
+ if (local->schema_version() != RLMNotVersioned) {
  RLMSchema *schema = getSchema(*local);
  RLMRealm *localRealm = [RLMRealm realmWithSharedRealm:local
  schema:schema
@@ -102,7 +97,8 @@ void operator()(std::shared_ptr<Realm> local, ThreadSafeReference remote, bool)
  block(localRealm, remoteRealm);
  }
  }
-};
+}
+
 } // anonymous namespace
 
 @interface RLMSyncConfiguration () {

Realm/RLMSyncConfiguration_Private.hpp

@@ -20,16 +20,39 @@
 
 #import <functional>
 #import <memory>
+#import <string>
 
 namespace realm {
+class Realm;
 class SyncSession;
 struct SyncConfig;
 struct SyncError;
 using SyncSessionErrorHandler = void(std::shared_ptr<SyncSession>, SyncError);
+class ThreadSafeReference;
 }
 
 RLM_HEADER_AUDIT_BEGIN(nullability, sendability)
 
+namespace realm {
+
+struct CallbackSchema {
+ bool dynamic;
+ std::string path;
+ RLMSchema *customSchema;
+
+ RLMSchema *getSchema(realm::Realm& realm);
+};
+
+struct BeforeClientResetWrapper : CallbackSchema {
+ RLMClientResetBeforeBlock block;
+ void operator()(std::shared_ptr<realm::Realm> local);
+};
+struct AfterClientResetWrapper : CallbackSchema {
+ RLMClientResetAfterBlock block;
+ void operator()(std::shared_ptr<realm::Realm> local, realm::ThreadSafeReference remote, bool);
+};
+}
+
 @interface RLMSyncConfiguration ()
 
 - (instancetype)initWithRawConfig:(realm::SyncConfig)config path:(std::string const&)path;