iOS/Pods/Realm/include/sync/sync_user.hpp

   1 ////////////////////////////////////////////////////////////////////////////
   2 //
   3 // Copyright 2016 Realm Inc.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the "License");
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 ////////////////////////////////////////////////////////////////////////////
  18
  19 #ifndef REALM_OS_SYNC_USER_HPP
  20 #define REALM_OS_SYNC_USER_HPP
  21
  22 #include <string>
  23 #include <memory>
  24 #include <unordered_map>
  25 #include <vector>
  26 #include <mutex>
  27
  28 #include "util/atomic_shared_ptr.hpp"
  29
  30 #include <realm/util/optional.hpp>
  31
  32 namespace realm {
  33
  34 class SyncSession;
  35
  36 // A superclass that bindings can inherit from in order to store information
  37 // upon a `SyncUser` object.
  38 class SyncUserContext {
  39 public:
  40     virtual ~SyncUserContext() = default;
  41 };
  42
  43 using SyncUserContextFactory = std::function<std::shared_ptr<SyncUserContext>()>;
  44
  45 // A struct that uniquely identifies a user. Consists of ROS identity and auth server URL.
  46 struct SyncUserIdentifier {
  47     std::string user_id;
  48     std::string auth_server_url;
  49
  50     bool operator==(const SyncUserIdentifier& other) const
  51     {
  52         return user_id == other.user_id && auth_server_url == other.auth_server_url;
  53     }
  54 };
  55
  56 // A `SyncUser` represents a single user account. Each user manages the sessions that
  57 // are associated with it.
  58 class SyncUser {
  59 friend class SyncSession;
  60 public:
  61     enum class TokenType {
  62         Normal,
  63         Admin,
  64     };
  65
  66     enum class State {
  67         LoggedOut,
  68         Active,
  69         Error,
  70     };
  71
  72     // Don't use this directly; use the `SyncManager` APIs. Public for use with `make_shared`.
  73     SyncUser(std::string refresh_token,
  74              std::string identity,
  75              util::Optional<std::string> server_url,
  76              util::Optional<std::string> local_identity=none,
  77              TokenType token_type=TokenType::Normal);
  78
  79     // Return a list of all sessions belonging to this user.
  80     std::vector<std::shared_ptr<SyncSession>> all_sessions();
  81
  82     // Return a session for a given on disk path.
  83     // In most cases, bindings shouldn't expose this to consumers, since the on-disk
  84     // path for a synced Realm is an opaque implementation detail. This API is retained
  85     // for testing purposes, and for bindings for consumers that are servers or tools.
  86     std::shared_ptr<SyncSession> session_for_on_disk_path(const std::string& path);
  87
  88     // Update the user's refresh token. If the user is logged out, it will log itself back in.
  89     // Note that this is called by the SyncManager, and should not be directly called.
  90     void update_refresh_token(std::string token);
  91
  92     // Log the user out and mark it as such. This will also close its associated Sessions.
  93     void log_out();
  94
  95     // Whether the user has administrator privileges.
  96     bool is_admin() const noexcept
  97     {
  98         return m_token_type == TokenType::Admin || m_is_admin;
  99     }
 100
 101     TokenType token_type() const noexcept
 102     {
 103         return m_token_type;
 104     }
 105
 106     // Specify whether the user has administrator privileges.
 107     // Note that this is an internal flag meant for bindings to communicate information
 108     // originating from the server. It is *NOT* possible to unilaterally change a user's
 109     // administrator status from the client through this or any other API.
 110     void set_is_admin(bool);
 111
 112     std::string identity() const noexcept
 113     {
 114         return m_identity;
 115     }
 116
 117     const std::string& server_url() const noexcept
 118     {
 119         return m_server_url;
 120     }
 121
 122     const std::string& local_identity() const noexcept
 123     {
 124         return m_local_identity;
 125     }
 126
 127     std::string refresh_token() const;
 128     State state() const;
 129
 130     std::shared_ptr<SyncUserContext> binding_context() const
 131     {
 132         return m_binding_context.load();
 133     }
 134
 135     // Register a session to this user.
 136     // A registered session will be bound at the earliest opportunity: either
 137     // immediately, or upon the user becoming Active.
 138     // Note that this is called by the SyncManager, and should not be directly called.
 139     void register_session(std::shared_ptr<SyncSession>);
 140
 141     // Optionally set a context factory. If so, must be set before any sessions are created.
 142     static void set_binding_context_factory(SyncUserContextFactory factory);
 143
 144     // Internal APIs. Do not call.
 145     void register_management_session(const std::string&);
 146     void register_permission_session(const std::string&);
 147
 148 private:
 149     static SyncUserContextFactory s_binding_context_factory;
 150     static std::mutex s_binding_context_factory_mutex;
 151
 152     State m_state;
 153
 154     util::AtomicSharedPtr<SyncUserContext> m_binding_context;
 155
 156     // A locally assigned UUID intended to provide a level of indirection for various features.
 157     std::string m_local_identity;
 158
 159     std::weak_ptr<SyncSession> m_management_session;
 160     std::weak_ptr<SyncSession> m_permission_session;
 161
 162     // The auth server URL associated with this user. Set upon creation. The empty string for
 163     // auth token users.
 164     std::string m_server_url;
 165
 166     // Mark the user as invalid, since a fatal user-related error was encountered.
 167     void invalidate();
 168
 169     mutable std::mutex m_mutex;
 170
 171     // The token type of the user.
 172     // FIXME: remove this flag once bindings take responsible for admin token users
 173     TokenType m_token_type;
 174
 175     bool m_is_admin;
 176
 177     // The user's refresh token.
 178     std::string m_refresh_token;
 179     // Set by the server. The unique ID of the user account on the Realm Object Server.
 180     std::string m_identity;
 181
 182     // Sessions are owned by the SyncManager, but the user keeps a map of weak references
 183     // to them.
 184     std::unordered_map<std::string, std::weak_ptr<SyncSession>> m_sessions;
 185
 186     // Waiting sessions are those that should be asked to connect once this user is logged in.
 187     std::unordered_map<std::string, std::weak_ptr<SyncSession>> m_waiting_sessions;
 188 };
 189
 190 }
 191
 192 namespace std {
 193 template<> struct hash<realm::SyncUserIdentifier> {
 194     size_t operator()(realm::SyncUserIdentifier const&) const;
 195 };
 196 }
 197
 198 #endif // REALM_OS_SYNC_USER_HPP