GothenburgBitFactory/taskwarrior
1
0
Fork 0
mirror of https://github.com/GothenburgBitFactory/taskwarrior.git synced 2025-08-19 09:53:08 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Change "client key" to "client id" (#3130)

Browse source 
In #3118 @ryneeverett mentioned that "key" suggests that this is a
secret, when in truth it's just a user identifier. So "ID" is a better
word for it than "key".
This commit is contained in:
Dustin J. Mitchell 2023-07-11 22:13:53 -04:00 • committed by GitHub
parent 8097e28318
commit 7f68441916
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
32 changed files with 387 additions and 388 deletions
Download patch file Download diff file Expand all files Collapse all files

14
doc/man/task-sync.5.in
View file

@ -29,9 +29,9 @@ information from the server administrator:
.br .br
- The server's URL ("origin", such as "https://tw.example.com") - The server's URL ("origin", such as "https://tw.example.com")
.br .br
- A client key ("client_key") identifying your tasks - A client ID ("client_id") identifying your tasks
.br .br
- An encryption secret ("encryption_secret") used to encrypt and decrypt your tasks. This can be any secret string, and must match for all replicas using the same client key. - An encryption secret ("encryption_secret") used to encrypt and decrypt your tasks. This can be any secret string, and must match for all replicas using the same client ID.
Tools such as Tools such as
.BR pwgen (1) .BR pwgen (1)
@ -40,7 +40,7 @@ can generate suitable secret values.
Configure Taskwarrior with these details: Configure Taskwarrior with these details:
$ task config sync.server.origin <origin> $ task config sync.server.origin <origin>
$ task config sync.server.client_key <client_key> $ task config sync.server.client_id <client_id>
$ task config sync.server.encryption_secret <encryption_secret> $ task config sync.server.encryption_secret <encryption_secret>
.SS Adding a Replica .SS Adding a Replica
@ -74,7 +74,7 @@ The default configuration is to sync to a database in the task directory
.SH RUNNING TASKCHAMPION-SYNC-SERVER .SH RUNNING TASKCHAMPION-SYNC-SERVER
The Taskchampion sync server is an HTTP server supporting multiple users. The Taskchampion sync server is an HTTP server supporting multiple users.
Users are identified by a client key, and users with different client keys are Users are identified by a client ID, and users with different client IDs are
entirely independent. Task data is encrypted by Taskwarrior, and the sync entirely independent. Task data is encrypted by Taskwarrior, and the sync
server never sees un-encrypted data. server never sees un-encrypted data.
@ -91,10 +91,10 @@ For example:
.SS Adding a New User .SS Adding a New User
To add a new user to the server, invent a new client key with a tool like To add a new user to the server, invent a new client ID with a tool like
`uuidgen` or an online UUID generator. There is no need to configure the server `uuidgen` or an online UUID generator. There is no need to configure the server
for this new client key: the sync server will automatically create a new user for this new client ID: the sync server will automatically create a new user
whenever presented with a new client key. Supply the key, along with the whenever presented with a new client ID. Supply the ID, along with the
origin, to the user for inclusion in their Taskwarrior config. The user should origin, to the user for inclusion in their Taskwarrior config. The user should
invent their own "encryption_secret". invent their own "encryption_secret".

2
scripts/vim/syntax/taskrc.vim
View file

@ -163,7 +163,7 @@ syn match taskrcGoodKey '^\s*\Vrule.precedence.color='he=e-1
syn match taskrcGoodKey '^\s*\Vsearch.case.sensitive='he=e-1 syn match taskrcGoodKey '^\s*\Vsearch.case.sensitive='he=e-1
syn match taskrcGoodKey '^\s*\Vsummary.all.projects='he=e-1 syn match taskrcGoodKey '^\s*\Vsummary.all.projects='he=e-1
syn match taskrcGoodKey '^\s*\Vsugar='he=e-1 syn match taskrcGoodKey '^\s*\Vsugar='he=e-1
syn match taskrcGoodKey '^\s*\Vsync.\(server.\(origin\|client_key\|encryption_secret\)\|local.server_dir\)='he=e-1 syn match taskrcGoodKey '^\s*\Vsync.\(server.\(origin\|client_id\|encryption_secret\)\|local.server_dir\)='he=e-1
syn match taskrcGoodKey '^\s*\Vtag.indicator='he=e-1 syn match taskrcGoodKey '^\s*\Vtag.indicator='he=e-1
syn match taskrcGoodKey '^\s*\Vuda.\S\{-}.\(default\|type\|label\|values\|indicator\)='he=e-1 syn match taskrcGoodKey '^\s*\Vuda.\S\{-}.\(default\|type\|label\|values\|indicator\)='he=e-1
syn match taskrcGoodKey '^\s*\Vundo.style='he=e-1 syn match taskrcGoodKey '^\s*\Vundo.style='he=e-1

2
src/Context.cpp
View file

@ -279,7 +279,7 @@ std::string configurationDefaults =
"# WARNING: Please read the documentation (man task-sync) before setting up\n" "# WARNING: Please read the documentation (man task-sync) before setting up\n"
"# Taskwarrior for Taskserver synchronization.\n" "# Taskwarrior for Taskserver synchronization.\n"
"\n" "\n"
"#sync.server.client_key # Client key for sync to a server\n" "#sync.server.client_id # Client ID for sync to a server\n"
"#sync.server.encryption_secret # Encryption secret for sync to a server\n" "#sync.server.encryption_secret # Encryption secret for sync to a server\n"
"#sync.server.origin # Origin of the sync server\n" "#sync.server.origin # Origin of the sync server\n"
"#sync.local.server_dir # Directory for local sync\n" "#sync.local.server_dir # Directory for local sync\n"

2
src/commands/CmdShow.cpp
View file

@ -193,7 +193,7 @@ int CmdShow::execute (std::string& output)
" sugar" " sugar"
" summary.all.projects" " summary.all.projects"
" sync.local.server_dir" " sync.local.server_dir"
" sync.server.client_key" " sync.server.client_id"
" sync.server.encryption_secret" " sync.server.encryption_secret"
" sync.server.origin" " sync.server.origin"
" tag.indicator" " tag.indicator"

6
src/commands/CmdSync.cpp
View file

