move contents of taskchampion repo to tc/

rust/sync-server/src/api/add_snapshot.rs

@@ -0,0 +1,204 @@
+use crate::api::{client_key_header, failure_to_ise, ServerState, SNAPSHOT_CONTENT_TYPE};
+use crate::server::{add_snapshot, VersionId, NIL_VERSION_ID};
+use actix_web::{error, post, web, HttpMessage, HttpRequest, HttpResponse, Result};
+use futures::StreamExt;
+use std::sync::Arc;
+
+/// Max snapshot size: 100MB
+const MAX_SIZE: usize = 100 * 1024 * 1024;
+
+/// Add a new snapshot, after checking prerequisites.  The snapshot should be transmitted in the
+/// request entity body and must have content-type `application/vnd.taskchampion.snapshot`.  The
+/// content can be encoded in any of the formats supported by actix-web.
+///
+/// On success, the response is a 200 OK. Even in a 200 OK, the snapshot may not appear in a
+/// subsequent `GetSnapshot` call.
+///
+/// Returns other 4xx or 5xx responses on other errors.
+#[post("/v1/client/add-snapshot/{version_id}")]
+pub(crate) async fn service(
+    req: HttpRequest,
+    server_state: web::Data<Arc<ServerState>>,
+    web::Path((version_id,)): web::Path<(VersionId,)>,
+    mut payload: web::Payload,
+) -> Result<HttpResponse> {
+    // check content-type
+    if req.content_type() != SNAPSHOT_CONTENT_TYPE {
+        return Err(error::ErrorBadRequest("Bad content-type"));
+    }
+
+    let client_key = client_key_header(&req)?;
+
+    // read the body in its entirety
+    let mut body = web::BytesMut::new();
+    while let Some(chunk) = payload.next().await {
+        let chunk = chunk?;
+        // limit max size of in-memory payload
+        if (body.len() + chunk.len()) > MAX_SIZE {
+            return Err(error::ErrorBadRequest("Snapshot over maximum allowed size"));
+        }
+        body.extend_from_slice(&chunk);
+    }
+
+    if body.is_empty() {
+        return Err(error::ErrorBadRequest("No snapshot supplied"));
+    }
+
+    // note that we do not open the transaction until the body has been read
+    // completely, to avoid blocking other storage access while that data is
+    // in transit.
+    let mut txn = server_state.storage.txn().map_err(failure_to_ise)?;
+
+    // get, or create, the client
+    let client = match txn.get_client(client_key).map_err(failure_to_ise)? {
+        Some(client) => client,
+        None => {
+            txn.new_client(client_key, NIL_VERSION_ID)
+                .map_err(failure_to_ise)?;
+            txn.get_client(client_key).map_err(failure_to_ise)?.unwrap()
+        }
+    };
+
+    add_snapshot(
+        txn,
+        &server_state.config,
+        client_key,
+        client,
+        version_id,
+        body.to_vec(),
+    )
+    .map_err(failure_to_ise)?;
+    Ok(HttpResponse::Ok().body(""))
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::storage::{InMemoryStorage, Storage};
+    use crate::Server;
+    use actix_web::{http::StatusCode, test, App};
+    use pretty_assertions::assert_eq;
+    use uuid::Uuid;
+
+    #[actix_rt::test]
+    async fn test_success() -> anyhow::Result<()> {
+        let client_key = Uuid::new_v4();
+        let version_id = Uuid::new_v4();
+        let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
+
+        // set up the storage contents..
+        {
+            let mut txn = storage.txn().unwrap();
+            txn.new_client(client_key, version_id).unwrap();
+            txn.add_version(client_key, version_id, NIL_VERSION_ID, vec![])?;
+        }
+
+        let server = Server::new(Default::default(), storage);
+        let app = App::new().configure(|sc| server.config(sc));
+        let mut app = test::init_service(app).await;
+
+        let uri = format!("/v1/client/add-snapshot/{}", version_id);
+        let req = test::TestRequest::post()
+            .uri(&uri)
+            .header("Content-Type", "application/vnd.taskchampion.snapshot")
+            .header("X-Client-Key", client_key.to_string())
+            .set_payload(b"abcd".to_vec())
+            .to_request();
+        let resp = test::call_service(&mut app, req).await;
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        // read back that snapshot
+        let uri = "/v1/client/snapshot";
+        let req = test::TestRequest::get()
+            .uri(uri)
+            .header("X-Client-Key", client_key.to_string())
+            .to_request();
+        let mut resp = test::call_service(&mut app, req).await;
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        use futures::StreamExt;
+        let (bytes, _) = resp.take_body().into_future().await;
+        assert_eq!(bytes.unwrap().unwrap().as_ref(), b"abcd");
+
+        Ok(())
+    }
+
+    #[actix_rt::test]
+    async fn test_not_added_200() {
+        let client_key = Uuid::new_v4();
+        let version_id = Uuid::new_v4();
+        let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
+
+        // set up the storage contents..
+        {
+            let mut txn = storage.txn().unwrap();
+            txn.new_client(client_key, NIL_VERSION_ID).unwrap();
+        }
+
+        let server = Server::new(Default::default(), storage);
+        let app = App::new().configure(|sc| server.config(sc));
+        let mut app = test::init_service(app).await;
+
+        // add a snapshot for a nonexistent version
+        let uri = format!("/v1/client/add-snapshot/{}", version_id);
+        let req = test::TestRequest::post()
+            .uri(&uri)
+            .header("Content-Type", "application/vnd.taskchampion.snapshot")
+            .header("X-Client-Key", client_key.to_string())
+            .set_payload(b"abcd".to_vec())
+            .to_request();
+        let resp = test::call_service(&mut app, req).await;
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        // read back, seeing no snapshot
+        let uri = "/v1/client/snapshot";
+        let req = test::TestRequest::get()
+            .uri(uri)
+            .header("X-Client-Key", client_key.to_string())
+            .to_request();
+        let resp = test::call_service(&mut app, req).await;
+        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+    }
+
+    #[actix_rt::test]
+    async fn test_bad_content_type() {
+        let client_key = Uuid::new_v4();
+        let version_id = Uuid::new_v4();
+        let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
+        let server = Server::new(Default::default(), storage);
+        let app = App::new().configure(|sc| server.config(sc));
+        let mut app = test::init_service(app).await;
+
+        let uri = format!("/v1/client/add-snapshot/{}", version_id);
+        let req = test::TestRequest::post()
+            .uri(&uri)
+            .header("Content-Type", "not/correct")
+            .header("X-Client-Key", client_key.to_string())
+            .set_payload(b"abcd".to_vec())
+            .to_request();
+        let resp = test::call_service(&mut app, req).await;
+        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+    }
+
+    #[actix_rt::test]
+    async fn test_empty_body() {
+        let client_key = Uuid::new_v4();
+        let version_id = Uuid::new_v4();
+        let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
+        let server = Server::new(Default::default(), storage);
+        let app = App::new().configure(|sc| server.config(sc));
+        let mut app = test::init_service(app).await;
+
+        let uri = format!("/v1/client/add-snapshot/{}", version_id);
+        let req = test::TestRequest::post()
+            .uri(&uri)
+            .header(
+                "Content-Type",
+                "application/vnd.taskchampion.history-segment",
+            )
+            .header("X-Client-Key", client_key.to_string())
+            .to_request();
+        let resp = test::call_service(&mut app, req).await;
+        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+    }
+}

