Make storage transactions specific to a client_id (#67)

Transactions for different client_ids cannot interfere with one another,
so this provides an opportunity for the sort of concurrency that a
mult-client hosting solution might need. For example, a postgres backend
could lock the client row in each transaction.

core/src/storage.rs

@@ -39,48 +39,38 @@ pub struct Version {
 /// in storage must be as if each were executed sequentially in some order. In particular,
 /// un-committed changes must not be read by another transaction.
 ///
+/// Transactions with different client IDs cannot share any data, so it is safe to handle them
+/// concurrently.
+///
 /// Changes in a transaction that is dropped without calling `commit` must not appear in any other
 /// transaction.
 pub trait StorageTxn {
-    /// Get information about the given client
-    fn get_client(&mut self, client_id: Uuid) -> anyhow::Result<Option<Client>>;
+    /// Get information about the client for this transaction
+    fn get_client(&mut self) -> anyhow::Result<Option<Client>>;
 
-    /// Create a new client with the given latest_version_id
-    fn new_client(&mut self, client_id: Uuid, latest_version_id: Uuid) -> anyhow::Result<()>;
+    /// Create the client for this transaction, with the given latest_version_id. The client must
+    /// not already exist.
+    fn new_client(&mut self, latest_version_id: Uuid) -> anyhow::Result<()>;
 
     /// Set the client's most recent snapshot.
-    fn set_snapshot(
-        &mut self,
-        client_id: Uuid,
-        snapshot: Snapshot,
-        data: Vec<u8>,
-    ) -> anyhow::Result<()>;
+    fn set_snapshot(&mut self, snapshot: Snapshot, data: Vec<u8>) -> anyhow::Result<()>;
 
     /// Get the data for the most recent snapshot.  The version_id
     /// is used to verify that the snapshot is for the correct version.
-    fn get_snapshot_data(
-        &mut self,
-        client_id: Uuid,
-        version_id: Uuid,
-    ) -> anyhow::Result<Option<Vec<u8>>>;
+    fn get_snapshot_data(&mut self, version_id: Uuid) -> anyhow::Result<Option<Vec<u8>>>;
 
     /// Get a version, indexed by parent version id
-    fn get_version_by_parent(
-        &mut self,
-        client_id: Uuid,
-        parent_version_id: Uuid,
-    ) -> anyhow::Result<Option<Version>>;
+    fn get_version_by_parent(&mut self, parent_version_id: Uuid)
+        -> anyhow::Result<Option<Version>>;
 
     /// Get a version, indexed by its own version id
-    fn get_version(&mut self, client_id: Uuid, version_id: Uuid)
-        -> anyhow::Result<Option<Version>>;
+    fn get_version(&mut self, version_id: Uuid) -> anyhow::Result<Option<Version>>;
 
     /// Add a version (that must not already exist), and
     ///  - update latest_version_id
     ///  - increment snapshot.versions_since
     fn add_version(
         &mut self,
-        client_id: Uuid,
         version_id: Uuid,
         parent_version_id: Uuid,
         history_segment: Vec<u8>,
@@ -94,6 +84,6 @@ pub trait StorageTxn {
 /// A trait for objects able to act as storage.  Most of the interesting behavior is in the
 /// [`crate::storage::StorageTxn`] trait.
 pub trait Storage: Send + Sync {
-    /// Begin a transaction
-    fn txn(&self) -> anyhow::Result<Box<dyn StorageTxn + '_>>;
+    /// Begin a transaction for the given client ID.
+    fn txn(&self, client_id: Uuid) -> anyhow::Result<Box<dyn StorageTxn + '_>>;
 }