Merge pull request #7576 from realm/tg/multi-process-launch-actions

RCORE-1900 Make "next launch" metadata actions multiprocess-safe

Author: tgoyne

CHANGELOG.md

@@ -2,7 +2,7 @@
 
 ### Enhancements
 * <New feature description> (PR [#????](https://github.com/realm/realm-core/pull/????))
-* None.
+* "Next launch" metadata file actions are now performed in a multi-process safe manner ([#7576](https://github.com/realm/realm-core/pull/7576)).
 
 ### Fixed
 * <How do the end-user experience this issue? what was the impact?> ([#????](https://github.com/realm/realm-core/issues/????), since v?.?.?)

src/realm/db.cpp

@@ -2860,20 +2860,27 @@ DBRef DB::create(BinaryData buffer, bool take_ownership) NO_THREAD_SAFETY_ANALYS
     return retval;
 }
 
-void DB::claim_sync_agent()
+bool DB::try_claim_sync_agent()
 {
     REALM_ASSERT(is_attached());
-    std::unique_lock<InterprocessMutex> lock(m_controlmutex);
+    std::lock_guard lock(m_controlmutex);
     if (m_info->sync_agent_present)
-        throw MultipleSyncAgents{};
+        return false;
     m_info->sync_agent_present = 1; // Set to true
     m_is_sync_agent = true;
+    return true;
+}
+
+void DB::claim_sync_agent()
+{
+    if (!try_claim_sync_agent())
+        throw MultipleSyncAgents{};
 }
 
 void DB::release_sync_agent()
 {
     REALM_ASSERT(is_attached());
-    std::unique_lock<InterprocessMutex> lock(m_controlmutex);
+    std::lock_guard lock(m_controlmutex);
     if (!m_is_sync_agent)
         return;
     REALM_ASSERT(m_info->sync_agent_present);

src/realm/db.hpp

@@ -432,6 +432,7 @@ class DB : public std::enable_shared_from_this<DB> {
     /// Mark this DB as the sync agent for the file.
     /// \throw MultipleSyncAgents if another DB is already the sync agent.
     void claim_sync_agent();
+    bool try_claim_sync_agent();
     void release_sync_agent();
 
     /// Returns true if there are threads waiting to acquire the write lock, false otherwise.

src/realm/object-store/impl/realm_coordinator.hpp

@@ -228,6 +228,11 @@ class RealmCoordinator : public std::enable_shared_from_this<RealmCoordinator>,
         return m_audit_context.get();
     }
 
+    bool try_claim_sync_agent()
+    {
+        return m_db->try_claim_sync_agent();
+    }
+
 private:
     friend Realm::Internal;
     Realm::Config m_config;

src/realm/object-store/sync/app.cpp

@@ -715,12 +715,11 @@ void App::get_profile(const std::shared_ptr<User>& user,
                     identities.push_back({get<std::string>(doc, "id"), get<std::string>(doc, "provider_type")});
                 }
 
-                if (auto data = m_metadata_store->get_user(user->user_id())) {
-                    data->identities = std::move(identities);
-                    data->profile = UserProfile(get<BsonDocument>(profile_json, "data"));
-                    m_metadata_store->update_user(user->user_id(), *data);
-                    user->update_backing_data(std::move(data));
-                }
+                m_metadata_store->update_user(user->user_id(), [&](auto& data) {
+                    data.identities = std::move(identities);
+                    data.profile = UserProfile(get<BsonDocument>(profile_json, "data"));
+                    user->update_backing_data(data); // FIXME
+                });
             }
             catch (const AppError& err) {
                 return completion(nullptr, err);
@@ -812,12 +811,11 @@ void App::log_in_with_credentials(const AppCredentials& credentials, const std::
             try {
                 auto json = parse<BsonDocument>(response.body);
                 if (linking_user) {
-                    if (auto user_data = m_metadata_store->get_user(linking_user->user_id())) {
-                        user_data->access_token = RealmJWT(get<std::string>(json, "access_token"));
-                        // maybe a callback for this?
-                        m_metadata_store->update_user(linking_user->user_id(), *user_data);
-                        linking_user->update_backing_data(std::move(user_data));
-                    }
+                    m_metadata_store->update_user(linking_user->user_id(), [&](auto& data) {
+                        data.access_token = RealmJWT(get<std::string>(json, "access_token"));
+                        // FIXME: should be powered by callback
+                        linking_user->update_backing_data(data);
+                    });
                 }
                 else {
                     auto user_id = get<std::string>(json, "user_id");
@@ -1338,11 +1336,10 @@ void App::refresh_access_token(const std::shared_ptr<User>& user, bool update_lo
             try {
                 auto json = parse<BsonDocument>(response.body);
                 RealmJWT access_token{get<std::string>(json, "access_token")};
-                if (auto data = self->m_metadata_store->get_user(user->user_id())) {
-                    data->access_token = access_token;
-                    self->m_metadata_store->update_user(user->user_id(), *data);
-                    user->update_backing_data(std::move(data));
-                }
+                self->m_metadata_store->update_user(user->user_id(), [&](auto& data) {
+                    data.access_token = access_token;
+                    user->update_backing_data(data);
+                });
             }
             catch (AppError& err) {
                 return completion(std::move(err));

src/realm/object-store/sync/async_open_task.cpp

@@ -23,6 +23,7 @@
 #include <realm/object-store/impl/realm_coordinator.hpp>
 #include <realm/object-store/sync/sync_session.hpp>
 #include <realm/object-store/thread_safe_reference.hpp>
+#include <realm/object-store/util/scheduler.hpp>
 
 namespace realm {
 
@@ -126,7 +127,7 @@ void AsyncOpenTask::wait_for_bootstrap_or_complete(AsyncOpenCallback&& callback,
 
     SharedRealm shared_realm;
     try {
-        shared_realm = coordinator->get_realm(nullptr, m_db_first_open);
+        shared_realm = coordinator->get_realm(util::Scheduler::make_dummy(), m_db_first_open);
     }
     catch (...) {
         async_open_complete(std::move(callback), coordinator, exception_to_status());