rust/sync-server/src/api/add_version.rs

@@ -0,0 +1,230 @@
+use crate::api::{
+    client_key_header, failure_to_ise, ServerState, HISTORY_SEGMENT_CONTENT_TYPE,
+    PARENT_VERSION_ID_HEADER, SNAPSHOT_REQUEST_HEADER, VERSION_ID_HEADER,
+};
+use crate::server::{add_version, AddVersionResult, SnapshotUrgency, VersionId, NIL_VERSION_ID};
+use actix_web::{error, post, web, HttpMessage, HttpRequest, HttpResponse, Result};
+use futures::StreamExt;
+use std::sync::Arc;
+
+/// Max history segment size: 100MB
+const MAX_SIZE: usize = 100 * 1024 * 1024;
+
+/// Add a new version, after checking prerequisites.  The history segment should be transmitted in
+/// the request entity body and must have content-type
+/// `application/vnd.taskchampion.history-segment`.  The content can be encoded in any of the
+/// formats supported by actix-web.
+///
+/// On success, the response is a 200 OK with the new version ID in the `X-Version-Id` header.  If
+/// the version cannot be added due to a conflict, the response is a 409 CONFLICT with the expected
+/// parent version ID in the `X-Parent-Version-Id` header.
+///
+/// If included, a snapshot request appears in the `X-Snapshot-Request` header with value
+/// `urgency=low` or `urgency=high`.
+///
+/// Returns other 4xx or 5xx responses on other errors.
+#[post("/v1/client/add-version/{parent_version_id}")]
+pub(crate) async fn service(
+    req: HttpRequest,
+    server_state: web::Data<Arc<ServerState>>,
+    web::Path((parent_version_id,)): web::Path<(VersionId,)>,
+    mut payload: web::Payload,
+) -> Result<HttpResponse> {
+    // check content-type
+    if req.content_type() != HISTORY_SEGMENT_CONTENT_TYPE {
+        return Err(error::ErrorBadRequest("Bad content-type"));
+    }
+
+    let client_key = client_key_header(&req)?;
+
+    // read the body in its entirety
+    let mut body = web::BytesMut::new();
+    while let Some(chunk) = payload.next().await {
+        let chunk = chunk?;
+        // limit max size of in-memory payload
+        if (body.len() + chunk.len()) > MAX_SIZE {
+            return Err(error::ErrorBadRequest("overflow"));
+        }
+        body.extend_from_slice(&chunk);
+    }
+
+    if body.is_empty() {
+        return Err(error::ErrorBadRequest("Empty body"));
+    }
+
+    // note that we do not open the transaction until the body has been read
+    // completely, to avoid blocking other storage access while that data is
+    // in transit.
+    let mut txn = server_state.storage.txn().map_err(failure_to_ise)?;
+
+    // get, or create, the client
+    let client = match txn.get_client(client_key).map_err(failure_to_ise)? {
+        Some(client) => client,
+        None => {
+            txn.new_client(client_key, NIL_VERSION_ID)
+                .map_err(failure_to_ise)?;
+            txn.get_client(client_key).map_err(failure_to_ise)?.unwrap()
+        }
+    };
+
+    let (result, snap_urgency) = add_version(
+        txn,
+        &server_state.config,
+        client_key,
+        client,
+        parent_version_id,
+        body.to_vec(),
+    )
+    .map_err(failure_to_ise)?;
+
+    Ok(match result {
+        AddVersionResult::Ok(version_id) => {
+            let mut rb = HttpResponse::Ok();
+            rb.header(VERSION_ID_HEADER, version_id.to_string());
+            match snap_urgency {
+                SnapshotUrgency::None => {}
+                SnapshotUrgency::Low => {
+                    rb.header(SNAPSHOT_REQUEST_HEADER, "urgency=low");
+                }
+                SnapshotUrgency::High => {
+                    rb.header(SNAPSHOT_REQUEST_HEADER, "urgency=high");
+                }
+            };
+            rb.finish()
+        }
+        AddVersionResult::ExpectedParentVersion(parent_version_id) => {
+            let mut rb = HttpResponse::Conflict();
+            rb.header(PARENT_VERSION_ID_HEADER, parent_version_id.to_string());
+            rb.finish()
+        }
+    })
+}
+
+#[cfg(test)]
+mod test {
+    use crate::storage::{InMemoryStorage, Storage};
+    use crate::Server;
+    use actix_web::{http::StatusCode, test, App};
+    use pretty_assertions::assert_eq;
+    use uuid::Uuid;
+
+    #[actix_rt::test]
+    async fn test_success() {
+        let client_key = Uuid::new_v4();
+        let version_id = Uuid::new_v4();
+        let parent_version_id = Uuid::new_v4();
+        let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
+
+        // set up the storage contents..
+        {
+            let mut txn = storage.txn().unwrap();
+            txn.new_client(client_key, Uuid::nil()).unwrap();
+        }
+
+        let server = Server::new(Default::default(), storage);
+        let app = App::new().configure(|sc| server.config(sc));
+        let mut app = test::init_service(app).await;
+
+        let uri = format!("/v1/client/add-version/{}", parent_version_id);
+        let req = test::TestRequest::post()
+            .uri(&uri)
+            .header(
+                "Content-Type",
+                "application/vnd.taskchampion.history-segment",
+            )
+            .header("X-Client-Key", client_key.to_string())
+            .set_payload(b"abcd".to_vec())
+            .to_request();
+        let resp = test::call_service(&mut app, req).await;
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        // the returned version ID is random, but let's check that it's not
+        // the passed parent version ID, at least
+        let new_version_id = resp.headers().get("X-Version-Id").unwrap();
+        assert!(new_version_id != &version_id.to_string());
+
+        // Shapshot should be requested, since there is no existing snapshot
+        let snapshot_request = resp.headers().get("X-Snapshot-Request").unwrap();
+        assert_eq!(snapshot_request, "urgency=high");
+
+        assert_eq!(resp.headers().get("X-Parent-Version-Id"), None);
+    }
+
+    #[actix_rt::test]
+    async fn test_conflict() {
+        let client_key = Uuid::new_v4();
+        let version_id = Uuid::new_v4();
+        let parent_version_id = Uuid::new_v4();
+        let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
+
+        // set up the storage contents..
+        {
+            let mut txn = storage.txn().unwrap();
+            txn.new_client(client_key, version_id).unwrap();
+        }
+
+        let server = Server::new(Default::default(), storage);
+        let app = App::new().configure(|sc| server.config(sc));
+        let mut app = test::init_service(app).await;
+
+        let uri = format!("/v1/client/add-version/{}", parent_version_id);
+        let req = test::TestRequest::post()
+            .uri(&uri)
+            .header(
+                "Content-Type",
+                "application/vnd.taskchampion.history-segment",
+            )
+            .header("X-Client-Key", client_key.to_string())
+            .set_payload(b"abcd".to_vec())
+            .to_request();
+        let resp = test::call_service(&mut app, req).await;
+        assert_eq!(resp.status(), StatusCode::CONFLICT);
+        assert_eq!(resp.headers().get("X-Version-Id"), None);
+        assert_eq!(
+            resp.headers().get("X-Parent-Version-Id").unwrap(),
+            &version_id.to_string()
+        );
+    }
+
+    #[actix_rt::test]
+    async fn test_bad_content_type() {
+        let client_key = Uuid::new_v4();
+        let parent_version_id = Uuid::new_v4();
+        let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
+        let server = Server::new(Default::default(), storage);
+        let app = App::new().configure(|sc| server.config(sc));
+        let mut app = test::init_service(app).await;
+
+        let uri = format!("/v1/client/add-version/{}", parent_version_id);
+        let req = test::TestRequest::post()
+            .uri(&uri)
+            .header("Content-Type", "not/correct")
+            .header("X-Client-Key", client_key.to_string())
+            .set_payload(b"abcd".to_vec())
+            .to_request();
+        let resp = test::call_service(&mut app, req).await;
+        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+    }
+
+    #[actix_rt::test]
+    async fn test_empty_body() {
+        let client_key = Uuid::new_v4();
+        let parent_version_id = Uuid::new_v4();
+        let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
+        let server = Server::new(Default::default(), storage);
+        let app = App::new().configure(|sc| server.config(sc));
+        let mut app = test::init_service(app).await;
+
+        let uri = format!("/v1/client/add-version/{}", parent_version_id);
+        let req = test::TestRequest::post()
+            .uri(&uri)
+            .header(
+                "Content-Type",
+                "application/vnd.taskchampion.history-segment",
+            )
+            .header("X-Client-Key", client_key.to_string())
+            .to_request();
+        let resp = test::call_service(&mut app, req).await;
+        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+    }
+}

