X-Git-Url: https://git.mdrn.pl/wl-app.git/blobdiff_plain/53b27422d140022594fc241cca91c3183be57bca..48b2fe9f7c2dc3d9aeaaa6dbfb27c7da4f3235ff:/iOS/Pods/Realm/include/sync/sync_manager.hpp?ds=sidebyside diff --git a/iOS/Pods/Realm/include/sync/sync_manager.hpp b/iOS/Pods/Realm/include/sync/sync_manager.hpp new file mode 100644 index 0000000..2fbd470 --- /dev/null +++ b/iOS/Pods/Realm/include/sync/sync_manager.hpp @@ -0,0 +1,211 @@ +//////////////////////////////////////////////////////////////////////////// +// +// Copyright 2016 Realm Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//////////////////////////////////////////////////////////////////////////// + +#ifndef REALM_OS_SYNC_MANAGER_HPP +#define REALM_OS_SYNC_MANAGER_HPP + +#include "shared_realm.hpp" + +#include "sync_user.hpp" + +#include +#include +#include + +#include +#include +#include + +namespace realm { + +struct SyncConfig; +class SyncSession; +class SyncUser; +class SyncFileManager; +class SyncMetadataManager; +class SyncFileActionMetadata; + +namespace _impl { +struct SyncClient; +} + +enum class SyncSessionStopPolicy { + Immediately, // Immediately stop the session as soon as all Realms/Sessions go out of scope. + LiveIndefinitely, // Never stop the session. + AfterChangesUploaded, // Once all Realms/Sessions go out of scope, wait for uploads to complete and stop. +}; + +class SyncLoggerFactory { +public: + virtual std::unique_ptr make_logger(util::Logger::Level) = 0; +}; + +class SyncManager { +friend class SyncSession; +public: + enum class MetadataMode { + NoEncryption, // Enable metadata, but disable encryption. + Encryption, // Enable metadata, and use encryption (automatic if possible). + NoMetadata, // Disable metadata. + }; + + static SyncManager& shared(); + + // Configure the metadata and file management subsystems. This MUST be called upon startup. + void configure_file_system(const std::string& base_file_path, + MetadataMode metadata_mode=MetadataMode::Encryption, + util::Optional> custom_encryption_key=none, + bool reset_metadata_on_error=false); + + // Immediately run file actions for a single Realm at a given original path. + // Returns whether or not a file action was successfully executed for the specified Realm. + // Preconditions: all references to the Realm at the given path must have already been invalidated. + // The metadata and file management subsystems must also have already been configured. + bool immediately_run_file_actions(const std::string& original_name); + + // Use a single connection for all sync sessions for each host/port rather + // than one per session. + // This must be called before any sync sessions are created, cannot be + // disabled afterwards, and currently is incompatible with using a load + // balancer or automatic failover. + void enable_session_multiplexing(); + + void set_log_level(util::Logger::Level) noexcept; + void set_logger_factory(SyncLoggerFactory&) noexcept; + + /// Control whether the sync client attempts to reconnect immediately. Only set this to `true` for testing purposes. + void set_client_should_reconnect_immediately(bool reconnect_immediately); + bool client_should_reconnect_immediately() const noexcept; + + /// Ask all valid sync sessions to perform whatever tasks might be necessary to + /// re-establish connectivity with the Realm Object Server. It is presumed that + /// the caller knows that network connectivity has been restored. + /// + /// Refer to `SyncSession::handle_reconnect()` to see what sort of work is done + /// on a per-session basis. + void reconnect(); + + util::Logger::Level log_level() const noexcept; + + std::shared_ptr get_session(const std::string& path, const SyncConfig& config); + std::shared_ptr get_existing_session(const std::string& path) const; + std::shared_ptr get_existing_active_session(const std::string& path) const; + + // If the metadata manager is configured, perform an update. Returns `true` iff the code was run. + bool perform_metadata_update(std::function update_function) const; + + // Get a sync user for a given identity, or create one if none exists yet, and set its token. + // If a logged-out user exists, it will marked as logged back in. + std::shared_ptr get_user(const SyncUserIdentifier& identifier, std::string refresh_token); + + // Get or create an admin token user based on the given identity. + // Please note: a future version will remove this method and deprecate the + // use of identities for admin users completely. + // Warning: it is an error to create or get an admin token user with a given identity and + // specifying a URL, and later get that same user by specifying only the identity and no + // URL, or vice versa. + std::shared_ptr get_admin_token_user_from_identity(const std::string& identity, + util::Optional server_url, + const std::string& token); + + // Get or create an admin token user for the given URL. + // If the user already exists, the token value will be ignored. + // If an old identity is provided and a directory for the user already exists, the directory + // will be renamed. + std::shared_ptr get_admin_token_user(const std::string& server_url, + const std::string& token, + util::Optional old_identity=none); + + // Get an existing user for a given identifier, if one exists and is logged in. + std::shared_ptr get_existing_logged_in_user(const SyncUserIdentifier&) const; + + // Get all the users that are logged in and not errored out. + std::vector> all_logged_in_users() const; + // Gets the currently logged in user. If there are more than 1 users logged in, an exception is thrown. + std::shared_ptr get_current_user() const; + + // Get the default path for a Realm for the given user and absolute unresolved URL. + std::string path_for_realm(const SyncUser& user, const std::string& raw_realm_url) const; + + // Get the path of the recovery directory for backed-up or recovered Realms. + std::string recovery_directory_path() const; + + // Get the unique identifier of this client. + std::string client_uuid() const; + + // Reset the singleton state for testing purposes. DO NOT CALL OUTSIDE OF TESTING CODE. + // Precondition: any synced Realms or `SyncSession`s must be closed or rendered inactive prior to + // calling this method. + void reset_for_testing(); + +private: + using ReconnectMode = sync::Client::ReconnectMode; + + static constexpr const char c_admin_identity[] = "__auth"; + + // Stop tracking the session for the given path if it is inactive. + // No-op if the session is either still active or in the active sessions list + // due to someone holding a strong reference to it. + void unregister_session(const std::string& path); + + SyncManager() = default; + SyncManager(const SyncManager&) = delete; + SyncManager& operator=(const SyncManager&) = delete; + + _impl::SyncClient& get_sync_client() const; + std::unique_ptr<_impl::SyncClient> create_sync_client() const; + + std::shared_ptr get_existing_session_locked(const std::string& path) const; + + mutable std::mutex m_mutex; + + // FIXME: Should probably be util::Logger::Level::error + util::Logger::Level m_log_level = util::Logger::Level::info; + SyncLoggerFactory* m_logger_factory = nullptr; + ReconnectMode m_client_reconnect_mode = ReconnectMode::normal; + + bool run_file_action(const SyncFileActionMetadata&); + + // Protects m_users + mutable std::mutex m_user_mutex; + + // A map of user ID/auth server URL pairs to (shared pointers to) SyncUser objects. + std::unordered_map> m_users; + // A map of local identifiers to admin token users. + std::unordered_map> m_admin_token_users; + + mutable std::unique_ptr<_impl::SyncClient> m_sync_client; + bool m_multiplex_sessions = false; + + // Protects m_file_manager and m_metadata_manager + mutable std::mutex m_file_system_mutex; + std::unique_ptr m_file_manager; + std::unique_ptr m_metadata_manager; + + // Protects m_sessions + mutable std::mutex m_session_mutex; + + // Map of sessions by path name. + // Sessions remove themselves from this map by calling `unregister_session` once they're + // inactive and have performed any necessary cleanup work. + std::unordered_map> m_sessions; +}; + +} // namespace realm + +#endif // REALM_OS_SYNC_MANAGER_HPP