refactor sync server to use pluggable storage

..with a fixed implementation of the replica / server protocol logic.
There isn't much logic yet, and there's a lot of boilerplate to take
care of, so this looks a little lopsided, but I'm confident this is the
right structure for this code's future.

sync-server/src/storage/inmemory.rs

@@ -0,0 +1,90 @@
+use super::{Client, Storage, StorageTxn, Uuid, Version};
+use failure::Fallible;
+use std::collections::HashMap;
+use std::sync::{Mutex, MutexGuard};
+
+struct Inner {
+    /// Clients, indexed by client_id
+    clients: HashMap<Uuid, Client>,
+
+    /// Versions, indexed by (client_id, parent_version_id)
+    versions: HashMap<(Uuid, Uuid), Version>,
+}
+
+pub(crate) struct InMemoryStorage(Mutex<Inner>);
+
+impl InMemoryStorage {
+    pub(crate) fn new() -> Self {
+        Self(Mutex::new(Inner {
+            clients: HashMap::new(),
+            versions: HashMap::new(),
+        }))
+    }
+}
+
+struct InnerTxn<'a>(MutexGuard<'a, Inner>);
+
+/// In-memory storage for testing and experimentation.
+///
+/// NOTE: this does not implement transaction rollback.
+impl Storage for InMemoryStorage {
+    fn txn<'a>(&'a self) -> Fallible<Box<dyn StorageTxn + 'a>> {
+        Ok(Box::new(InnerTxn(self.0.lock().expect("poisoned lock"))))
+    }
+}
+
+impl<'a> StorageTxn for InnerTxn<'a> {
+    fn get_client(&mut self, client_id: Uuid) -> Fallible<Option<Client>> {
+        Ok(self.0.clients.get(&client_id).cloned())
+    }
+
+    fn set_client_latest_version_id(
+        &mut self,
+        client_id: Uuid,
+        latest_version_id: Uuid,
+    ) -> Fallible<()> {
+        if let Some(client) = self.0.clients.get_mut(&client_id) {
+            client.latest_version_id = latest_version_id;
+        } else {
+            self.0
+                .clients
+                .insert(client_id, Client { latest_version_id });
+        }
+        Ok(())
+    }
+
+    fn get_version_by_parent(
+        &mut self,
+        client_id: Uuid,
+        parent_version_id: Uuid,
+    ) -> Fallible<Option<Version>> {
+        Ok(self
+            .0
+            .versions
+            .get(&(client_id, parent_version_id))
+            .cloned())
+    }
+
+    fn add_version(
+        &mut self,
+        client_id: Uuid,
+        version_id: Uuid,
+        parent_version_id: Uuid,
+        history_segment: Vec<u8>,
+    ) -> Fallible<()> {
+        // TODO: verify it doesn't exist (`.entry`?)
+        let version = Version {
+            version_id,
+            parent_version_id,
+            history_segment,
+        };
+        self.0
+            .versions
+            .insert((client_id, version.parent_version_id), version);
+        Ok(())
+    }
+
+    fn commit(&mut self) -> Fallible<()> {
+        Ok(())
+    }
+}

sync-server/src/storage/mod.rs

@@ -0,0 +1,56 @@
+use failure::Fallible;
+use taskchampion::Uuid;
+
+mod inmemory;
+pub(crate) use inmemory::InMemoryStorage;
+
+#[derive(Clone)]
+pub(crate) struct Client {
+    pub(crate) latest_version_id: Uuid,
+}
+
+#[derive(Clone)]
+pub(crate) struct Version {
+    pub(crate) version_id: Uuid,
+    pub(crate) parent_version_id: Uuid,
+    pub(crate) history_segment: Vec<u8>,
+}
+
+pub(crate) trait StorageTxn {
+    /// Get information about the given client
+    fn get_client(&mut self, client_id: Uuid) -> Fallible<Option<Client>>;
+
+    /// Set the client's latest_version_id (creating the client if necessary)
+    fn set_client_latest_version_id(
+        &mut self,
+        client_id: Uuid,
+        latest_version_id: Uuid,
+    ) -> Fallible<()>;
+
+    /// Get a version, indexed by parent version id
+    fn get_version_by_parent(
+        &mut self,
+        client_id: Uuid,
+        parent_version_id: Uuid,
+    ) -> Fallible<Option<Version>>;
+
+    /// Add a version (that must not already exist)
+    fn add_version(
+        &mut self,
+        client_id: Uuid,
+        version_id: Uuid,
+        parent_version_id: Uuid,
+        history_segment: Vec<u8>,
+    ) -> Fallible<()>;
+
+    /// Commit any changes made in the transaction.  It is an error to call this more than
+    /// once.  It is safe to skip this call for read-only operations.
+    fn commit(&mut self) -> Fallible<()>;
+}
+
+/// A trait for objects able to act as storage.  Most of the interesting behavior is in the
+/// [`crate::storage::StorageTxn`] trait.
+pub(crate) trait Storage: Send + Sync {
+    /// Begin a transaction
+    fn txn<'a>(&'a self) -> Fallible<Box<dyn StorageTxn + 'a>>;
+}