@ -63,14 +63,14 @@ int CmdSync::execute (std::string& output)
// If no server is set up, quit. // If no server is set up, quit.
std::string origin = Context::getContext ().config.get ("sync.server.origin"); std::string origin = Context::getContext ().config.get ("sync.server.origin");
std::string client_key = Context::getContext ().config.get ("sync.server.client_key"); std::string client_id = Context::getContext ().config.get ("sync.server.client_id");
std::string encryption_secret = Context::getContext ().config.get ("sync.server.encryption_secret"); std::string encryption_secret = Context::getContext ().config.get ("sync.server.encryption_secret");
std::string server_dir = Context::getContext ().config.get ("sync.local.server_dir"); std::string server_dir = Context::getContext ().config.get ("sync.local.server_dir");
if (server_dir != "") { if (server_dir != "") {
server = tc::Server (server_dir); server = tc::Server (server_dir);
server_ident = server_dir; server_ident = server_dir;
} else if (origin != "" && client_key != "" && encryption_secret != "") { } else if (origin != "" && client_id != "" && encryption_secret != "") {
server = tc::Server (origin, client_key, encryption_secret); server = tc::Server (origin, client_id, encryption_secret);
server_ident = origin; server_ident = origin;
} else { } else {
throw std::string ("Neither sync.server nor sync.local are configured."); throw std::string ("Neither sync.server nor sync.local are configured.");

12
src/tc/Server.cpp
View file

@ -49,23 +49,23 @@ tc::Server::Server (const std::string &server_dir)
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
tc::Server::Server (const std::string &origin, const std::string &client_key, const std::string &encryption_secret) tc::Server::Server (const std::string &origin, const std::string &client_id, const std::string &encryption_secret)
{ {
TCString tc_origin = tc_string_borrow (origin.c_str ()); TCString tc_origin = tc_string_borrow (origin.c_str ());
TCString tc_client_key_str = tc_string_borrow (client_key.c_str ()); TCString tc_client_id = tc_string_borrow (client_id.c_str ());
TCString tc_encryption_secret = tc_string_borrow (encryption_secret.c_str ()); TCString tc_encryption_secret = tc_string_borrow (encryption_secret.c_str ());
TCUuid tc_client_key; TCUuid tc_client_uuid;
if (tc_uuid_from_str(tc_client_key_str, &tc_client_key) != TC_RESULT_OK) { if (tc_uuid_from_str(tc_client_id, &tc_client_uuid) != TC_RESULT_OK) {
tc_string_free(&tc_origin); tc_string_free(&tc_origin);
tc_string_free(&tc_encryption_secret); tc_string_free(&tc_encryption_secret);
throw "client_key must be a valid UUID"; throw "client_id must be a valid UUID";
} }
TCString error; TCString error;
auto tcserver = tc_server_new_remote (tc_origin, tc_client_key, tc_encryption_secret, &error); auto tcserver = tc_server_new_remote (tc_origin, tc_client_uuid, tc_encryption_secret, &error);
if (!tcserver) { if (!tcserver) {
auto errmsg = format ("Could not configure connection to server at {1}: {2}", auto errmsg = format ("Could not configure connection to server at {1}: {2}",
origin, tc_string_content (&error)); origin, tc_string_content (&error));

2
src/tc/Server.h
View file

@ -54,7 +54,7 @@ namespace tc {
Server (const std::string& server_dir); Server (const std::string& server_dir);
// Construct a remote server (tc_server_new_remote). // Construct a remote server (tc_server_new_remote).
Server (const std::string &origin, const std::string &client_key, const std::string &encryption_secret); Server (const std::string &origin, const std::string &client_id, const std::string &encryption_secret);
// This object "owns" inner, so copy is not allowed. // This object "owns" inner, so copy is not allowed.
Server (const Server &) = delete; Server (const Server &) = delete;

6
taskchampion/docs/src/sync-protocol.md
View file

@ -9,7 +9,7 @@ The protocol builds on the model presented in the previous chapter, and in parti
From the server's perspective, replicas accessing the same task history are indistinguishable, so this protocol uses the term "client" to refer generically to all replicas replicating a single task history. From the server's perspective, replicas accessing the same task history are indistinguishable, so this protocol uses the term "client" to refer generically to all replicas replicating a single task history.
Each client is identified and authenticated with a "client key", known only to the server and to the replicas replicating the task history. Each client is identified and authenticated with a "client_id key", known only to the server and to the replicas replicating the task history.
## Server ## Server
@ -48,7 +48,7 @@ This section describes how that information is used to encrypt and decrypt data
#### Key Derivation #### Key Derivation
The client derives the 32-byte encryption key from the configured encryption secret using PBKDF2 with HMAC-SHA256 and 100,000 iterations. The client derives the 32-byte encryption key from the configured encryption secret using PBKDF2 with HMAC-SHA256 and 100,000 iterations.
The salt is the SHA256 hash of the 16-byte form of the client key. The salt is the SHA256 hash of the 16-byte form of the client ID.
#### Encryption #### Encryption
@ -172,7 +172,7 @@ The response contains the snapshot version ID and the snapshot data, if those ex
The transactions above are realized for an HTTP server at `<origin>` using the HTTP requests and responses described here. The transactions above are realized for an HTTP server at `<origin>` using the HTTP requests and responses described here.
The `origin` *should* be an HTTPS endpoint on general principle, but nothing in the functonality or security of the protocol depends on connection encryption. The `origin` *should* be an HTTPS endpoint on general principle, but nothing in the functonality or security of the protocol depends on connection encryption.
The replica identifies itself to the server using a `clientKey` in the form of a UUID. The replica identifies itself to the server using a `client_id` in the form of a UUID.
This value is passed with every request in the `X-Client-Id` header, in its dashed-hex format. This value is passed with every request in the `X-Client-Id` header, in its dashed-hex format.
### AddVersion ### AddVersion

4
taskchampion/integration-tests/tests/cross-sync.rs
View file

@ -26,12 +26,12 @@ async fn cross_sync() -> anyhow::Result<()> {
let mut rep1 = Replica::new(StorageConfig::InMemory.into_storage()?); let mut rep1 = Replica::new(StorageConfig::InMemory.into_storage()?);
let mut rep2 = Replica::new(StorageConfig::InMemory.into_storage()?); let mut rep2 = Replica::new(StorageConfig::InMemory.into_storage()?);
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let encryption_secret = b"abc123".to_vec(); let encryption_secret = b"abc123".to_vec();
let make_server = || { let make_server = || {
ServerConfig::Remote { ServerConfig::Remote {
origin: format!("http://127.0.0.1:{}", port), origin: format!("http://127.0.0.1:{}", port),
client_key, client_id,
encryption_secret: encryption_secret.clone(), encryption_secret: encryption_secret.clone(),
} }
.into_server() .into_server()

4
taskchampion/integration-tests/tests/snapshots.rs
View file

@ -30,12 +30,12 @@ async fn sync_with_snapshots() -> anyhow::Result<()> {
} }
fn client(port: u16) -> anyhow::Result<()> { fn client(port: u16) -> anyhow::Result<()> {
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let encryption_secret = b"abc123".to_vec(); let encryption_secret = b"abc123".to_vec();
let make_server = || { let make_server = || {
ServerConfig::Remote { ServerConfig::Remote {
origin: format!("http://127.0.0.1:{}", port), origin: format!("http://127.0.0.1:{}", port),
client_key, client_id,
encryption_secret: encryption_secret.clone(), encryption_secret: encryption_secret.clone(),
} }
.into_server() .into_server()

10
taskchampion/lib/src/server.rs
View file

@ -109,14 +109,14 @@ pub unsafe extern "C" fn tc_server_new_local(
/// ///
/// ```c /// ```c
/// EXTERN_C struct TCServer *tc_server_new_remote(struct TCString origin, /// EXTERN_C struct TCServer *tc_server_new_remote(struct TCString origin,
/// struct TCUuid client_key, /// struct TCUuid client_id,
/// struct TCString encryption_secret, /// struct TCString encryption_secret,
/// struct TCString *error_out); /// struct TCString *error_out);
/// ``` /// ```
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn tc_server_new_remote( pub unsafe extern "C" fn tc_server_new_remote(
origin: TCString, origin: TCString,
client_key: TCUuid, client_id: TCUuid,
encryption_secret: TCString, encryption_secret: TCString,
error_out: *mut TCString, error_out: *mut TCString,
) -> *mut TCServer { ) -> *mut TCServer {
@ -128,9 +128,9 @@ pub unsafe extern "C" fn tc_server_new_remote(
let origin = unsafe { TCString::val_from_arg(origin) }.into_string()?; let origin = unsafe { TCString::val_from_arg(origin) }.into_string()?;
// SAFETY: // SAFETY:
// - client_key is a valid Uuid (any 8-byte sequence counts) // - client_id is a valid Uuid (any 8-byte sequence counts)
let client_key = unsafe { TCUuid::val_from_arg(client_key) }; let client_id = unsafe { TCUuid::val_from_arg(client_id) };
// SAFETY: // SAFETY:
// - encryption_secret is valid (promised by caller) // - encryption_secret is valid (promised by caller)
// - encryption_secret ownership is transferred to this function // - encryption_secret ownership is transferred to this function
@ -140,7 +140,7 @@ pub unsafe extern "C" fn tc_server_new_remote(
let server_config = ServerConfig::Remote { let server_config = ServerConfig::Remote {
origin, origin,
client_key, client_id,
encryption_secret, encryption_secret,
}; };
let server = server_config.into_server()?; let server = server_config.into_server()?;

2
taskchampion/lib/taskchampion.h
View file

@ -433,7 +433,7 @@ EXTERN_C struct TCServer *tc_server_new_local(struct TCString server_dir, struct
// //
// The server must be freed after it is used - tc_replica_sync does not automatically free it. // The server must be freed after it is used - tc_replica_sync does not automatically free it.
EXTERN_C struct TCServer *tc_server_new_remote(struct TCString origin, EXTERN_C struct TCServer *tc_server_new_remote(struct TCString origin,
struct TCUuid client_key, struct TCUuid client_id,
struct TCString encryption_secret, struct TCString encryption_secret,
struct TCString *error_out); struct TCString *error_out);

39
taskchampion/sync-server/src/api/add_snapshot.rs
View file

@ -1,4 +1,4 @@
use crate::api::{client_key_header, failure_to_ise, ServerState, SNAPSHOT_CONTENT_TYPE}; use crate::api::{client_id_header, failure_to_ise, ServerState, SNAPSHOT_CONTENT_TYPE};
use crate::server::{add_snapshot, VersionId, NIL_VERSION_ID}; use crate::server::{add_snapshot, VersionId, NIL_VERSION_ID};
use actix_web::{error, post, web, HttpMessage, HttpRequest, HttpResponse, Result}; use actix_web::{error, post, web, HttpMessage, HttpRequest, HttpResponse, Result};
use futures::StreamExt; use futures::StreamExt;
@ -29,7 +29,7 @@ pub(crate) async fn service(
return Err(error::ErrorBadRequest("Bad content-type")); return Err(error::ErrorBadRequest("Bad content-type"));
} }
let client_key = client_key_header(&req)?; let client_id = client_id_header(&req)?;
// read the body in its entirety // read the body in its entirety
let mut body = web::BytesMut::new(); let mut body = web::BytesMut::new();
@ -52,19 +52,19 @@ pub(crate) async fn service(
let mut txn = server_state.storage.txn().map_err(failure_to_ise)?; let mut txn = server_state.storage.txn().map_err(failure_to_ise)?;
// get, or create, the client // get, or create, the client
let client = match txn.get_client(client_key).map_err(failure_to_ise)? { let client = match txn.get_client(client_id).map_err(failure_to_ise)? {
Some(client) => client, Some(client) => client,
None => { None => {
txn.new_client(client_key, NIL_VERSION_ID) txn.new_client(client_id, NIL_VERSION_ID)
.map_err(failure_to_ise)?; .map_err(failure_to_ise)?;
txn.get_client(client_key).map_err(failure_to_ise)?.unwrap() txn.get_client(client_id).map_err(failure_to_ise)?.unwrap()
} }
}; };
add_snapshot( add_snapshot(
txn, txn,
&server_state.config, &server_state.config,
client_key, client_id,
client, client,
version_id, version_id,
body.to_vec(), body.to_vec(),
@ -76,6 +76,7 @@ pub(crate) async fn service(
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::*; use super::*;
use crate::api::CLIENT_ID_HEADER;
use crate::storage::{InMemoryStorage, Storage}; use crate::storage::{InMemoryStorage, Storage};
use crate::Server; use crate::Server;
use actix_web::{http::StatusCode, test, App}; use actix_web::{http::StatusCode, test, App};
@ -84,15 +85,15 @@ mod test {
#[actix_rt::test] #[actix_rt::test]
async fn test_success() -> anyhow::Result<()> { async fn test_success() -> anyhow::Result<()> {
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let version_id = Uuid::new_v4(); let version_id = Uuid::new_v4();
let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new()); let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
// set up the storage contents.. // set up the storage contents..
{ {
let mut txn = storage.txn().unwrap(); let mut txn = storage.txn().unwrap();
txn.new_client(client_key, version_id).unwrap(); txn.new_client(client_id, version_id).unwrap();
txn.add_version(client_key, version_id, NIL_VERSION_ID, vec![])?; txn.add_version(client_id, version_id, NIL_VERSION_ID, vec![])?;
} }
let server = Server::new(Default::default(), storage); let server = Server::new(Default::default(), storage);
@ -103,7 +104,7 @@ mod test {
let req = test::TestRequest::post() let req = test::TestRequest::post()
.uri(&uri) .uri(&uri)
.insert_header(("Content-Type", "application/vnd.taskchampion.snapshot")) .insert_header(("Content-Type", "application/vnd.taskchampion.snapshot"))
.insert_header(("X-Client-Key", client_key.to_string())) .insert_header((CLIENT_ID_HEADER, client_id.to_string()))
.set_payload(b"abcd".to_vec()) .set_payload(b"abcd".to_vec())
.to_request(); .to_request();
let resp = test::call_service(&mut app, req).await; let resp = test::call_service(&mut app, req).await;
@ -113,7 +114,7 @@ mod test {
let uri = "/v1/client/snapshot"; let uri = "/v1/client/snapshot";
let req = test::TestRequest::get() let req = test::TestRequest::get()
.uri(uri) .uri(uri)
.append_header(("X-Client-Key", client_key.to_string())) .append_header((CLIENT_ID_HEADER, client_id.to_string()))
.to_request(); .to_request();
let resp = test::call_service(&mut app, req).await; let resp = test::call_service(&mut app, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
@ -127,14 +128,14 @@ mod test {
#[actix_rt::test] #[actix_rt::test]
async fn test_not_added_200() { async fn test_not_added_200() {
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let version_id = Uuid::new_v4(); let version_id = Uuid::new_v4();
let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new()); let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
// set up the storage contents.. // set up the storage contents..
{ {
let mut txn = storage.txn().unwrap(); let mut txn = storage.txn().unwrap();
txn.new_client(client_key, NIL_VERSION_ID).unwrap(); txn.new_client(client_id, NIL_VERSION_ID).unwrap();
} }
let server = Server::new(Default::default(), storage); let server = Server::new(Default::default(), storage);
@ -146,7 +147,7 @@ mod test {
let req = test::TestRequest::post() let req = test::TestRequest::post()
.uri(&uri) .uri(&uri)
.append_header(("Content-Type", "application/vnd.taskchampion.snapshot")) .append_header(("Content-Type", "application/vnd.taskchampion.snapshot"))
.append_header(("X-Client-Key", client_key.to_string())) .append_header((CLIENT_ID_HEADER, client_id.to_string()))
.set_payload(b"abcd".to_vec()) .set_payload(b"abcd".to_vec())
.to_request(); .to_request();
let resp = test::call_service(&mut app, req).await; let resp = test::call_service(&mut app, req).await;
@ -156,7 +157,7 @@ mod test {
let uri = "/v1/client/snapshot"; let uri = "/v1/client/snapshot";
let req = test::TestRequest::get() let req = test::TestRequest::get()
.uri(uri) .uri(uri)
.append_header(("X-Client-Key", client_key.to_string())) .append_header((CLIENT_ID_HEADER, client_id.to_string()))
.to_request(); .to_request();
let resp = test::call_service(&mut app, req).await; let resp = test::call_service(&mut app, req).await;
assert_eq!(resp.status(), StatusCode::NOT_FOUND); assert_eq!(resp.status(), StatusCode::NOT_FOUND);
@ -164,7 +165,7 @@ mod test {
#[actix_rt::test] #[actix_rt::test]
async fn test_bad_content_type() { async fn test_bad_content_type() {
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let version_id = Uuid::new_v4(); let version_id = Uuid::new_v4();
let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new()); let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
let server = Server::new(Default::default(), storage); let server = Server::new(Default::default(), storage);
@ -175,7 +176,7 @@ mod test {
let req = test::TestRequest::post() let req = test::TestRequest::post()
.uri(&uri) .uri(&uri)
.append_header(("Content-Type", "not/correct")) .append_header(("Content-Type", "not/correct"))
.append_header(("X-Client-Key", client_key.to_string())) .append_header((CLIENT_ID_HEADER, client_id.to_string()))
.set_payload(b"abcd".to_vec()) .set_payload(b"abcd".to_vec())
.to_request(); .to_request();
let resp = test::call_service(&mut app, req).await; let resp = test::call_service(&mut app, req).await;
@ -184,7 +185,7 @@ mod test {
#[actix_rt::test] #[actix_rt::test]
async fn test_empty_body() { async fn test_empty_body() {
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let version_id = Uuid::new_v4(); let version_id = Uuid::new_v4();
let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new()); let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
let server = Server::new(Default::default(), storage); let server = Server::new(Default::default(), storage);
@ -198,7 +199,7 @@ mod test {
"Content-Type", "Content-Type",
"application/vnd.taskchampion.history-segment", "application/vnd.taskchampion.history-segment",
)) ))
.append_header(("X-Client-Key", client_key.to_string())) .append_header((CLIENT_ID_HEADER, client_id.to_string()))
.to_request(); .to_request();
let resp = test::call_service(&mut app, req).await; let resp = test::call_service(&mut app, req).await;
assert_eq!(resp.status(), StatusCode::BAD_REQUEST); assert_eq!(resp.status(), StatusCode::BAD_REQUEST);

33
taskchampion/sync-server/src/api/add_version.rs
View file

@ -1,5 +1,5 @@
use crate::api::{ use crate::api::{
client_key_header, failure_to_ise, ServerState, HISTORY_SEGMENT_CONTENT_TYPE, client_id_header, failure_to_ise, ServerState, HISTORY_SEGMENT_CONTENT_TYPE,
PARENT_VERSION_ID_HEADER, SNAPSHOT_REQUEST_HEADER, VERSION_ID_HEADER, PARENT_VERSION_ID_HEADER, SNAPSHOT_REQUEST_HEADER, VERSION_ID_HEADER,
}; };
use crate::server::{add_version, AddVersionResult, SnapshotUrgency, VersionId, NIL_VERSION_ID}; use crate::server::{add_version, AddVersionResult, SnapshotUrgency, VersionId, NIL_VERSION_ID};
@ -37,7 +37,7 @@ pub(crate) async fn service(
return Err(error::ErrorBadRequest("Bad content-type")); return Err(error::ErrorBadRequest("Bad content-type"));
} }
let client_key = client_key_header(&req)?; let client_id = client_id_header(&req)?;
// read the body in its entirety // read the body in its entirety
let mut body = web::BytesMut::new(); let mut body = web::BytesMut::new();
@ -60,19 +60,19 @@ pub(crate) async fn service(
let mut txn = server_state.storage.txn().map_err(failure_to_ise)?; let mut txn = server_state.storage.txn().map_err(failure_to_ise)?;
// get, or create, the client // get, or create, the client
let client = match txn.get_client(client_key).map_err(failure_to_ise)? { let client = match txn.get_client(client_id).map_err(failure_to_ise)? {
Some(client) => client, Some(client) => client,
None => { None => {
txn.new_client(client_key, NIL_VERSION_ID) txn.new_client(client_id, NIL_VERSION_ID)
.map_err(failure_to_ise)?; .map_err(failure_to_ise)?;
txn.get_client(client_key).map_err(failure_to_ise)?.unwrap() txn.get_client(client_id).map_err(failure_to_ise)?.unwrap()
} }
}; };
let (result, snap_urgency) = add_version( let (result, snap_urgency) = add_version(
txn, txn,
&server_state.config, &server_state.config,
client_key, client_id,
client, client,
parent_version_id, parent_version_id,
body.to_vec(), body.to_vec(),
@ -104,6 +104,7 @@ pub(crate) async fn service(
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use crate::api::CLIENT_ID_HEADER;
use crate::storage::{InMemoryStorage, Storage}; use crate::storage::{InMemoryStorage, Storage};
use crate::Server; use crate::Server;
use actix_web::{http::StatusCode, test, App}; use actix_web::{http::StatusCode, test, App};
@ -112,7 +113,7 @@ mod test {
#[actix_rt::test] #[actix_rt::test]
async fn test_success() { async fn test_success() {
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let version_id = Uuid::new_v4(); let version_id = Uuid::new_v4();
let parent_version_id = Uuid::new_v4(); let parent_version_id = Uuid::new_v4();
let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new()); let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
@ -120,7 +121,7 @@ mod test {
// set up the storage contents.. // set up the storage contents..
{ {
let mut txn = storage.txn().unwrap(); let mut txn = storage.txn().unwrap();
txn.new_client(client_key, Uuid::nil()).unwrap(); txn.new_client(client_id, Uuid::nil()).unwrap();
} }
let server = Server::new(Default::default(), storage); let server = Server::new(Default::default(), storage);
@ -134,7 +135,7 @@ mod test {
"Content-Type", "Content-Type",
"application/vnd.taskchampion.history-segment", "application/vnd.taskchampion.history-segment",
)) ))
.append_header(("X-Client-Key", client_key.to_string())) .append_header((CLIENT_ID_HEADER, client_id.to_string()))
.set_payload(b"abcd".to_vec()) .set_payload(b"abcd".to_vec())
.to_request(); .to_request();
let resp = test::call_service(&mut app, req).await; let resp = test::call_service(&mut app, req).await;
@ -154,7 +155,7 @@ mod test {
#[actix_rt::test] #[actix_rt::test]
async fn test_conflict() { async fn test_conflict() {
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let version_id = Uuid::new_v4(); let version_id = Uuid::new_v4();
let parent_version_id = Uuid::new_v4(); let parent_version_id = Uuid::new_v4();
let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new()); let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
@ -162,7 +163,7 @@ mod test {
// set up the storage contents.. // set up the storage contents..
{ {
let mut txn = storage.txn().unwrap(); let mut txn = storage.txn().unwrap();
txn.new_client(client_key, version_id).unwrap(); txn.new_client(client_id, version_id).unwrap();
} }
let server = Server::new(Default::default(), storage); let server = Server::new(Default::default(), storage);
@ -176,7 +177,7 @@ mod test {
"Content-Type", "Content-Type",
"application/vnd.taskchampion.history-segment", "application/vnd.taskchampion.history-segment",
)) ))
.append_header(("X-Client-Key", client_key.to_string())) .append_header((CLIENT_ID_HEADER, client_id.to_string()))
.set_payload(b"abcd".to_vec()) .set_payload(b"abcd".to_vec())
.to_request(); .to_request();
let resp = test::call_service(&mut app, req).await; let resp = test::call_service(&mut app, req).await;
@ -190,7 +191,7 @@ mod test {
#[actix_rt::test] #[actix_rt::test]
async fn test_bad_content_type() { async fn test_bad_content_type() {
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let parent_version_id = Uuid::new_v4(); let parent_version_id = Uuid::new_v4();
let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new()); let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
let server = Server::new(Default::default(), storage); let server = Server::new(Default::default(), storage);
@ -201,7 +202,7 @@ mod test {
let req = test::TestRequest::post() let req = test::TestRequest::post()
.uri(&uri) .uri(&uri)
.append_header(("Content-Type", "not/correct")) .append_header(("Content-Type", "not/correct"))
.append_header(("X-Client-Key", client_key.to_string())) .append_header((CLIENT_ID_HEADER, client_id.to_string()))
.set_payload(b"abcd".to_vec()) .set_payload(b"abcd".to_vec())
.to_request(); .to_request();
let resp = test::call_service(&mut app, req).await; let resp = test::call_service(&mut app, req).await;
@ -210,7 +211,7 @@ mod test {
#[actix_rt::test] #[actix_rt::test]
async fn test_empty_body() { async fn test_empty_body() {
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let parent_version_id = Uuid::new_v4(); let parent_version_id = Uuid::new_v4();
let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new()); let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
let server = Server::new(Default::default(), storage); let server = Server::new(Default::default(), storage);
@ -224,7 +225,7 @@ mod test {
"Content-Type", "Content-Type",
"application/vnd.taskchampion.history-segment", "application/vnd.taskchampion.history-segment",
)) ))
.append_header(("X-Client-Key", client_key.to_string())) .append_header((CLIENT_ID_HEADER, client_id.to_string()))
.to_request(); .to_request();
let resp = test::call_service(&mut app, req).await; let resp = test::call_service(&mut app, req).await;
assert_eq!(resp.status(), StatusCode::BAD_REQUEST); assert_eq!(resp.status(), StatusCode::BAD_REQUEST);

29
taskchampion/sync-server/src/api/get_child_version.rs
View file

@ -1,5 +1,5 @@
use crate::api::{ use crate::api::{
client_key_header, failure_to_ise, ServerState, HISTORY_SEGMENT_CONTENT_TYPE, client_id_header, failure_to_ise, ServerState, HISTORY_SEGMENT_CONTENT_TYPE,
PARENT_VERSION_ID_HEADER, VERSION_ID_HEADER, PARENT_VERSION_ID_HEADER, VERSION_ID_HEADER,
}; };
use crate::server::{get_child_version, GetVersionResult, VersionId}; use crate::server::{get_child_version, GetVersionResult, VersionId};
@ -24,17 +24,17 @@ pub(crate) async fn service(
let mut txn = server_state.storage.txn().map_err(failure_to_ise)?; let mut txn = server_state.storage.txn().map_err(failure_to_ise)?;
let client_key = client_key_header(&req)?; let client_id = client_id_header(&req)?;
let client = txn let client = txn
.get_client(client_key) .get_client(client_id)
.map_err(failure_to_ise)? .map_err(failure_to_ise)?
.ok_or_else(|| error::ErrorNotFound("no such client"))?; .ok_or_else(|| error::ErrorNotFound("no such client"))?;
return match get_child_version( return match get_child_version(
txn, txn,
&server_state.config, &server_state.config,
client_key, client_id,
client, client,
parent_version_id, parent_version_id,
) )
@ -56,6 +56,7 @@ pub(crate) async fn service(
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use crate::api::CLIENT_ID_HEADER;
use crate::server::NIL_VERSION_ID; use crate::server::NIL_VERSION_ID;
use crate::storage::{InMemoryStorage, Storage}; use crate::storage::{InMemoryStorage, Storage};
use crate::Server; use crate::Server;
@ -65,7 +66,7 @@ mod test {
#[actix_rt::test] #[actix_rt::test]
async fn test_success() { async fn test_success() {
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let version_id = Uuid::new_v4(); let version_id = Uuid::new_v4();
let parent_version_id = Uuid::new_v4(); let parent_version_id = Uuid::new_v4();
let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new()); let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
@ -73,8 +74,8 @@ mod test {
// set up the storage contents.. // set up the storage contents..
{ {
let mut txn = storage.txn().unwrap(); let mut txn = storage.txn().unwrap();
txn.new_client(client_key, Uuid::new_v4()).unwrap(); txn.new_client(client_id, Uuid::new_v4()).unwrap();
txn.add_version(client_key, version_id, parent_version_id, b"abcd".to_vec()) txn.add_version(client_id, version_id, parent_version_id, b"abcd".to_vec())
.unwrap(); .unwrap();
} }
@ -85,7 +86,7 @@ mod test {
let uri = format!("/v1/client/get-child-version/{}", parent_version_id); let uri = format!("/v1/client/get-child-version/{}", parent_version_id);
let req = test::TestRequest::get() let req = test::TestRequest::get()
.uri(&uri) .uri(&uri)
.append_header(("X-Client-Key", client_key.to_string())) .append_header((CLIENT_ID_HEADER, client_id.to_string()))
.to_request(); .to_request();
let resp = test::call_service(&mut app, req).await; let resp = test::call_service(&mut app, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
@ -109,7 +110,7 @@ mod test {
#[actix_rt::test] #[actix_rt::test]
async fn test_client_not_found() { async fn test_client_not_found() {
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let parent_version_id = Uuid::new_v4(); let parent_version_id = Uuid::new_v4();
let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new()); let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
let server = Server::new(Default::default(), storage); let server = Server::new(Default::default(), storage);
@ -119,7 +120,7 @@ mod test {
let uri = format!("/v1/client/get-child-version/{}", parent_version_id); let uri = format!("/v1/client/get-child-version/{}", parent_version_id);
let req = test::TestRequest::get() let req = test::TestRequest::get()
.uri(&uri) .uri(&uri)
.append_header(("X-Client-Key", client_key.to_string())) .append_header((CLIENT_ID_HEADER, client_id.to_string()))
.to_request(); .to_request();
let resp = test::call_service(&mut app, req).await; let resp = test::call_service(&mut app, req).await;
assert_eq!(resp.status(), StatusCode::NOT_FOUND); assert_eq!(resp.status(), StatusCode::NOT_FOUND);
@ -129,14 +130,14 @@ mod test {
#[actix_rt::test] #[actix_rt::test]
async fn test_version_not_found_and_gone() { async fn test_version_not_found_and_gone() {
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let parent_version_id = Uuid::new_v4(); let parent_version_id = Uuid::new_v4();
let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new()); let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
// create the client, but not the version // create the client, but not the version
{ {
let mut txn = storage.txn().unwrap(); let mut txn = storage.txn().unwrap();
txn.new_client(client_key, Uuid::new_v4()).unwrap(); txn.new_client(client_id, Uuid::new_v4()).unwrap();
} }
let server = Server::new(Default::default(), storage); let server = Server::new(Default::default(), storage);
let app = App::new().configure(|sc| server.config(sc)); let app = App::new().configure(|sc| server.config(sc));
@ -146,7 +147,7 @@ mod test {
let uri = format!("/v1/client/get-child-version/{}", parent_version_id); let uri = format!("/v1/client/get-child-version/{}", parent_version_id);
let req = test::TestRequest::get() let req = test::TestRequest::get()
.uri(&uri) .uri(&uri)
.append_header(("X-Client-Key", client_key.to_string())) .append_header((CLIENT_ID_HEADER, client_id.to_string()))
.to_request(); .to_request();
let resp = test::call_service(&mut app, req).await; let resp = test::call_service(&mut app, req).await;
assert_eq!(resp.status(), StatusCode::GONE); assert_eq!(resp.status(), StatusCode::GONE);
@ -159,7 +160,7 @@ mod test {
let uri = format!("/v1/client/get-child-version/{}", NIL_VERSION_ID); let uri = format!("/v1/client/get-child-version/{}", NIL_VERSION_ID);
let req = test::TestRequest::get() let req = test::TestRequest::get()
.uri(&uri) .uri(&uri)
.append_header(("X-Client-Key", client_key.to_string())) .append_header((CLIENT_ID_HEADER, client_id.to_string()))
.to_request(); .to_request();
let resp = test::call_service(&mut app, req).await; let resp = test::call_service(&mut app, req).await;
assert_eq!(resp.status(), StatusCode::NOT_FOUND); assert_eq!(resp.status(), StatusCode::NOT_FOUND);

23
taskchampion/sync-server/src/api/get_snapshot.rs
View file

@ -1,5 +1,5 @@
use crate::api::{ use crate::api::{
client_key_header, failure_to_ise, ServerState, SNAPSHOT_CONTENT_TYPE, VERSION_ID_HEADER, client_id_header, failure_to_ise, ServerState, SNAPSHOT_CONTENT_TYPE, VERSION_ID_HEADER,
}; };
use crate::server::get_snapshot; use crate::server::get_snapshot;
use actix_web::{error, get, web, HttpRequest, HttpResponse, Result}; use actix_web::{error, get, web, HttpRequest, HttpResponse, Result};
@ -20,15 +20,15 @@ pub(crate) async fn service(
) -> Result<HttpResponse> { ) -> Result<HttpResponse> {
let mut txn = server_state.storage.txn().map_err(failure_to_ise)?; let mut txn = server_state.storage.txn().map_err(failure_to_ise)?;
let client_key = client_key_header(&req)?; let client_id = client_id_header(&req)?;
let client = txn let client = txn
.get_client(client_key) .get_client(client_id)
.map_err(failure_to_ise)? .map_err(failure_to_ise)?
.ok_or_else(|| error::ErrorNotFound("no such client"))?; .ok_or_else(|| error::ErrorNotFound("no such client"))?;
if let Some((version_id, data)) = if let Some((version_id, data)) =
get_snapshot(txn, &server_state.config, client_key, client).map_err(failure_to_ise)? get_snapshot(txn, &server_state.config, client_id, client).map_err(failure_to_ise)?
{ {
Ok(HttpResponse::Ok() Ok(HttpResponse::Ok()
.content_type(SNAPSHOT_CONTENT_TYPE) .content_type(SNAPSHOT_CONTENT_TYPE)
@ -41,6 +41,7 @@ pub(crate) async fn service(
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use crate::api::CLIENT_ID_HEADER;
use crate::storage::{InMemoryStorage, Snapshot, Storage}; use crate::storage::{InMemoryStorage, Snapshot, Storage};
use crate::Server; use crate::Server;
use actix_web::{http::StatusCode, test, App}; use actix_web::{http::StatusCode, test, App};
@ -50,13 +51,13 @@ mod test {
#[actix_rt::test] #[actix_rt::test]
async fn test_not_found() { async fn test_not_found() {
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new()); let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
// set up the storage contents.. // set up the storage contents..
{ {
let mut txn = storage.txn().unwrap(); let mut txn = storage.txn().unwrap();
txn.new_client(client_key, Uuid::new_v4()).unwrap(); txn.new_client(client_id, Uuid::new_v4()).unwrap();
} }
let server = Server::new(Default::default(), storage); let server = Server::new(Default::default(), storage);
@ -66,7 +67,7 @@ mod test {
let uri = "/v1/client/snapshot"; let uri = "/v1/client/snapshot";
let req = test::TestRequest::get() let req = test::TestRequest::get()
.uri(uri) .uri(uri)
.append_header(("X-Client-Key", client_key.to_string())) .append_header((CLIENT_ID_HEADER, client_id.to_string()))
.to_request(); .to_request();
let resp = test::call_service(&mut app, req).await; let resp = test::call_service(&mut app, req).await;
assert_eq!(resp.status(), StatusCode::NOT_FOUND); assert_eq!(resp.status(), StatusCode::NOT_FOUND);
@ -74,7 +75,7 @@ mod test {
#[actix_rt::test] #[actix_rt::test]
async fn test_success() { async fn test_success() {
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let version_id = Uuid::new_v4(); let version_id = Uuid::new_v4();
let snapshot_data = vec![1, 2, 3, 4]; let snapshot_data = vec![1, 2, 3, 4];
let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new()); let storage: Box<dyn Storage> = Box::new(InMemoryStorage::new());
@ -82,9 +83,9 @@ mod test {
// set up the storage contents.. // set up the storage contents..
{ {
let mut txn = storage.txn().unwrap(); let mut txn = storage.txn().unwrap();
txn.new_client(client_key, Uuid::new_v4()).unwrap(); txn.new_client(client_id, Uuid::new_v4()).unwrap();
txn.set_snapshot( txn.set_snapshot(
client_key, client_id,
Snapshot { Snapshot {
version_id, version_id,
versions_since: 3, versions_since: 3,
@ -102,7 +103,7 @@ mod test {
let uri = "/v1/client/snapshot"; let uri = "/v1/client/snapshot";
let req = test::TestRequest::get() let req = test::TestRequest::get()
.uri(uri) .uri(uri)
.append_header(("X-Client-Key", client_key.to_string())) .append_header((CLIENT_ID_HEADER, client_id.to_string()))
.to_request(); .to_request();
let resp = test::call_service(&mut app, req).await; let resp = test::call_service(&mut app, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);

18
taskchampion/sync-server/src/api/mod.rs
View file

@ -1,4 +1,4 @@
use crate::server::ClientKey; use crate::server::ClientId;
use crate::storage::Storage; use crate::storage::Storage;
use crate::ServerConfig; use crate::ServerConfig;
use actix_web::{error, http::StatusCode, web, HttpRequest, Result, Scope}; use actix_web::{error, http::StatusCode, web, HttpRequest, Result, Scope};
@ -18,8 +18,8 @@ pub(crate) const SNAPSHOT_CONTENT_TYPE: &str = "application/vnd.taskchampion.sna
/// The header name for version ID /// The header name for version ID
pub(crate) const VERSION_ID_HEADER: &str = "X-Version-Id"; pub(crate) const VERSION_ID_HEADER: &str = "X-Version-Id";
/// The header name for client key /// The header name for client id
pub(crate) const CLIENT_KEY_HEADER: &str = "X-Client-Key"; pub(crate) const CLIENT_ID_HEADER: &str = "X-Client-Id";
/// The header name for parent version ID /// The header name for parent version ID
pub(crate) const PARENT_VERSION_ID_HEADER: &str = "X-Parent-Version-Id"; pub(crate) const PARENT_VERSION_ID_HEADER: &str = "X-Parent-Version-Id";
@ -46,15 +46,15 @@ fn failure_to_ise(err: anyhow::Error) -> impl actix_web::ResponseError {
error::InternalError::new(err, StatusCode::INTERNAL_SERVER_ERROR) error::InternalError::new(err, StatusCode::INTERNAL_SERVER_ERROR)
} }
/// Get the client key /// Get the client id
fn client_key_header(req: &HttpRequest) -> Result<ClientKey> { fn client_id_header(req: &HttpRequest) -> Result<ClientId> {
fn badrequest() -> error::Error { fn badrequest() -> error::Error {
error::ErrorBadRequest("bad x-client-id") error::ErrorBadRequest("bad x-client-id")
} }
if let Some(client_key_hdr) = req.headers().get(CLIENT_KEY_HEADER) { if let Some(client_id_hdr) = req.headers().get(CLIENT_ID_HEADER) {
let client_key = client_key_hdr.to_str().map_err(|_| badrequest())?; let client_id = client_id_hdr.to_str().map_err(|_| badrequest())?;
let client_key = ClientKey::parse_str(client_key).map_err(|_| badrequest())?; let client_id = ClientId::parse_str(client_id).map_err(|_| badrequest())?;
Ok(client_key) Ok(client_id)
} else { } else {
Err(badrequest()) Err(badrequest())
} }

242
taskchampion/sync-server/src/server.rs
View file

@ -14,7 +14,7 @@ pub const NIL_VERSION_ID: VersionId = Uuid::nil();
const SNAPSHOT_SEARCH_LEN: i32 = 5; const SNAPSHOT_SEARCH_LEN: i32 = 5;
pub(crate) type HistorySegment = Vec<u8>; pub(crate) type HistorySegment = Vec<u8>;
pub(crate) type ClientKey = Uuid; pub(crate) type ClientId = Uuid;
pub(crate) type VersionId = Uuid; pub(crate) type VersionId = Uuid;
/// ServerConfig contains configuration parameters for the server. /// ServerConfig contains configuration parameters for the server.
@ -60,12 +60,12 @@ pub(crate) enum GetVersionResult {
pub(crate) fn get_child_version<'a>( pub(crate) fn get_child_version<'a>(
mut txn: Box<dyn StorageTxn + 'a>, mut txn: Box<dyn StorageTxn + 'a>,
_config: &ServerConfig, _config: &ServerConfig,
client_key: ClientKey, client_id: ClientId,
client: Client, client: Client,
parent_version_id: VersionId, parent_version_id: VersionId,
) -> anyhow::Result<GetVersionResult> { ) -> anyhow::Result<GetVersionResult> {
// If a version with parentVersionId equal to the requested parentVersionId exists, it is returned. // If a version with parentVersionId equal to the requested parentVersionId exists, it is returned.
if let Some(version) = txn.get_version_by_parent(client_key, parent_version_id)? { if let Some(version) = txn.get_version_by_parent(client_id, parent_version_id)? {
return Ok(GetVersionResult::Success { return Ok(GetVersionResult::Success {
version_id: version.version_id, version_id: version.version_id,
parent_version_id: version.parent_version_id, parent_version_id: version.parent_version_id,
@ -86,7 +86,7 @@ pub(crate) fn get_child_version<'a>(
} }
// If a version with versionId equal to the requested parentVersionId exists, the response is _not-found_ (the client is up-to-date) // If a version with versionId equal to the requested parentVersionId exists, the response is _not-found_ (the client is up-to-date)
if txn.get_version(client_key, parent_version_id)?.is_some() { if txn.get_version(client_id, parent_version_id)?.is_some() {
return Ok(GetVersionResult::NotFound); return Ok(GetVersionResult::NotFound);
} }
@ -144,14 +144,14 @@ impl SnapshotUrgency {
pub(crate) fn add_version<'a>( pub(crate) fn add_version<'a>(
mut txn: Box<dyn StorageTxn + 'a>, mut txn: Box<dyn StorageTxn + 'a>,
config: &ServerConfig, config: &ServerConfig,
client_key: ClientKey, client_id: ClientId,
client: Client, client: Client,
parent_version_id: VersionId, parent_version_id: VersionId,
history_segment: HistorySegment, history_segment: HistorySegment,
) -> anyhow::Result<(AddVersionResult, SnapshotUrgency)> { ) -> anyhow::Result<(AddVersionResult, SnapshotUrgency)> {
log::debug!( log::debug!(
"add_version(client_key: {}, parent_version_id: {})", "add_version(client_id: {}, parent_version_id: {})",
client_key, client_id,
parent_version_id, parent_version_id,
); );
@ -172,7 +172,7 @@ pub(crate) fn add_version<'a>(
); );
// update the DB // update the DB
txn.add_version(client_key, version_id, parent_version_id, history_segment)?; txn.add_version(client_id, version_id, parent_version_id, history_segment)?;
txn.commit()?; txn.commit()?;
// calculate the urgency // calculate the urgency
@ -200,14 +200,14 @@ pub(crate) fn add_version<'a>(
pub(crate) fn add_snapshot<'a>( pub(crate) fn add_snapshot<'a>(
mut txn: Box<dyn StorageTxn + 'a>, mut txn: Box<dyn StorageTxn + 'a>,
_config: &ServerConfig, _config: &ServerConfig,
client_key: ClientKey, client_id: ClientId,
client: Client, client: Client,
version_id: VersionId, version_id: VersionId,
data: Vec<u8>, data: Vec<u8>,
) -> anyhow::Result<()> { ) -> anyhow::Result<()> {
log::debug!( log::debug!(
"add_snapshot(client_key: {}, version_id: {})", "add_snapshot(client_id: {}, version_id: {})",
client_key, client_id,
version_id, version_id,
); );
@ -254,7 +254,7 @@ pub(crate) fn add_snapshot<'a>(
} }
// get the parent version ID // get the parent version ID
if let Some(parent) = txn.get_version(client_key, vid)? { if let Some(parent) = txn.get_version(client_id, vid)? {
vid = parent.parent_version_id; vid = parent.parent_version_id;
} else { } else {
// this version does not exist; "this should not happen" but if it does, // this version does not exist; "this should not happen" but if it does,
@ -269,7 +269,7 @@ pub(crate) fn add_snapshot<'a>(
log::warn!("accepting snapshot for version {}", version_id); log::warn!("accepting snapshot for version {}", version_id);
txn.set_snapshot( txn.set_snapshot(
client_key, client_id,
Snapshot { Snapshot {
version_id, version_id,
timestamp: Utc::now(), timestamp: Utc::now(),
@ -285,11 +285,11 @@ pub(crate) fn add_snapshot<'a>(
pub(crate) fn get_snapshot<'a>( pub(crate) fn get_snapshot<'a>(
mut txn: Box<dyn StorageTxn + 'a>, mut txn: Box<dyn StorageTxn + 'a>,
_config: &ServerConfig, _config: &ServerConfig,
client_key: ClientKey, client_id: ClientId,
client: Client, client: Client,
) -> anyhow::Result<Option<(Uuid, Vec<u8>)>> { ) -> anyhow::Result<Option<(Uuid, Vec<u8>)>> {
Ok(if let Some(snap) = client.snapshot { Ok(if let Some(snap) = client.snapshot {
txn.get_snapshot_data(client_key, snap.version_id)? txn.get_snapshot_data(client_id, snap.version_id)?
.map(|data| (snap.version_id, data)) .map(|data| (snap.version_id, data))
} else { } else {
None None
@ -354,16 +354,16 @@ mod test {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
txn.new_client(client_key, NIL_VERSION_ID)?; txn.new_client(client_id, NIL_VERSION_ID)?;
// when no snapshot exists, the first version is NotFound // when no snapshot exists, the first version is NotFound
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
assert_eq!( assert_eq!(
get_child_version( get_child_version(
txn, txn,
&ServerConfig::default(), &ServerConfig::default(),
client_key, client_id,
client, client,
NIL_VERSION_ID NIL_VERSION_ID
)?, )?,
@ -378,11 +378,11 @@ mod test {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
txn.new_client(client_key, Uuid::new_v4())?; txn.new_client(client_id, Uuid::new_v4())?;
txn.set_snapshot( txn.set_snapshot(
client_key, client_id,
Snapshot { Snapshot {
version_id: Uuid::new_v4(), version_id: Uuid::new_v4(),
versions_since: 0, versions_since: 0,
@ -392,12 +392,12 @@ mod test {
)?; )?;
// when a snapshot exists, the first version is GONE // when a snapshot exists, the first version is GONE
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
assert_eq!( assert_eq!(
get_child_version( get_child_version(
txn, txn,
&ServerConfig::default(), &ServerConfig::default(),
client_key, client_id,
client, client,
NIL_VERSION_ID NIL_VERSION_ID
)?, )?,
@ -412,19 +412,19 @@ mod test {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
// add a parent version, but not the requested child version // add a parent version, but not the requested child version
let parent_version_id = Uuid::new_v4(); let parent_version_id = Uuid::new_v4();
txn.new_client(client_key, parent_version_id)?; txn.new_client(client_id, parent_version_id)?;
txn.add_version(client_key, parent_version_id, NIL_VERSION_ID, vec![])?; txn.add_version(client_id, parent_version_id, NIL_VERSION_ID, vec![])?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
assert_eq!( assert_eq!(
get_child_version( get_child_version(
txn, txn,
&ServerConfig::default(), &ServerConfig::default(),
client_key, client_id,
client, client,
parent_version_id parent_version_id
)?, )?,
@ -439,19 +439,19 @@ mod test {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
// make up a parent version id, but neither that version // make up a parent version id, but neither that version
// nor its child exists (presumed to have been deleted) // nor its child exists (presumed to have been deleted)
let parent_version_id = Uuid::new_v4(); let parent_version_id = Uuid::new_v4();
txn.new_client(client_key, Uuid::new_v4())?; txn.new_client(client_id, Uuid::new_v4())?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
assert_eq!( assert_eq!(
get_child_version( get_child_version(
txn, txn,
&ServerConfig::default(), &ServerConfig::default(),
client_key, client_id,
client, client,
parent_version_id parent_version_id
)?, )?,
@ -466,25 +466,25 @@ mod test {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let version_id = Uuid::new_v4(); let version_id = Uuid::new_v4();
let parent_version_id = Uuid::new_v4(); let parent_version_id = Uuid::new_v4();
let history_segment = b"abcd".to_vec(); let history_segment = b"abcd".to_vec();
txn.new_client(client_key, version_id)?; txn.new_client(client_id, version_id)?;
txn.add_version( txn.add_version(
client_key, client_id,
version_id, version_id,
parent_version_id, parent_version_id,
history_segment.clone(), history_segment.clone(),
)?; )?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
assert_eq!( assert_eq!(
get_child_version( get_child_version(
txn, txn,
&ServerConfig::default(), &ServerConfig::default(),
client_key, client_id,
client, client,
parent_version_id parent_version_id
)?, )?,
@ -506,24 +506,24 @@ mod test {
) -> anyhow::Result<(Uuid, Vec<Uuid>)> { ) -> anyhow::Result<(Uuid, Vec<Uuid>)> {
init_logging(); init_logging();
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let mut versions = vec![]; let mut versions = vec![];
let mut version_id = Uuid::nil(); let mut version_id = Uuid::nil();
txn.new_client(client_key, Uuid::nil())?; txn.new_client(client_id, Uuid::nil())?;
for vnum in 0..num_versions { for vnum in 0..num_versions {
let parent_version_id = version_id; let parent_version_id = version_id;
version_id = Uuid::new_v4(); version_id = Uuid::new_v4();
versions.push(version_id); versions.push(version_id);
txn.add_version( txn.add_version(
client_key, client_id,
version_id, version_id,
parent_version_id, parent_version_id,
vec![0, 0, vnum as u8], vec![0, 0, vnum as u8],
)?; )?;
if Some(vnum) == snapshot_version { if Some(vnum) == snapshot_version {
txn.set_snapshot( txn.set_snapshot(
client_key, client_id,
Snapshot { Snapshot {
version_id, version_id,
versions_since: 0, versions_since: 0,
@ -534,13 +534,13 @@ mod test {
} }
} }
Ok((client_key, versions)) Ok((client_id, versions))
} }
/// Utility function to check the results of an add_version call /// Utility function to check the results of an add_version call
fn av_success_check( fn av_success_check(
storage: &InMemoryStorage, storage: &InMemoryStorage,
client_key: Uuid, client_id: Uuid,
existing_versions: &[Uuid], existing_versions: &[Uuid],
result: (AddVersionResult, SnapshotUrgency), result: (AddVersionResult, SnapshotUrgency),
expected_history: Vec<u8>, expected_history: Vec<u8>,
@ -554,11 +554,11 @@ mod test {
// verify that the storage was updated // verify that the storage was updated
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
assert_eq!(client.latest_version_id, new_version_id); assert_eq!(client.latest_version_id, new_version_id);
let parent_version_id = existing_versions.last().cloned().unwrap_or_else(Uuid::nil); let parent_version_id = existing_versions.last().cloned().unwrap_or_else(Uuid::nil);
let version = txn.get_version(client_key, new_version_id)?.unwrap(); let version = txn.get_version(client_id, new_version_id)?.unwrap();
assert_eq!(version.version_id, new_version_id); assert_eq!(version.version_id, new_version_id);
assert_eq!(version.parent_version_id, parent_version_id); assert_eq!(version.parent_version_id, parent_version_id);
assert_eq!(version.history_segment, expected_history); assert_eq!(version.history_segment, expected_history);
@ -574,17 +574,17 @@ mod test {
#[test] #[test]
fn add_version_conflict() -> anyhow::Result<()> { fn add_version_conflict() -> anyhow::Result<()> {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let (client_key, versions) = av_setup(&storage, 3, None, None)?; let (client_id, versions) = av_setup(&storage, 3, None, None)?;
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
// try to add a child of a version other than the latest // try to add a child of a version other than the latest
assert_eq!( assert_eq!(
add_version( add_version(
txn, txn,
&ServerConfig::default(), &ServerConfig::default(),
client_key, client_id,
client, client,
versions[1], versions[1],
vec![3, 6, 9] vec![3, 6, 9]
@ -596,10 +596,10 @@ mod test {
// verify that the storage wasn't updated // verify that the storage wasn't updated
txn = storage.txn()?; txn = storage.txn()?;
assert_eq!( assert_eq!(
txn.get_client(client_key)?.unwrap().latest_version_id, txn.get_client(client_id)?.unwrap().latest_version_id,
versions[2] versions[2]
); );
assert_eq!(txn.get_version_by_parent(client_key, versions[2])?, None); assert_eq!(txn.get_version_by_parent(client_id, versions[2])?, None);
Ok(()) Ok(())
} }
@ -607,15 +607,15 @@ mod test {
#[test] #[test]
fn add_version_with_existing_history() -> anyhow::Result<()> { fn add_version_with_existing_history() -> anyhow::Result<()> {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let (client_key, versions) = av_setup(&storage, 1, None, None)?; let (client_id, versions) = av_setup(&storage, 1, None, None)?;
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
let result = add_version( let result = add_version(
txn, txn,
&ServerConfig::default(), &ServerConfig::default(),
client_key, client_id,
client, client,
versions[0], versions[0],
vec![3, 6, 9], vec![3, 6, 9],
@ -623,7 +623,7 @@ mod test {
av_success_check( av_success_check(
&storage, &storage,
client_key, client_id,
&versions, &versions,
result, result,
vec![3, 6, 9], vec![3, 6, 9],
@ -637,16 +637,16 @@ mod test {
#[test] #[test]
fn add_version_with_no_history() -> anyhow::Result<()> { fn add_version_with_no_history() -> anyhow::Result<()> {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let (client_key, versions) = av_setup(&storage, 0, None, None)?; let (client_id, versions) = av_setup(&storage, 0, None, None)?;
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
let parent_version_id = Uuid::nil(); let parent_version_id = Uuid::nil();
let result = add_version( let result = add_version(
txn, txn,
&ServerConfig::default(), &ServerConfig::default(),
client_key, client_id,
client, client,
parent_version_id, parent_version_id,
vec![3, 6, 9], vec![3, 6, 9],
@ -654,7 +654,7 @@ mod test {
av_success_check( av_success_check(
&storage, &storage,
client_key, client_id,
&versions, &versions,
result, result,
vec![3, 6, 9], vec![3, 6, 9],
@ -668,15 +668,15 @@ mod test {
#[test] #[test]
fn add_version_success_recent_snapshot() -> anyhow::Result<()> { fn add_version_success_recent_snapshot() -> anyhow::Result<()> {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let (client_key, versions) = av_setup(&storage, 1, Some(0), None)?; let (client_id, versions) = av_setup(&storage, 1, Some(0), None)?;
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
let result = add_version( let result = add_version(
txn, txn,
&ServerConfig::default(), &ServerConfig::default(),
client_key, client_id,
client, client,
versions[0], versions[0],
vec![1, 2, 3], vec![1, 2, 3],
@ -684,7 +684,7 @@ mod test {
av_success_check( av_success_check(
&storage, &storage,
client_key, client_id,
&versions, &versions,
result, result,
vec![1, 2, 3], vec![1, 2, 3],
@ -699,15 +699,15 @@ mod test {
fn add_version_success_aged_snapshot() -> anyhow::Result<()> { fn add_version_success_aged_snapshot() -> anyhow::Result<()> {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
// one snapshot, but it was 50 days ago // one snapshot, but it was 50 days ago
let (client_key, versions) = av_setup(&storage, 1, Some(0), Some(50))?; let (client_id, versions) = av_setup(&storage, 1, Some(0), Some(50))?;
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
let result = add_version( let result = add_version(
txn, txn,
&ServerConfig::default(), &ServerConfig::default(),
client_key, client_id,
client, client,
versions[0], versions[0],
vec![1, 2, 3], vec![1, 2, 3],
@ -715,7 +715,7 @@ mod test {
av_success_check( av_success_check(
&storage, &storage,
client_key, client_id,
&versions, &versions,
result, result,
vec![1, 2, 3], vec![1, 2, 3],
@ -730,10 +730,10 @@ mod test {
fn add_version_success_snapshot_many_versions_ago() -> anyhow::Result<()> { fn add_version_success_snapshot_many_versions_ago() -> anyhow::Result<()> {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
// one snapshot, but it was 50 versions ago // one snapshot, but it was 50 versions ago
let (client_key, versions) = av_setup(&storage, 50, Some(0), None)?; let (client_id, versions) = av_setup(&storage, 50, Some(0), None)?;
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
let result = add_version( let result = add_version(
txn, txn,
@ -741,7 +741,7 @@ mod test {
snapshot_versions: 30, snapshot_versions: 30,
..ServerConfig::default() ..ServerConfig::default()
}, },
client_key, client_id,
client, client,
versions[49], versions[49],
vec![1, 2, 3], vec![1, 2, 3],
@ -749,7 +749,7 @@ mod test {
av_success_check( av_success_check(
&storage, &storage,
client_key, client_id,
&versions, &versions,
result, result,
vec![1, 2, 3], vec![1, 2, 3],
@ -766,19 +766,19 @@ mod test {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let version_id = Uuid::new_v4(); let version_id = Uuid::new_v4();
// set up a task DB with one version in it // set up a task DB with one version in it
txn.new_client(client_key, version_id)?; txn.new_client(client_id, version_id)?;
txn.add_version(client_key, version_id, NIL_VERSION_ID, vec![])?; txn.add_version(client_id, version_id, NIL_VERSION_ID, vec![])?;
// add a snapshot for that version // add a snapshot for that version
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
add_snapshot( add_snapshot(
txn, txn,
&ServerConfig::default(), &ServerConfig::default(),
client_key, client_id,
client, client,
version_id, version_id,
vec![1, 2, 3], vec![1, 2, 3],
@ -786,12 +786,12 @@ mod test {
// verify the snapshot // verify the snapshot
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
let snapshot = client.snapshot.unwrap(); let snapshot = client.snapshot.unwrap();
assert_eq!(snapshot.version_id, version_id); assert_eq!(snapshot.version_id, version_id);
assert_eq!(snapshot.versions_since, 0); assert_eq!(snapshot.versions_since, 0);
assert_eq!( assert_eq!(
txn.get_snapshot_data(client_key, version_id).unwrap(), txn.get_snapshot_data(client_id, version_id).unwrap(),
Some(vec![1, 2, 3]) Some(vec![1, 2, 3])
); );
@ -804,21 +804,21 @@ mod test {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let version_id_1 = Uuid::new_v4(); let version_id_1 = Uuid::new_v4();
let version_id_2 = Uuid::new_v4(); let version_id_2 = Uuid::new_v4();
// set up a task DB with two versions in it // set up a task DB with two versions in it
txn.new_client(client_key, version_id_2)?; txn.new_client(client_id, version_id_2)?;
txn.add_version(client_key, version_id_1, NIL_VERSION_ID, vec![])?; txn.add_version(client_id, version_id_1, NIL_VERSION_ID, vec![])?;
txn.add_version(client_key, version_id_2, version_id_1, vec![])?; txn.add_version(client_id, version_id_2, version_id_1, vec![])?;
// add a snapshot for version 1 // add a snapshot for version 1
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
add_snapshot( add_snapshot(
txn, txn,
&ServerConfig::default(), &ServerConfig::default(),
client_key, client_id,
client, client,
version_id_1, version_id_1,
vec![1, 2, 3], vec![1, 2, 3],
@ -826,12 +826,12 @@ mod test {
// verify the snapshot // verify the snapshot
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
let snapshot = client.snapshot.unwrap(); let snapshot = client.snapshot.unwrap();
assert_eq!(snapshot.version_id, version_id_1); assert_eq!(snapshot.version_id, version_id_1);
assert_eq!(snapshot.versions_since, 0); assert_eq!(snapshot.versions_since, 0);
assert_eq!( assert_eq!(
txn.get_snapshot_data(client_key, version_id_1).unwrap(), txn.get_snapshot_data(client_id, version_id_1).unwrap(),
Some(vec![1, 2, 3]) Some(vec![1, 2, 3])
); );
@ -844,22 +844,22 @@ mod test {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let version_id_1 = Uuid::new_v4(); let version_id_1 = Uuid::new_v4();
let version_id_2 = Uuid::new_v4(); let version_id_2 = Uuid::new_v4();
// set up a task DB with two versions in it // set up a task DB with two versions in it
txn.new_client(client_key, version_id_2)?; txn.new_client(client_id, version_id_2)?;
txn.add_version(client_key, version_id_1, NIL_VERSION_ID, vec![])?; txn.add_version(client_id, version_id_1, NIL_VERSION_ID, vec![])?;
txn.add_version(client_key, version_id_2, version_id_1, vec![])?; txn.add_version(client_id, version_id_2, version_id_1, vec![])?;
// add a snapshot for unknown version // add a snapshot for unknown version
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
let version_id_unk = Uuid::new_v4(); let version_id_unk = Uuid::new_v4();
add_snapshot( add_snapshot(
txn, txn,
&ServerConfig::default(), &ServerConfig::default(),
client_key, client_id,
client, client,
version_id_unk, version_id_unk,
vec![1, 2, 3], vec![1, 2, 3],
@ -867,7 +867,7 @@ mod test {
// verify the snapshot does not exist // verify the snapshot does not exist
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
assert!(client.snapshot.is_none()); assert!(client.snapshot.is_none());
Ok(()) Ok(())
@ -879,26 +879,26 @@ mod test {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let mut version_id = Uuid::new_v4(); let mut version_id = Uuid::new_v4();
let mut parent_version_id = Uuid::nil(); let mut parent_version_id = Uuid::nil();
let mut version_ids = vec![]; let mut version_ids = vec![];
// set up a task DB with 10 versions in it (oldest to newest) // set up a task DB with 10 versions in it (oldest to newest)
txn.new_client(client_key, Uuid::nil())?; txn.new_client(client_id, Uuid::nil())?;
for _ in 0..10 { for _ in 0..10 {
txn.add_version(client_key, version_id, parent_version_id, vec![])?; txn.add_version(client_id, version_id, parent_version_id, vec![])?;
version_ids.push(version_id); version_ids.push(version_id);
parent_version_id = version_id; parent_version_id = version_id;
version_id = Uuid::new_v4(); version_id = Uuid::new_v4();
} }
// add a snapshot for the earliest of those // add a snapshot for the earliest of those
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
add_snapshot( add_snapshot(
txn, txn,
&ServerConfig::default(), &ServerConfig::default(),
client_key, client_id,
client, client,
version_ids[0], version_ids[0],
vec![1, 2, 3], vec![1, 2, 3],
@ -906,7 +906,7 @@ mod test {
// verify the snapshot does not exist // verify the snapshot does not exist
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
assert!(client.snapshot.is_none()); assert!(client.snapshot.is_none());
Ok(()) Ok(())
@ -918,22 +918,22 @@ mod test {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let mut version_id = Uuid::new_v4(); let mut version_id = Uuid::new_v4();
let mut parent_version_id = Uuid::nil(); let mut parent_version_id = Uuid::nil();
let mut version_ids = vec![]; let mut version_ids = vec![];
// set up a task DB with 5 versions in it (oldest to newest) and a snapshot of the middle // set up a task DB with 5 versions in it (oldest to newest) and a snapshot of the middle
// one // one
txn.new_client(client_key, Uuid::nil())?; txn.new_client(client_id, Uuid::nil())?;
for _ in 0..5 { for _ in 0..5 {
txn.add_version(client_key, version_id, parent_version_id, vec![])?; txn.add_version(client_id, version_id, parent_version_id, vec![])?;
version_ids.push(version_id); version_ids.push(version_id);
parent_version_id = version_id; parent_version_id = version_id;
version_id = Uuid::new_v4(); version_id = Uuid::new_v4();
} }
txn.set_snapshot( txn.set_snapshot(
client_key, client_id,
Snapshot { Snapshot {
version_id: version_ids[2], version_id: version_ids[2],
versions_since: 2, versions_since: 2,
@ -943,11 +943,11 @@ mod test {
)?; )?;
// add a snapshot for the earliest of those // add a snapshot for the earliest of those
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
add_snapshot( add_snapshot(
txn, txn,
&ServerConfig::default(), &ServerConfig::default(),
client_key, client_id,
client, client,
version_ids[0], version_ids[0],
vec![9, 9, 9], vec![9, 9, 9],
@ -955,12 +955,12 @@ mod test {
// verify the snapshot was not replaced // verify the snapshot was not replaced
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
let snapshot = client.snapshot.unwrap(); let snapshot = client.snapshot.unwrap();
assert_eq!(snapshot.version_id, version_ids[2]); assert_eq!(snapshot.version_id, version_ids[2]);
assert_eq!(snapshot.versions_since, 2); assert_eq!(snapshot.versions_since, 2);
assert_eq!( assert_eq!(
txn.get_snapshot_data(client_key, version_ids[2]).unwrap(), txn.get_snapshot_data(client_id, version_ids[2]).unwrap(),
Some(vec![1, 2, 3]) Some(vec![1, 2, 3])
); );
@ -973,17 +973,17 @@ mod test {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
// just set up the client // just set up the client
txn.new_client(client_key, NIL_VERSION_ID)?; txn.new_client(client_id, NIL_VERSION_ID)?;
// add a snapshot for the nil version // add a snapshot for the nil version
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
add_snapshot( add_snapshot(
txn, txn,
&ServerConfig::default(), &ServerConfig::default(),
client_key, client_id,
client, client,
NIL_VERSION_ID, NIL_VERSION_ID,
vec![9, 9, 9], vec![9, 9, 9],
@ -991,7 +991,7 @@ mod test {
// verify the snapshot does not exist // verify the snapshot does not exist
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
assert!(client.snapshot.is_none()); assert!(client.snapshot.is_none());
Ok(()) Ok(())
@ -1003,13 +1003,13 @@ mod test {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let data = vec![1, 2, 3]; let data = vec![1, 2, 3];
let snapshot_version_id = Uuid::new_v4(); let snapshot_version_id = Uuid::new_v4();
txn.new_client(client_key, snapshot_version_id)?; txn.new_client(client_id, snapshot_version_id)?;
txn.set_snapshot( txn.set_snapshot(
client_key, client_id,
Snapshot { Snapshot {
version_id: snapshot_version_id, version_id: snapshot_version_id,
versions_since: 3, versions_since: 3,
@ -1018,9 +1018,9 @@ mod test {
data.clone(), data.clone(),
)?; )?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
assert_eq!( assert_eq!(
get_snapshot(txn, &ServerConfig::default(), client_key, client)?, get_snapshot(txn, &ServerConfig::default(), client_id, client)?,
Some((snapshot_version_id, data)) Some((snapshot_version_id, data))
); );
@ -1033,13 +1033,13 @@ mod test {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
txn.new_client(client_key, NIL_VERSION_ID)?; txn.new_client(client_id, NIL_VERSION_ID)?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
assert_eq!( assert_eq!(
get_snapshot(txn, &ServerConfig::default(), client_key, client)?, get_snapshot(txn, &ServerConfig::default(), client_id, client)?,
None None
); );

97
taskchampion/sync-server/src/storage/inmemory.rs
View file

@ -3,16 +3,16 @@ use std::collections::HashMap;
use std::sync::{Mutex, MutexGuard}; use std::sync::{Mutex, MutexGuard};
struct Inner { struct Inner {
/// Clients, indexed by client_key /// Clients, indexed by client_id
clients: HashMap<Uuid, Client>, clients: HashMap<Uuid, Client>,
/// Snapshot data, indexed by client key /// Snapshot data, indexed by client id
snapshots: HashMap<Uuid, Vec<u8>>, snapshots: HashMap<Uuid, Vec<u8>>,
/// Versions, indexed by (client_key, version_id) /// Versions, indexed by (client_id, version_id)
versions: HashMap<(Uuid, Uuid), Version>, versions: HashMap<(Uuid, Uuid), Version>,
/// Child versions, indexed by (client_key, parent_version_id) /// Child versions, indexed by (client_id, parent_version_id)
children: HashMap<(Uuid, Uuid), Uuid>, children: HashMap<(Uuid, Uuid), Uuid>,
} }
@ -42,16 +42,16 @@ impl Storage for InMemoryStorage {
} }
impl<'a> StorageTxn for InnerTxn<'a> { impl<'a> StorageTxn for InnerTxn<'a> {
fn get_client(&mut self, client_key: Uuid) -> anyhow::Result<Option<Client>> { fn get_client(&mut self, client_id: Uuid) -> anyhow::Result<Option<Client>> {
Ok(self.0.clients.get(&client_key).cloned()) Ok(self.0.clients.get(&client_id).cloned())
} }
fn new_client(&mut self, client_key: Uuid, latest_version_id: Uuid) -> anyhow::Result<()> { fn new_client(&mut self, client_id: Uuid, latest_version_id: Uuid) -> anyhow::Result<()> {
if self.0.clients.get(&client_key).is_some() { if self.0.clients.get(&client_id).is_some() {
return Err(anyhow::anyhow!("Client {} already exists", client_key)); return Err(anyhow::anyhow!("Client {} already exists", client_id));
} }
self.0.clients.insert( self.0.clients.insert(
client_key, client_id,
Client { Client {
latest_version_id, latest_version_id,
snapshot: None, snapshot: None,
@ -62,44 +62,44 @@ impl<'a> StorageTxn for InnerTxn<'a> {
fn set_snapshot( fn set_snapshot(
&mut self, &mut self,
client_key: Uuid, client_id: Uuid,
snapshot: Snapshot, snapshot: Snapshot,
data: Vec<u8>, data: Vec<u8>,
) -> anyhow::Result<()> { ) -> anyhow::Result<()> {
let mut client = self let mut client = self
.0 .0
.clients .clients
.get_mut(&client_key) .get_mut(&client_id)
.ok_or_else(|| anyhow::anyhow!("no such client"))?; .ok_or_else(|| anyhow::anyhow!("no such client"))?;
client.snapshot = Some(snapshot); client.snapshot = Some(snapshot);
self.0.snapshots.insert(client_key, data); self.0.snapshots.insert(client_id, data);
Ok(()) Ok(())
} }
fn get_snapshot_data( fn get_snapshot_data(
&mut self, &mut self,
client_key: Uuid, client_id: Uuid,
version_id: Uuid, version_id: Uuid,
) -> anyhow::Result<Option<Vec<u8>>> { ) -> anyhow::Result<Option<Vec<u8>>> {
// sanity check // sanity check
let client = self.0.clients.get(&client_key); let client = self.0.clients.get(&client_id);
let client = client.ok_or_else(|| anyhow::anyhow!("no such client"))?; let client = client.ok_or_else(|| anyhow::anyhow!("no such client"))?;
if Some(&version_id) != client.snapshot.as_ref().map(|snap| &snap.version_id) { if Some(&version_id) != client.snapshot.as_ref().map(|snap| &snap.version_id) {
return Err(anyhow::anyhow!("unexpected snapshot_version_id")); return Err(anyhow::anyhow!("unexpected snapshot_version_id"));
} }
Ok(self.0.snapshots.get(&client_key).cloned()) Ok(self.0.snapshots.get(&client_id).cloned())
} }
fn get_version_by_parent( fn get_version_by_parent(
&mut self, &mut self,
client_key: Uuid, client_id: Uuid,
parent_version_id: Uuid, parent_version_id: Uuid,
) -> anyhow::Result<Option<Version>> { ) -> anyhow::Result<Option<Version>> {
if let Some(parent_version_id) = self.0.children.get(&(client_key, parent_version_id)) { if let Some(parent_version_id) = self.0.children.get(&(client_id, parent_version_id)) {
Ok(self Ok(self
.0 .0
.versions .versions
.get(&(client_key, *parent_version_id)) .get(&(client_id, *parent_version_id))
.cloned()) .cloned())
} else { } else {
Ok(None) Ok(None)
@ -108,15 +108,15 @@ impl<'a> StorageTxn for InnerTxn<'a> {
fn get_version( fn get_version(
&mut self, &mut self,
client_key: Uuid, client_id: Uuid,
version_id: Uuid, version_id: Uuid,
) -> anyhow::Result<Option<Version>> { ) -> anyhow::Result<Option<Version>> {
Ok(self.0.versions.get(&(client_key, version_id)).cloned()) Ok(self.0.versions.get(&(client_id, version_id)).cloned())
} }
fn add_version( fn add_version(
&mut self, &mut self,
client_key: Uuid, client_id: Uuid,
version_id: Uuid, version_id: Uuid,
parent_version_id: Uuid, parent_version_id: Uuid,
history_segment: Vec<u8>, history_segment: Vec<u8>,
@ -128,19 +128,19 @@ impl<'a> StorageTxn for InnerTxn<'a> {
history_segment, history_segment,
}; };
if let Some(client) = self.0.clients.get_mut(&client_key) { if let Some(client) = self.0.clients.get_mut(&client_id) {
client.latest_version_id = version_id; client.latest_version_id = version_id;
if let Some(ref mut snap) = client.snapshot { if let Some(ref mut snap) = client.snapshot {
snap.versions_since += 1; snap.versions_since += 1;
} }
} else { } else {
return Err(anyhow::anyhow!("Client {} does not exist", client_key)); return Err(anyhow::anyhow!("Client {} does not exist", client_id));
} }
self.0 self.0
.children .children
.insert((client_key, parent_version_id), version_id); .insert((client_id, parent_version_id), version_id);
self.0.versions.insert((client_key, version_id), version); self.0.versions.insert((client_id, version_id), version);
Ok(()) Ok(())
} }
@ -169,18 +169,18 @@ mod test {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let latest_version_id = Uuid::new_v4(); let latest_version_id = Uuid::new_v4();
txn.new_client(client_key, latest_version_id)?; txn.new_client(client_id, latest_version_id)?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
assert_eq!(client.latest_version_id, latest_version_id); assert_eq!(client.latest_version_id, latest_version_id);
assert!(client.snapshot.is_none()); assert!(client.snapshot.is_none());
let latest_version_id = Uuid::new_v4(); let latest_version_id = Uuid::new_v4();
txn.add_version(client_key, latest_version_id, Uuid::new_v4(), vec![1, 1])?; txn.add_version(client_id, latest_version_id, Uuid::new_v4(), vec![1, 1])?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
assert_eq!(client.latest_version_id, latest_version_id); assert_eq!(client.latest_version_id, latest_version_id);
assert!(client.snapshot.is_none()); assert!(client.snapshot.is_none());
@ -189,9 +189,9 @@ mod test {
timestamp: Utc::now(), timestamp: Utc::now(),
versions_since: 4, versions_since: 4,
}; };
txn.set_snapshot(client_key, snap.clone(), vec![1, 2, 3])?; txn.set_snapshot(client_id, snap.clone(), vec![1, 2, 3])?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
assert_eq!(client.latest_version_id, latest_version_id); assert_eq!(client.latest_version_id, latest_version_id);
assert_eq!(client.snapshot.unwrap(), snap); assert_eq!(client.snapshot.unwrap(), snap);
@ -212,14 +212,14 @@ mod test {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let version_id = Uuid::new_v4(); let version_id = Uuid::new_v4();
let parent_version_id = Uuid::new_v4(); let parent_version_id = Uuid::new_v4();
let history_segment = b"abc".to_vec(); let history_segment = b"abc".to_vec();
txn.new_client(client_key, parent_version_id)?; txn.new_client(client_id, parent_version_id)?;
txn.add_version( txn.add_version(
client_key, client_id,
version_id, version_id,
parent_version_id, parent_version_id,
history_segment.clone(), history_segment.clone(),
@ -232,11 +232,11 @@ mod test {
}; };
let version = txn let version = txn
.get_version_by_parent(client_key, parent_version_id)? .get_version_by_parent(client_id, parent_version_id)?
.unwrap(); .unwrap();
assert_eq!(version, expected); assert_eq!(version, expected);
let version = txn.get_version(client_key, version_id)?.unwrap(); let version = txn.get_version(client_id, version_id)?.unwrap();
assert_eq!(version, expected); assert_eq!(version, expected);
Ok(()) Ok(())
@ -247,40 +247,39 @@ mod test {
let storage = InMemoryStorage::new(); let storage = InMemoryStorage::new();
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
txn.new_client(client_key, Uuid::new_v4())?; txn.new_client(client_id, Uuid::new_v4())?;
assert!(txn.get_client(client_key)?.unwrap().snapshot.is_none()); assert!(txn.get_client(client_id)?.unwrap().snapshot.is_none());
let snap = Snapshot { let snap = Snapshot {
version_id: Uuid::new_v4(), version_id: Uuid::new_v4(),
timestamp: Utc::now(), timestamp: Utc::now(),
versions_since: 3, versions_since: 3,
}; };
txn.set_snapshot(client_key, snap.clone(), vec![9, 8, 9])?; txn.set_snapshot(client_id, snap.clone(), vec![9, 8, 9])?;
assert_eq!( assert_eq!(
txn.get_snapshot_data(client_key, snap.version_id)?.unwrap(), txn.get_snapshot_data(client_id, snap.version_id)?.unwrap(),
vec![9, 8, 9] vec![9, 8, 9]
); );
assert_eq!(txn.get_client(client_key)?.unwrap().snapshot, Some(snap)); assert_eq!(txn.get_client(client_id)?.unwrap().snapshot, Some(snap));
let snap2 = Snapshot { let snap2 = Snapshot {
version_id: Uuid::new_v4(), version_id: Uuid::new_v4(),
timestamp: Utc::now(), timestamp: Utc::now(),
versions_since: 10, versions_since: 10,
}; };
txn.set_snapshot(client_key, snap2.clone(), vec![0, 2, 4, 6])?; txn.set_snapshot(client_id, snap2.clone(), vec![0, 2, 4, 6])?;
assert_eq!( assert_eq!(
txn.get_snapshot_data(client_key, snap2.version_id)? txn.get_snapshot_data(client_id, snap2.version_id)?.unwrap(),
.unwrap(),
vec![0, 2, 4, 6] vec![0, 2, 4, 6]
); );
assert_eq!(txn.get_client(client_key)?.unwrap().snapshot, Some(snap2)); assert_eq!(txn.get_client(client_id)?.unwrap().snapshot, Some(snap2));
// check that mismatched version is detected // check that mismatched version is detected
assert!(txn.get_snapshot_data(client_key, Uuid::new_v4()).is_err()); assert!(txn.get_snapshot_data(client_id, Uuid::new_v4()).is_err());
Ok(()) Ok(())
} }

19
taskchampion/sync-server/src/storage/mod.rs
View file

@ -39,15 +39,15 @@ pub struct Version {
pub trait StorageTxn { pub trait StorageTxn {
/// Get information about the given client /// Get information about the given client
fn get_client(&mut self, client_key: Uuid) -> anyhow::Result<Option<Client>>; fn get_client(&mut self, client_id: Uuid) -> anyhow::Result<Option<Client>>;
/// Create a new client with the given latest_version_id /// Create a new client with the given latest_version_id
fn new_client(&mut self, client_key: Uuid, latest_version_id: Uuid) -> anyhow::Result<()>; fn new_client(&mut self, client_id: Uuid, latest_version_id: Uuid) -> anyhow::Result<()>;
/// Set the client's most recent snapshot. /// Set the client's most recent snapshot.
fn set_snapshot( fn set_snapshot(
&mut self, &mut self,
client_key: Uuid, client_id: Uuid,
snapshot: Snapshot, snapshot: Snapshot,
data: Vec<u8>, data: Vec<u8>,
) -> anyhow::Result<()>; ) -> anyhow::Result<()>;
@ -56,30 +56,27 @@ pub trait StorageTxn {
/// is used to verify that the snapshot is for the correct version. /// is used to verify that the snapshot is for the correct version.
fn get_snapshot_data( fn get_snapshot_data(
&mut self, &mut self,
client_key: Uuid, client_id: Uuid,
version_id: Uuid, version_id: Uuid,
) -> anyhow::Result<Option<Vec<u8>>>; ) -> anyhow::Result<Option<Vec<u8>>>;
/// Get a version, indexed by parent version id /// Get a version, indexed by parent version id
fn get_version_by_parent( fn get_version_by_parent(
&mut self, &mut self,
client_key: Uuid, client_id: Uuid,
parent_version_id: Uuid, parent_version_id: Uuid,
) -> anyhow::Result<Option<Version>>; ) -> anyhow::Result<Option<Version>>;
/// Get a version, indexed by its own version id /// Get a version, indexed by its own version id
fn get_version( fn get_version(&mut self, client_id: Uuid, version_id: Uuid)
&mut self, -> anyhow::Result<Option<Version>>;
client_key: Uuid,
version_id: Uuid,
) -> anyhow::Result<Option<Version>>;
/// Add a version (that must not already exist), and /// Add a version (that must not already exist), and
/// - update latest_version_id /// - update latest_version_id
/// - increment snapshot.versions_since /// - increment snapshot.versions_since
fn add_version( fn add_version(
&mut self, &mut self,
client_key: Uuid, client_id: Uuid,
version_id: Uuid, version_id: Uuid,
parent_version_id: Uuid, parent_version_id: Uuid,
history_segment: Vec<u8>, history_segment: Vec<u8>,

97
taskchampion/sync-server/src/storage/sqlite.rs
View file

@ -53,13 +53,13 @@ impl SqliteStorage {
let queries = vec![ let queries = vec![
"CREATE TABLE IF NOT EXISTS clients ( "CREATE TABLE IF NOT EXISTS clients (
client_key STRING PRIMARY KEY, client_id STRING PRIMARY KEY,
latest_version_id STRING, latest_version_id STRING,
snapshot_version_id STRING, snapshot_version_id STRING,
versions_since_snapshot INTEGER, versions_since_snapshot INTEGER,
snapshot_timestamp INTEGER, snapshot_timestamp INTEGER,
snapshot BLOB);", snapshot BLOB);",
"CREATE TABLE IF NOT EXISTS versions (version_id STRING PRIMARY KEY, client_key STRING, parent_version_id STRING, history_segment BLOB);", "CREATE TABLE IF NOT EXISTS versions (version_id STRING PRIMARY KEY, client_id STRING, parent_version_id STRING, history_segment BLOB);",
"CREATE INDEX IF NOT EXISTS versions_by_parent ON versions (parent_version_id);", "CREATE INDEX IF NOT EXISTS versions_by_parent ON versions (parent_version_id);",
]; ];
for q in queries { for q in queries {
@ -96,14 +96,14 @@ impl Txn {
fn get_version_impl( fn get_version_impl(
&mut self, &mut self,
query: &'static str, query: &'static str,
client_key: Uuid, client_id: Uuid,
version_id_arg: Uuid, version_id_arg: Uuid,
) -> anyhow::Result<Option<Version>> { ) -> anyhow::Result<Option<Version>> {
let t = self.get_txn()?; let t = self.get_txn()?;
let r = t let r = t
.query_row( .query_row(
query, query,
params![&StoredUuid(version_id_arg), &StoredUuid(client_key)], params![&StoredUuid(version_id_arg), &StoredUuid(client_id)],
|r| { |r| {
let version_id: StoredUuid = r.get("version_id")?; let version_id: StoredUuid = r.get("version_id")?;
let parent_version_id: StoredUuid = r.get("parent_version_id")?; let parent_version_id: StoredUuid = r.get("parent_version_id")?;
@ -122,7 +122,7 @@ impl Txn {
} }
impl StorageTxn for Txn { impl StorageTxn for Txn {
fn get_client(&mut self, client_key: Uuid) -> anyhow::Result<Option<Client>> { fn get_client(&mut self, client_id: Uuid) -> anyhow::Result<Option<Client>> {
let t = self.get_txn()?; let t = self.get_txn()?;
let result: Option<Client> = t let result: Option<Client> = t
.query_row( .query_row(
@ -132,9 +132,9 @@ impl StorageTxn for Txn {
versions_since_snapshot, versions_since_snapshot,
snapshot_version_id snapshot_version_id
FROM clients FROM clients
WHERE client_key = ? WHERE client_id = ?
LIMIT 1", LIMIT 1",
[&StoredUuid(client_key)], [&StoredUuid(client_id)],
|r| { |r| {
let latest_version_id: StoredUuid = r.get(0)?; let latest_version_id: StoredUuid = r.get(0)?;
let snapshot_timestamp: Option<i64> = r.get(1)?; let snapshot_timestamp: Option<i64> = r.get(1)?;
@ -166,12 +166,12 @@ impl StorageTxn for Txn {
Ok(result) Ok(result)
} }
fn new_client(&mut self, client_key: Uuid, latest_version_id: Uuid) -> anyhow::Result<()> { fn new_client(&mut self, client_id: Uuid, latest_version_id: Uuid) -> anyhow::Result<()> {
let t = self.get_txn()?; let t = self.get_txn()?;
t.execute( t.execute(
"INSERT OR REPLACE INTO clients (client_key, latest_version_id) VALUES (?, ?)", "INSERT OR REPLACE INTO clients (client_id, latest_version_id) VALUES (?, ?)",
params![&StoredUuid(client_key), &StoredUuid(latest_version_id)], params![&StoredUuid(client_id), &StoredUuid(latest_version_id)],
) )
.context("Error creating/updating client")?; .context("Error creating/updating client")?;
t.commit()?; t.commit()?;
@ -180,7 +180,7 @@ impl StorageTxn for Txn {
fn set_snapshot( fn set_snapshot(
&mut self, &mut self,
client_key: Uuid, client_id: Uuid,
snapshot: Snapshot, snapshot: Snapshot,
data: Vec<u8>, data: Vec<u8>,
) -> anyhow::Result<()> { ) -> anyhow::Result<()> {
@ -193,13 +193,13 @@ impl StorageTxn for Txn {
snapshot_timestamp = ?, snapshot_timestamp = ?,
versions_since_snapshot = ?, versions_since_snapshot = ?,
snapshot = ? snapshot = ?
WHERE client_key = ?", WHERE client_id = ?",
params![ params![
&StoredUuid(snapshot.version_id), &StoredUuid(snapshot.version_id),
snapshot.timestamp.timestamp(), snapshot.timestamp.timestamp(),
snapshot.versions_since, snapshot.versions_since,
data, data,
&StoredUuid(client_key), &StoredUuid(client_id),
], ],
) )
.context("Error creating/updating snapshot")?; .context("Error creating/updating snapshot")?;
@ -209,14 +209,14 @@ impl StorageTxn for Txn {
fn get_snapshot_data( fn get_snapshot_data(
&mut self, &mut self,
client_key: Uuid, client_id: Uuid,
version_id: Uuid, version_id: Uuid,
) -> anyhow::Result<Option<Vec<u8>>> { ) -> anyhow::Result<Option<Vec<u8>>> {
let t = self.get_txn()?; let t = self.get_txn()?;
let r = t let r = t
.query_row( .query_row(
"SELECT snapshot, snapshot_version_id FROM clients WHERE client_key = ?", "SELECT snapshot, snapshot_version_id FROM clients WHERE client_id = ?",
params![&StoredUuid(client_key)], params![&StoredUuid(client_id)],
|r| { |r| {
let v: StoredUuid = r.get("snapshot_version_id")?; let v: StoredUuid = r.get("snapshot_version_id")?;
let d: Vec<u8> = r.get("snapshot")?; let d: Vec<u8> = r.get("snapshot")?;
@ -237,29 +237,29 @@ impl StorageTxn for Txn {
fn get_version_by_parent( fn get_version_by_parent(
&mut self, &mut self,
client_key: Uuid, client_id: Uuid,
parent_version_id: Uuid, parent_version_id: Uuid,
) -> anyhow::Result<Option<Version>> { ) -> anyhow::Result<Option<Version>> {
self.get_version_impl( self.get_version_impl(
"SELECT version_id, parent_version_id, history_segment FROM versions WHERE parent_version_id = ? AND client_key = ?", "SELECT version_id, parent_version_id, history_segment FROM versions WHERE parent_version_id = ? AND client_id = ?",
client_key, client_id,
parent_version_id) parent_version_id)
} }
fn get_version( fn get_version(
&mut self, &mut self,
client_key: Uuid, client_id: Uuid,
version_id: Uuid, version_id: Uuid,
) -> anyhow::Result<Option<Version>> { ) -> anyhow::Result<Option<Version>> {
self.get_version_impl( self.get_version_impl(
"SELECT version_id, parent_version_id, history_segment FROM versions WHERE version_id = ? AND client_key = ?", "SELECT version_id, parent_version_id, history_segment FROM versions WHERE version_id = ? AND client_id = ?",
client_key, client_id,
version_id) version_id)
} }
fn add_version( fn add_version(
&mut self, &mut self,
client_key: Uuid, client_id: Uuid,
version_id: Uuid, version_id: Uuid,
parent_version_id: Uuid, parent_version_id: Uuid,
history_segment: Vec<u8>, history_segment: Vec<u8>,
@ -267,10 +267,10 @@ impl StorageTxn for Txn {
let t = self.get_txn()?; let t = self.get_txn()?;
t.execute( t.execute(
"INSERT INTO versions (version_id, client_key, parent_version_id, history_segment) VALUES(?, ?, ?, ?)", "INSERT INTO versions (version_id, client_id, parent_version_id, history_segment) VALUES(?, ?, ?, ?)",
params![ params![
StoredUuid(version_id), StoredUuid(version_id),
StoredUuid(client_key), StoredUuid(client_id),
StoredUuid(parent_version_id), StoredUuid(parent_version_id),
history_segment history_segment
] ]
@ -281,8 +281,8 @@ impl StorageTxn for Txn {
SET SET
latest_version_id = ?, latest_version_id = ?,
versions_since_snapshot = versions_since_snapshot + 1 versions_since_snapshot = versions_since_snapshot + 1
WHERE client_key = ?", WHERE client_id = ?",
params![StoredUuid(version_id), StoredUuid(client_key),], params![StoredUuid(version_id), StoredUuid(client_id),],
) )
.context("Error updating client for new version")?; .context("Error updating client for new version")?;
@ -333,18 +333,18 @@ mod test {
let storage = SqliteStorage::new(tmp_dir.path())?; let storage = SqliteStorage::new(tmp_dir.path())?;
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let latest_version_id = Uuid::new_v4(); let latest_version_id = Uuid::new_v4();
txn.new_client(client_key, latest_version_id)?; txn.new_client(client_id, latest_version_id)?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
assert_eq!(client.latest_version_id, latest_version_id); assert_eq!(client.latest_version_id, latest_version_id);
assert!(client.snapshot.is_none()); assert!(client.snapshot.is_none());
let latest_version_id = Uuid::new_v4(); let latest_version_id = Uuid::new_v4();
txn.add_version(client_key, latest_version_id, Uuid::new_v4(), vec![1, 1])?; txn.add_version(client_id, latest_version_id, Uuid::new_v4(), vec![1, 1])?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
assert_eq!(client.latest_version_id, latest_version_id); assert_eq!(client.latest_version_id, latest_version_id);
assert!(client.snapshot.is_none()); assert!(client.snapshot.is_none());
@ -353,9 +353,9 @@ mod test {
timestamp: "2014-11-28T12:00:09Z".parse::<DateTime<Utc>>().unwrap(), timestamp: "2014-11-28T12:00:09Z".parse::<DateTime<Utc>>().unwrap(),
versions_since: 4, versions_since: 4,
}; };
txn.set_snapshot(client_key, snap.clone(), vec![1, 2, 3])?; txn.set_snapshot(client_id, snap.clone(), vec![1, 2, 3])?;
let client = txn.get_client(client_key)?.unwrap(); let client = txn.get_client(client_id)?.unwrap();
assert_eq!(client.latest_version_id, latest_version_id); assert_eq!(client.latest_version_id, latest_version_id);
assert_eq!(client.snapshot.unwrap(), snap); assert_eq!(client.snapshot.unwrap(), snap);
@ -378,12 +378,12 @@ mod test {
let storage = SqliteStorage::new(tmp_dir.path())?; let storage = SqliteStorage::new(tmp_dir.path())?;
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let version_id = Uuid::new_v4(); let version_id = Uuid::new_v4();
let parent_version_id = Uuid::new_v4(); let parent_version_id = Uuid::new_v4();
let history_segment = b"abc".to_vec(); let history_segment = b"abc".to_vec();
txn.add_version( txn.add_version(
client_key, client_id,
version_id, version_id,
parent_version_id, parent_version_id,
history_segment.clone(), history_segment.clone(),
@ -396,11 +396,11 @@ mod test {
}; };
let version = txn let version = txn
.get_version_by_parent(client_key, parent_version_id)? .get_version_by_parent(client_id, parent_version_id)?
.unwrap(); .unwrap();
assert_eq!(version, expected); assert_eq!(version, expected);
let version = txn.get_version(client_key, version_id)?.unwrap(); let version = txn.get_version(client_id, version_id)?.unwrap();
assert_eq!(version, expected); assert_eq!(version, expected);
Ok(()) Ok(())
@ -412,40 +412,39 @@ mod test {
let storage = SqliteStorage::new(tmp_dir.path())?; let storage = SqliteStorage::new(tmp_dir.path())?;
let mut txn = storage.txn()?; let mut txn = storage.txn()?;
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
txn.new_client(client_key, Uuid::new_v4())?; txn.new_client(client_id, Uuid::new_v4())?;
assert!(txn.get_client(client_key)?.unwrap().snapshot.is_none()); assert!(txn.get_client(client_id)?.unwrap().snapshot.is_none());
let snap = Snapshot { let snap = Snapshot {
version_id: Uuid::new_v4(), version_id: Uuid::new_v4(),
timestamp: "2013-10-08T12:00:09Z".parse::<DateTime<Utc>>().unwrap(), timestamp: "2013-10-08T12:00:09Z".parse::<DateTime<Utc>>().unwrap(),
versions_since: 3, versions_since: 3,
}; };
txn.set_snapshot(client_key, snap.clone(), vec![9, 8, 9])?; txn.set_snapshot(client_id, snap.clone(), vec![9, 8, 9])?;
assert_eq!( assert_eq!(
txn.get_snapshot_data(client_key, snap.version_id)?.unwrap(), txn.get_snapshot_data(client_id, snap.version_id)?.unwrap(),
vec![9, 8, 9] vec![9, 8, 9]
); );
assert_eq!(txn.get_client(client_key)?.unwrap().snapshot, Some(snap)); assert_eq!(txn.get_client(client_id)?.unwrap().snapshot, Some(snap));
let snap2 = Snapshot { let snap2 = Snapshot {
version_id: Uuid::new_v4(), version_id: Uuid::new_v4(),
timestamp: "2014-11-28T12:00:09Z".parse::<DateTime<Utc>>().unwrap(), timestamp: "2014-11-28T12:00:09Z".parse::<DateTime<Utc>>().unwrap(),
versions_since: 10, versions_since: 10,
}; };
txn.set_snapshot(client_key, snap2.clone(), vec![0, 2, 4, 6])?; txn.set_snapshot(client_id, snap2.clone(), vec![0, 2, 4, 6])?;
assert_eq!( assert_eq!(
txn.get_snapshot_data(client_key, snap2.version_id)? txn.get_snapshot_data(client_id, snap2.version_id)?.unwrap(),
.unwrap(),
vec![0, 2, 4, 6] vec![0, 2, 4, 6]
); );
assert_eq!(txn.get_client(client_key)?.unwrap().snapshot, Some(snap2)); assert_eq!(txn.get_client(client_id)?.unwrap().snapshot, Some(snap2));
// check that mismatched version is detected // check that mismatched version is detected
assert!(txn.get_snapshot_data(client_key, Uuid::new_v4()).is_err()); assert!(txn.get_snapshot_data(client_id, Uuid::new_v4()).is_err());
Ok(()) Ok(())
} }

8
taskchampion/taskchampion/src/server/config.rs
View file

@ -16,8 +16,8 @@ pub enum ServerConfig {
/// Sync server "origin"; a URL with schema and hostname but no path or trailing `/` /// Sync server "origin"; a URL with schema and hostname but no path or trailing `/`
origin: String, origin: String,
/// Client Key to identify and authenticate this replica to the server /// Client ID to identify and authenticate this replica to the server
client_key: Uuid, client_id: Uuid,
/// Private encryption secret used to encrypt all data sent to the server. This can /// Private encryption secret used to encrypt all data sent to the server. This can
/// be any suitably un-guessable string of bytes. /// be any suitably un-guessable string of bytes.
@ -32,9 +32,9 @@ impl ServerConfig {
ServerConfig::Local { server_dir } => Box::new(LocalServer::new(server_dir)?), ServerConfig::Local { server_dir } => Box::new(LocalServer::new(server_dir)?),
ServerConfig::Remote { ServerConfig::Remote {
origin, origin,
client_key, client_id,
encryption_secret, encryption_secret,
} => Box::new(RemoteServer::new(origin, client_key, encryption_secret)?), } => Box::new(RemoteServer::new(origin, client_id, encryption_secret)?),
}) })
} }
} }

58
taskchampion/taskchampion/src/server/crypto.rs
View file

@ -12,23 +12,23 @@ const TASK_APP_ID: u8 = 1;
/// An Cryptor stores a secret and allows sealing and unsealing. It derives a key from the secret, /// An Cryptor stores a secret and allows sealing and unsealing. It derives a key from the secret,
/// which takes a nontrivial amount of time, so it should be created once and re-used for the given /// which takes a nontrivial amount of time, so it should be created once and re-used for the given
/// client_key. /// client_id.
pub(super) struct Cryptor { pub(super) struct Cryptor {
key: aead::LessSafeKey, key: aead::LessSafeKey,
rng: rand::SystemRandom, rng: rand::SystemRandom,
} }
impl Cryptor { impl Cryptor {
pub(super) fn new(client_key: Uuid, secret: &Secret) -> Result<Self> { pub(super) fn new(client_id: Uuid, secret: &Secret) -> Result<Self> {
Ok(Cryptor { Ok(Cryptor {
key: Self::derive_key(client_key, secret)?, key: Self::derive_key(client_id, secret)?,
rng: rand::SystemRandom::new(), rng: rand::SystemRandom::new(),
}) })
} }
/// Derive a key as specified for version 1. Note that this may take 10s of ms. /// Derive a key as specified for version 1. Note that this may take 10s of ms.
fn derive_key(client_key: Uuid, secret: &Secret) -> Result<aead::LessSafeKey> { fn derive_key(client_id: Uuid, secret: &Secret) -> Result<aead::LessSafeKey> {
let salt = digest::digest(&digest::SHA256, client_key.as_bytes()); let salt = digest::digest(&digest::SHA256, client_id.as_bytes());
let mut key_bytes = vec![0u8; aead::CHACHA20_POLY1305.key_len()]; let mut key_bytes = vec![0u8; aead::CHACHA20_POLY1305.key_len()];
pbkdf2::derive( pbkdf2::derive(
@ -268,10 +268,10 @@ mod test {
fn round_trip_bad_key() { fn round_trip_bad_key() {
let version_id = Uuid::new_v4(); let version_id = Uuid::new_v4();
let payload = b"HISTORY REPEATS ITSELF".to_vec(); let payload = b"HISTORY REPEATS ITSELF".to_vec();
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let secret = Secret(b"SEKRIT".to_vec()); let secret = Secret(b"SEKRIT".to_vec());
let cryptor = Cryptor::new(client_key, &secret).unwrap(); let cryptor = Cryptor::new(client_id, &secret).unwrap();
let unsealed = Unsealed { let unsealed = Unsealed {
version_id, version_id,
@ -280,7 +280,7 @@ mod test {
let sealed = cryptor.seal(unsealed).unwrap(); let sealed = cryptor.seal(unsealed).unwrap();
let secret = Secret(b"DIFFERENT_SECRET".to_vec()); let secret = Secret(b"DIFFERENT_SECRET".to_vec());
let cryptor = Cryptor::new(client_key, &secret).unwrap(); let cryptor = Cryptor::new(client_id, &secret).unwrap();
assert!(cryptor.unseal(sealed).is_err()); assert!(cryptor.unseal(sealed).is_err());
} }
@ -288,10 +288,10 @@ mod test {
fn round_trip_bad_version() { fn round_trip_bad_version() {
let version_id = Uuid::new_v4(); let version_id = Uuid::new_v4();
let payload = b"HISTORY REPEATS ITSELF".to_vec(); let payload = b"HISTORY REPEATS ITSELF".to_vec();
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let secret = Secret(b"SEKRIT".to_vec()); let secret = Secret(b"SEKRIT".to_vec());
let cryptor = Cryptor::new(client_key, &secret).unwrap(); let cryptor = Cryptor::new(client_id, &secret).unwrap();
let unsealed = Unsealed { let unsealed = Unsealed {
version_id, version_id,
@ -303,13 +303,13 @@ mod test {
} }
#[test] #[test]
fn round_trip_bad_client_key() { fn round_trip_bad_client_id() {
let version_id = Uuid::new_v4(); let version_id = Uuid::new_v4();
let payload = b"HISTORY REPEATS ITSELF".to_vec(); let payload = b"HISTORY REPEATS ITSELF".to_vec();
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let secret = Secret(b"SEKRIT".to_vec()); let secret = Secret(b"SEKRIT".to_vec());
let cryptor = Cryptor::new(client_key, &secret).unwrap(); let cryptor = Cryptor::new(client_id, &secret).unwrap();
let unsealed = Unsealed { let unsealed = Unsealed {
version_id, version_id,
@ -317,8 +317,8 @@ mod test {
}; };
let sealed = cryptor.seal(unsealed).unwrap(); let sealed = cryptor.seal(unsealed).unwrap();
let client_key = Uuid::new_v4(); let client_id = Uuid::new_v4();
let cryptor = Cryptor::new(client_key, &secret).unwrap(); let cryptor = Cryptor::new(client_id, &secret).unwrap();
assert!(cryptor.unseal(sealed).is_err()); assert!(cryptor.unseal(sealed).is_err());
} }
@ -340,13 +340,13 @@ mod test {
#[test] #[test]
fn good() { fn good() {
let (version_id, client_key, encryption_secret) = defaults(); let (version_id, client_id, encryption_secret) = defaults();
let sealed = Sealed { let sealed = Sealed {
version_id, version_id,
payload: include_bytes!("test-good.data").to_vec(), payload: include_bytes!("test-good.data").to_vec(),
}; };
let cryptor = Cryptor::new(client_key, &Secret(encryption_secret)).unwrap(); let cryptor = Cryptor::new(client_id, &Secret(encryption_secret)).unwrap();
let unsealed = cryptor.unseal(sealed).unwrap(); let unsealed = cryptor.unseal(sealed).unwrap();
assert_eq!(unsealed.payload, b"SUCCESS"); assert_eq!(unsealed.payload, b"SUCCESS");
@ -355,61 +355,61 @@ mod test {
#[test] #[test]
fn bad_version_id() { fn bad_version_id() {
let (version_id, client_key, encryption_secret) = defaults(); let (version_id, client_id, encryption_secret) = defaults();
let sealed = Sealed { let sealed = Sealed {
version_id, version_id,
payload: include_bytes!("test-bad-version-id.data").to_vec(), payload: include_bytes!("test-bad-version-id.data").to_vec(),
}; };
let cryptor = Cryptor::new(client_key, &Secret(encryption_secret)).unwrap(); let cryptor = Cryptor::new(client_id, &Secret(encryption_secret)).unwrap();
assert!(cryptor.unseal(sealed).is_err()); assert!(cryptor.unseal(sealed).is_err());
} }
#[test] #[test]
fn bad_client_key() { fn bad_client_id() {
let (version_id, client_key, encryption_secret) = defaults(); let (version_id, client_id, encryption_secret) = defaults();
let sealed = Sealed { let sealed = Sealed {
version_id, version_id,
payload: include_bytes!("test-bad-client-key.data").to_vec(), payload: include_bytes!("test-bad-client-id.data").to_vec(),
}; };
let cryptor = Cryptor::new(client_key, &Secret(encryption_secret)).unwrap(); let cryptor = Cryptor::new(client_id, &Secret(encryption_secret)).unwrap();
assert!(cryptor.unseal(sealed).is_err()); assert!(cryptor.unseal(sealed).is_err());
} }
#[test] #[test]
fn bad_secret() { fn bad_secret() {
let (version_id, client_key, encryption_secret) = defaults(); let (version_id, client_id, encryption_secret) = defaults();
let sealed = Sealed { let sealed = Sealed {
version_id, version_id,
payload: include_bytes!("test-bad-secret.data").to_vec(), payload: include_bytes!("test-bad-secret.data").to_vec(),
}; };
let cryptor = Cryptor::new(client_key, &Secret(encryption_secret)).unwrap(); let cryptor = Cryptor::new(client_id, &Secret(encryption_secret)).unwrap();
assert!(cryptor.unseal(sealed).is_err()); assert!(cryptor.unseal(sealed).is_err());
} }
#[test] #[test]
fn bad_version() { fn bad_version() {
let (version_id, client_key, encryption_secret) = defaults(); let (version_id, client_id, encryption_secret) = defaults();
let sealed = Sealed { let sealed = Sealed {
version_id, version_id,
payload: include_bytes!("test-bad-version.data").to_vec(), payload: include_bytes!("test-bad-version.data").to_vec(),
}; };
let cryptor = Cryptor::new(client_key, &Secret(encryption_secret)).unwrap(); let cryptor = Cryptor::new(client_id, &Secret(encryption_secret)).unwrap();
assert!(cryptor.unseal(sealed).is_err()); assert!(cryptor.unseal(sealed).is_err());
} }
#[test] #[test]
fn bad_app_id() { fn bad_app_id() {
let (version_id, client_key, encryption_secret) = defaults(); let (version_id, client_id, encryption_secret) = defaults();
let sealed = Sealed { let sealed = Sealed {
version_id, version_id,
payload: include_bytes!("test-bad-app-id.data").to_vec(), payload: include_bytes!("test-bad-app-id.data").to_vec(),
}; };
let cryptor = Cryptor::new(client_key, &Secret(encryption_secret)).unwrap(); let cryptor = Cryptor::new(client_id, &Secret(encryption_secret)).unwrap();
assert!(cryptor.unseal(sealed).is_err()); assert!(cryptor.unseal(sealed).is_err());
} }
} }

12
taskchampion/taskchampion/src/server/generate-test-data.py
View file

@ -1,6 +1,6 @@
# This file generates test-encrypted.data. To run it: # This file generates test-encrypted.data. To run it:
# - pip install cryptography pbkdf2 # - pip install cryptography pbkdf2
# - python taskchampion/src/server/generate-test-data.py taskchampion/src/server/ # - python taskchampion/taskchampion/src/server/generate-test-data.py taskchampion/taskchampion/src/server/
import os import os
import hashlib import hashlib
@ -12,15 +12,15 @@ import uuid
from cryptography.hazmat.primitives.ciphers.aead import ChaCha20Poly1305 from cryptography.hazmat.primitives.ciphers.aead import ChaCha20Poly1305
# these values match values used in the rust tests # these values match values used in the rust tests
client_key = "0666d464-418a-4a08-ad53-6f15c78270cd" client_id = "0666d464-418a-4a08-ad53-6f15c78270cd"
encryption_secret = b"b4a4e6b7b811eda1dc1a2693ded" encryption_secret = b"b4a4e6b7b811eda1dc1a2693ded"
version_id = "b0517957-f912-4d49-8330-f612e73030c4" version_id = "b0517957-f912-4d49-8330-f612e73030c4"
def gen( def gen(
version_id=version_id, client_key=client_key, encryption_secret=encryption_secret, version_id=version_id, client_id=client_id, encryption_secret=encryption_secret,
app_id=1, version=1): app_id=1, version=1):
# first, generate the encryption key # first, generate the encryption key
salt = hashlib.sha256(uuid.UUID(client_key).bytes).digest() salt = hashlib.sha256(uuid.UUID(client_id).bytes).digest()
key = pbkdf2.PBKDF2( key = pbkdf2.PBKDF2(
encryption_secret, encryption_secret,
salt, salt,
@ -61,8 +61,8 @@ def main():
with open(os.path.join(dir, 'test-bad-version-id.data'), "wb") as f: with open(os.path.join(dir, 'test-bad-version-id.data'), "wb") as f:
f.write(gen(version_id=uuid.uuid4().hex)) f.write(gen(version_id=uuid.uuid4().hex))
with open(os.path.join(dir, 'test-bad-client-key.data'), "wb") as f: with open(os.path.join(dir, 'test-bad-client-id.data'), "wb") as f:
f.write(gen(client_key=uuid.uuid4().hex)) f.write(gen(client_id=uuid.uuid4().hex))
with open(os.path.join(dir, 'test-bad-secret.data'), "wb") as f: with open(os.path.join(dir, 'test-bad-secret.data'), "wb") as f:
f.write(gen(encryption_secret=b"xxxxxxxxxxxxxxxxxxxxx")) f.write(gen(encryption_secret=b"xxxxxxxxxxxxxxxxxxxxx"))

20
taskchampion/taskchampion/src/server/remote/mod.rs
View file

@ -10,7 +10,7 @@ use super::crypto::{Cryptor, Sealed, Secret, Unsealed};
pub struct RemoteServer { pub struct RemoteServer {
origin: String, origin: String,
client_key: Uuid, client_id: Uuid,
cryptor: Cryptor, cryptor: Cryptor,
agent: ureq::Agent, agent: ureq::Agent,
} }
@ -25,18 +25,18 @@ const SNAPSHOT_CONTENT_TYPE: &str = "application/vnd.taskchampion.snapshot";
/// taskchampion-sync-server). /// taskchampion-sync-server).
impl RemoteServer { impl RemoteServer {
/// Construct a new RemoteServer. The `origin` is the sync server's protocol and hostname /// Construct a new RemoteServer. The `origin` is the sync server's protocol and hostname
/// without a trailing slash, such as `https://tcsync.example.com`. Pass a client_key to /// without a trailing slash, such as `https://tcsync.example.com`. Pass a client_id to
/// identify this client to the server. Multiple replicas synchronizing the same task history /// identify this client to the server. Multiple replicas synchronizing the same task history
/// should use the same client_key. /// should use the same client_id.
pub fn new( pub fn new(
origin: String, origin: String,
client_key: Uuid, client_id: Uuid,
encryption_secret: Vec<u8>, encryption_secret: Vec<u8>,
) -> Result<RemoteServer> { ) -> Result<RemoteServer> {
Ok(RemoteServer { Ok(RemoteServer {
origin, origin,
client_key, client_id,
cryptor: Cryptor::new(client_key, &Secret(encryption_secret.to_vec()))?, cryptor: Cryptor::new(client_id, &Secret(encryption_secret.to_vec()))?,
agent: ureq::AgentBuilder::new() agent: ureq::AgentBuilder::new()
.timeout_connect(Duration::from_secs(10)) .timeout_connect(Duration::from_secs(10))
.timeout_read(Duration::from_secs(60)) .timeout_read(Duration::from_secs(60))
@ -86,7 +86,7 @@ impl Server for RemoteServer {
.agent .agent
.post(&url) .post(&url)
.set("Content-Type", HISTORY_SEGMENT_CONTENT_TYPE) .set("Content-Type", HISTORY_SEGMENT_CONTENT_TYPE)
.set("X-Client-Key", &self.client_key.to_string()) .set("X-Client-Id", &self.client_id.to_string())
.send_bytes(sealed.as_ref()) .send_bytes(sealed.as_ref())
{ {
Ok(resp) => { Ok(resp) => {
@ -115,7 +115,7 @@ impl Server for RemoteServer {
match self match self
.agent .agent
.get(&url) .get(&url)
.set("X-Client-Key", &self.client_key.to_string()) .set("X-Client-Id", &self.client_id.to_string())
.call() .call()
{ {
Ok(resp) => { Ok(resp) => {
@ -148,7 +148,7 @@ impl Server for RemoteServer {
.agent .agent
.post(&url) .post(&url)
.set("Content-Type", SNAPSHOT_CONTENT_TYPE) .set("Content-Type", SNAPSHOT_CONTENT_TYPE)
.set("X-Client-Key", &self.client_key.to_string()) .set("X-Client-Id", &self.client_id.to_string())
.send_bytes(sealed.as_ref()) .send_bytes(sealed.as_ref())
.map(|_| ())?) .map(|_| ())?)
} }
@ -158,7 +158,7 @@ impl Server for RemoteServer {
match self match self
.agent .agent
.get(&url) .get(&url)
.set("X-Client-Key", &self.client_key.to_string()) .set("X-Client-Id", &self.client_id.to_string())
.call() .call()
{ {
Ok(resp) => { Ok(resp) => {

4
taskchampion/taskchampion/src/server/test-bad-app-id.data
View file

@ -1,2 +1,2 @@
#§$á­ ®
†—Õ^~B>n)j›i†¯1—î9™|µœÓ~ <EFBFBD>KŸo]æâʶ£‘†‘McØ\ï©QL)cHÂ;ÚÎ-:

1
taskchampion/taskchampion/src/server/test-bad-client-id.data Normal file
View file

@ -0,0 +1 @@
%<25>ۇ <09><07><>ko¹<6F>{hكb<D983><62><EFBFBD> <0A><><02>ˁLqU

1
taskchampion/taskchampion/src/server/test-bad-client-key.data
View file

@ -1 +0,0 @@
<01>ΝA4φ―Γθ t;Δτ υηp¦Ο¦x^Αύreό…<CF8C>JΤ¤<CEA4>

2
taskchampion/taskchampion/src/server/test-bad-secret.data
View file

@ -1 +1 @@
/}åd E°‡dIcÁXéè-‡!V°Û%è4îáòd]³ÃÇ} κsq<0F><>nΟΐk,Βν\ ‹ΕΘ;W¶< ΄' ®Ξ;{Π<>

2
taskchampion/taskchampion/src/server/test-bad-version-id.data
View file

@ -1 +1 @@
lΰζδa|‚ο@Ο<>S_‚¬…γzέV9£q¦Ρ…‘)+¦…  ñ±Ÿâ–ajJ›šÕ·ïq\IF4¤ó<C2A4>Y Ó£ €$‹ë9W

2
taskchampion/taskchampion/src/server/test-bad-version.data
View file

@ -1 +1 @@
c╙╤TH╗Гp>╔╚Ф╨╕m4О╧к~в1╣0P░IЖ╢W╒ cR<06>ùË|¯|iKoÌÀ˜³+t•U|Ñ™ï˜&  —BIŸ·3

2
taskchampion/taskchampion/src/server/test-good.data
View file

@ -1 +1 @@
pÑ¿µÒŸ½V²ûÝäToë"}cT·äY7Æ ˆÀ@ÙdLTý`Ò PRÇojÇ—Þgs²&vMØYÔn<>œ?ƒÛcå¼~:œ