rust/sync-server/src/api/get_child_version.rs

@@ -0,0 +1,167 @@
+use crate::api::{
+    client_key_header, failure_to_ise, ServerState, HISTORY_SEGMENT_CONTENT_TYPE,
+    PARENT_VERSION_ID_HEADER, VERSION_ID_HEADER,
+};
+use crate::server::{get_child_version, GetVersionResult, VersionId};
+use actix_web::{error, get, web, HttpRequest, HttpResponse, Result};
+use std::sync::Arc;
+
+/// Get a child version.
+///
+/// On succcess, the response is the same sequence of bytes originally sent to the server,
+/// with content-type `application/vnd.taskchampion.history-segment`.  The `X-Version-Id` and
+/// `X-Parent-Version-Id` headers contain the corresponding values.
+///
+/// If no such child exists, returns a 404 with no content.
+/// Returns other 4xx or 5xx responses on other errors.
+#[get("/v1/client/get-child-version/{parent_version_id}")]
+pub(crate) async fn service(
+    req: HttpRequest,
+    server_state: web::Data<Arc<ServerState>>,
+    web::Path((parent_version_id,)): web::Path<(VersionId,)>,
+) -> Result<HttpResponse> {
+    let mut txn = server_state.storage.txn().map_err(failure_to_ise)?;
+
+    let client_key = client_key_header(&req)?;
+
+    let client = txn
+        .get_client(client_key)
+        .map_err(failure_to_ise)?
+        .ok_or_else(|| error::ErrorNotFound("no such client"))?;
+
+    return match get_child_version(
+        txn,
+        &server_state.config,
+        client_key,
+        client,
+        parent_version_id,
+    )
+    .map_err(failure_to_ise)?
+    {
+        GetVersionResult::Success {
+            version_id,
+            parent_version_id,
+            history_segment,
+        } => Ok(HttpResponse::Ok()
+            .content_type(HISTORY_SEGMENT_CONTENT_TYPE)
+            .header(VERSION_ID_HEADER, version_id.to_string())
+            .header(PARENT_VERSION_ID_HEADER, parent_version_id.to_string())
+            .body(history_segment)),
+        GetVersionResult::NotFound => Err(error::ErrorNotFound("no such version")),
+        GetVersionResult::Gone => Err(error::ErrorGone("version has been deleted")),
+    };
+}
+
+#[cfg(test)]
+mod test {
+    use crate::server::NIL_VERSION_ID;
+    use crate::storage::{InMemoryStorage, Storage};
+    use crate::Server;
+    use actix_web::{http::StatusCode, test, App};
+    use pretty_assertions::assert_eq;
+    use uuid::Uuid;
+
+    #[actix_rt::test]
+    async fn test_success() {
+        let client_key = Uuid::new_v4();
+        let version_id = Uuid::new_v4();
+        let parent_version_id = Uuid::new_v4();
+        let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
+
+        // set up the storage contents..
+        {
+            let mut txn = storage.txn().unwrap();
+            txn.new_client(client_key, Uuid::new_v4()).unwrap();
+            txn.add_version(client_key, version_id, parent_version_id, b"abcd".to_vec())
+                .unwrap();
+        }
+
+        let server = Server::new(Default::default(), storage);
+        let app = App::new().configure(|sc| server.config(sc));
+        let mut app = test::init_service(app).await;
+
+        let uri = format!("/v1/client/get-child-version/{}", parent_version_id);
+        let req = test::TestRequest::get()
+            .uri(&uri)
+            .header("X-Client-Key", client_key.to_string())
+            .to_request();
+        let mut resp = test::call_service(&mut app, req).await;
+        assert_eq!(resp.status(), StatusCode::OK);
+        assert_eq!(
+            resp.headers().get("X-Version-Id").unwrap(),
+            &version_id.to_string()
+        );
+        assert_eq!(
+            resp.headers().get("X-Parent-Version-Id").unwrap(),
+            &parent_version_id.to_string()
+        );
+        assert_eq!(
+            resp.headers().get("Content-Type").unwrap(),
+            &"application/vnd.taskchampion.history-segment".to_string()
+        );
+
+        use futures::StreamExt;
+        let (bytes, _) = resp.take_body().into_future().await;
+        assert_eq!(bytes.unwrap().unwrap().as_ref(), b"abcd");
+    }
+
+    #[actix_rt::test]
+    async fn test_client_not_found() {
+        let client_key = Uuid::new_v4();
+        let parent_version_id = Uuid::new_v4();
+        let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
+        let server = Server::new(Default::default(), storage);
+        let app = App::new().configure(|sc| server.config(sc));
+        let mut app = test::init_service(app).await;
+
+        let uri = format!("/v1/client/get-child-version/{}", parent_version_id);
+        let req = test::TestRequest::get()
+            .uri(&uri)
+            .header("X-Client-Key", client_key.to_string())
+            .to_request();
+        let resp = test::call_service(&mut app, req).await;
+        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+        assert_eq!(resp.headers().get("X-Version-Id"), None);
+        assert_eq!(resp.headers().get("X-Parent-Version-Id"), None);
+    }
+
+    #[actix_rt::test]
+    async fn test_version_not_found_and_gone() {
+        let client_key = Uuid::new_v4();
+        let parent_version_id = Uuid::new_v4();
+        let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
+
+        // create the client, but not the version
+        {
+            let mut txn = storage.txn().unwrap();
+            txn.new_client(client_key, Uuid::new_v4()).unwrap();
+        }
+        let server = Server::new(Default::default(), storage);
+        let app = App::new().configure(|sc| server.config(sc));
+        let mut app = test::init_service(app).await;
+
+        // the child of an unknown parent_version_id is GONE
+        let uri = format!("/v1/client/get-child-version/{}", parent_version_id);
+        let req = test::TestRequest::get()
+            .uri(&uri)
+            .header("X-Client-Key", client_key.to_string())
+            .to_request();
+        let resp = test::call_service(&mut app, req).await;
+        assert_eq!(resp.status(), StatusCode::GONE);
+        assert_eq!(resp.headers().get("X-Version-Id"), None);
+        assert_eq!(resp.headers().get("X-Parent-Version-Id"), None);
+
+        // but the child of the nil parent_version_id is NOT FOUND, since
+        // there is no snapshot.  The tests in crate::server test more
+        // corner cases.
+        let uri = format!("/v1/client/get-child-version/{}", NIL_VERSION_ID);
+        let req = test::TestRequest::get()
+            .uri(&uri)
+            .header("X-Client-Key", client_key.to_string())
+            .to_request();
+        let resp = test::call_service(&mut app, req).await;
+        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+        assert_eq!(resp.headers().get("X-Version-Id"), None);
+        assert_eq!(resp.headers().get("X-Parent-Version-Id"), None);
+    }
+}

