Added Android code

[wl-app.git] / iOS / Pods / Realm / include / sync / sync_manager.hpp

////////////////////////////////////////////////////////////////////////////
//
// 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 <realm/sync/client.hpp>
#include <realm/util/logger.hpp>
#include <realm/util/optional.hpp>

#include <memory>
#include <mutex>
#include <unordered_map>

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<util::Logger> 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<std::vector<char>> 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<SyncSession> get_session(const std::string& path, const SyncConfig& config);
    std::shared_ptr<SyncSession> get_existing_session(const std::string& path) const;
    std::shared_ptr<SyncSession> 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<void(const SyncMetadataManager&)> 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<SyncUser> 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<SyncUser> get_admin_token_user_from_identity(const std::string& identity,
                                                                 util::Optional<std::string> 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<SyncUser> get_admin_token_user(const std::string& server_url,
                                                   const std::string& token,
                                                   util::Optional<std::string> old_identity=none);

    // Get an existing user for a given identifier, if one exists and is logged in.
    std::shared_ptr<SyncUser> get_existing_logged_in_user(const SyncUserIdentifier&) const;

    // Get all the users that are logged in and not errored out.
    std::vector<std::shared_ptr<SyncUser>> 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<SyncUser> 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<SyncSession> 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<SyncUserIdentifier, std::shared_ptr<SyncUser>> m_users;
    // A map of local identifiers to admin token users.
    std::unordered_map<std::string, std::shared_ptr<SyncUser>> 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<SyncFileManager> m_file_manager;
    std::unique_ptr<SyncMetadataManager> 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<std::string, std::shared_ptr<SyncSession>> m_sessions;
};

} // namespace realm

#endif // REALM_OS_SYNC_MANAGER_HPP