rust/sync-server/src/api/get_snapshot.rs

@@ -0,0 +1,114 @@
+use crate::api::{
+    client_key_header, failure_to_ise, ServerState, SNAPSHOT_CONTENT_TYPE, VERSION_ID_HEADER,
+};
+use crate::server::get_snapshot;
+use actix_web::{error, get, web, HttpRequest, HttpResponse, Result};
+use std::sync::Arc;
+
+/// Get a snapshot.
+///
+/// If a snapshot for this client exists, it is returned with content-type
+/// `application/vnd.taskchampion.snapshot`.  The `X-Version-Id` header contains the version of the
+/// snapshot.
+///
+/// If no snapshot exists, returns a 404 with no content.  Returns other 4xx or 5xx responses on
+/// other errors.
+#[get("/v1/client/snapshot")]
+pub(crate) async fn service(
+    req: HttpRequest,
+    server_state: web::Data<Arc<ServerState>>,
+) -> Result<HttpResponse> {
+    let mut txn = server_state.storage.txn().map_err(failure_to_ise)?;
+
+    let client_key = client_key_header(&req)?;
+
+    let client = txn
+        .get_client(client_key)
+        .map_err(failure_to_ise)?
+        .ok_or_else(|| error::ErrorNotFound("no such client"))?;
+
+    if let Some((version_id, data)) =
+        get_snapshot(txn, &server_state.config, client_key, client).map_err(failure_to_ise)?
+    {
+        Ok(HttpResponse::Ok()
+            .content_type(SNAPSHOT_CONTENT_TYPE)
+            .header(VERSION_ID_HEADER, version_id.to_string())
+            .body(data))
+    } else {
+        Err(error::ErrorNotFound("no snapshot"))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::storage::{InMemoryStorage, Snapshot, Storage};
+    use crate::Server;
+    use actix_web::{http::StatusCode, test, App};
+    use chrono::{TimeZone, Utc};
+    use pretty_assertions::assert_eq;
+    use uuid::Uuid;
+
+    #[actix_rt::test]
+    async fn test_not_found() {
+        let client_key = Uuid::new_v4();
+        let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
+
+        // set up the storage contents..
+        {
+            let mut txn = storage.txn().unwrap();
+            txn.new_client(client_key, Uuid::new_v4()).unwrap();
+        }
+
+        let server = Server::new(Default::default(), storage);
+        let app = App::new().configure(|sc| server.config(sc));
+        let mut app = test::init_service(app).await;
+
+        let uri = "/v1/client/snapshot";
+        let req = test::TestRequest::get()
+            .uri(uri)
+            .header("X-Client-Key", client_key.to_string())
+            .to_request();
+        let resp = test::call_service(&mut app, req).await;
+        assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+    }
+
+    #[actix_rt::test]
+    async fn test_success() {
+        let client_key = Uuid::new_v4();
+        let version_id = Uuid::new_v4();
+        let snapshot_data = vec![1, 2, 3, 4];
+        let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
+
+        // set up the storage contents..
+        {
+            let mut txn = storage.txn().unwrap();
+            txn.new_client(client_key, Uuid::new_v4()).unwrap();
+            txn.set_snapshot(
+                client_key,
+                Snapshot {
+                    version_id,
+                    versions_since: 3,
+                    timestamp: Utc.ymd(2001, 9, 9).and_hms(1, 46, 40),
+                },
+                snapshot_data.clone(),
+            )
+            .unwrap();
+        }
+
+        let server = Server::new(Default::default(), storage);
+        let app = App::new().configure(|sc| server.config(sc));
+        let mut app = test::init_service(app).await;
+
+        let uri = "/v1/client/snapshot";
+        let req = test::TestRequest::get()
+            .uri(uri)
+            .header("X-Client-Key", client_key.to_string())
+            .to_request();
+        let mut resp = test::call_service(&mut app, req).await;
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        use futures::StreamExt;
+        let (bytes, _) = resp.take_body().into_future().await;
+        assert_eq!(bytes.unwrap().unwrap().as_ref(), snapshot_data);
+    }
+}

rust/sync-server/src/api/mod.rs

@@ -0,0 +1,61 @@
+use crate::server::ClientKey;
+use crate::storage::Storage;
+use crate::ServerConfig;
+use actix_web::{error, http::StatusCode, web, HttpRequest, Result, Scope};
+
+mod add_snapshot;
+mod add_version;
+mod get_child_version;
+mod get_snapshot;
+
+/// The content-type for history segments (opaque blobs of bytes)
+pub(crate) const HISTORY_SEGMENT_CONTENT_TYPE: &str =
+    "application/vnd.taskchampion.history-segment";
+
+/// The content-type for snapshots (opaque blobs of bytes)
+pub(crate) const SNAPSHOT_CONTENT_TYPE: &str = "application/vnd.taskchampion.snapshot";
+
+/// The header name for version ID
+pub(crate) const VERSION_ID_HEADER: &str = "X-Version-Id";
+
+/// The header name for client key
+pub(crate) const CLIENT_KEY_HEADER: &str = "X-Client-Key";
+
+/// The header name for parent version ID
+pub(crate) const PARENT_VERSION_ID_HEADER: &str = "X-Parent-Version-Id";
+
+/// The header name for parent version ID
+pub(crate) const SNAPSHOT_REQUEST_HEADER: &str = "X-Snapshot-Request";
+
+/// The type containing a reference to the persistent state for the server
+pub(crate) struct ServerState {
+    pub(crate) storage: Box<dyn Storage>,
+    pub(crate) config: ServerConfig,
+}
+
+pub(crate) fn api_scope() -> Scope {
+    web::scope("")
+        .service(get_child_version::service)
+        .service(add_version::service)
+        .service(get_snapshot::service)
+        .service(add_snapshot::service)
+}
+
+/// Convert a failure::Error to an Actix ISE
+fn failure_to_ise(err: anyhow::Error) -> impl actix_web::ResponseError {
+    error::InternalError::new(err, StatusCode::INTERNAL_SERVER_ERROR)
+}
+
+/// Get the client key
+fn client_key_header(req: &HttpRequest) -> Result<ClientKey> {
+    fn badrequest() -> error::Error {
+        error::ErrorBadRequest("bad x-client-id")
+    }
+    if let Some(client_key_hdr) = req.headers().get(CLIENT_KEY_HEADER) {
+        let client_key = client_key_hdr.to_str().map_err(|_| badrequest())?;
+        let client_key = ClientKey::parse_str(client_key).map_err(|_| badrequest())?;
+        Ok(client_key)
+    } else {
+        Err(badrequest())
+    }
+}