add a 'task sync' command using a copy of the test server

This commit is contained in:
Dustin J. Mitchell 2020-11-25 18:06:56 -05:00
parent a81c84d7c7
commit 8f7e2e2790
5 changed files with 153 additions and 24 deletions

View file

@ -1,7 +1,5 @@
use clap::{App, ArgMatches}; use clap::{App, ArgMatches};
use failure::{Error, Fallible}; use failure::{Error, Fallible};
use std::path::Path;
use taskchampion::{taskstorage, Replica};
#[macro_use] #[macro_use]
mod macros; mod macros;
@ -12,6 +10,7 @@ mod gc;
mod info; mod info;
mod list; mod list;
mod pending; mod pending;
mod sync;
/// Get a list of all subcommands in this crate /// Get a list of all subcommands in this crate
pub(crate) fn subcommands() -> Vec<Box<dyn SubCommand>> { pub(crate) fn subcommands() -> Vec<Box<dyn SubCommand>> {
@ -21,6 +20,7 @@ pub(crate) fn subcommands() -> Vec<Box<dyn SubCommand>> {
list::cmd(), list::cmd(),
pending::cmd(), pending::cmd(),
info::cmd(), info::cmd(),
sync::cmd(),
] ]
} }
@ -54,24 +54,4 @@ pub(crate) trait SubCommandInvocation: std::fmt::Debug {
fn as_any(&self) -> &dyn std::any::Any; fn as_any(&self) -> &dyn std::any::Any;
} }
/// A command invocation contains all of the necessary regarding a single invocation of the CLI. pub use shared::CommandInvocation;
#[derive(Debug)]
pub struct CommandInvocation {
pub(crate) subcommand: Box<dyn SubCommandInvocation>,
}
impl CommandInvocation {
pub(crate) fn new(subcommand: Box<dyn SubCommandInvocation>) -> Self {
Self { subcommand }
}
pub fn run(self) -> Fallible<()> {
self.subcommand.run(&self)
}
fn get_replica(&self) -> Replica {
Replica::new(Box::new(
taskstorage::KVStorage::new(Path::new("/tmp/tasks")).unwrap(),
))
}
}

View file

@ -1,6 +1,7 @@
use clap::Arg; use clap::Arg;
use failure::{format_err, Fallible}; use failure::{format_err, Fallible};
use taskchampion::{Replica, Task, Uuid}; use std::path::Path;
use taskchampion::{server, taskstorage, Replica, Task, Uuid};
pub(super) fn task_arg<'a>() -> Arg<'a, 'a> { pub(super) fn task_arg<'a>() -> Arg<'a, 'a> {
Arg::with_name("task") Arg::with_name("task")
@ -26,3 +27,31 @@ pub(super) fn get_task<S: AsRef<str>>(replica: &mut Replica, task_arg: S) -> Fal
Err(format_err!("Cannot interpret {:?} as a task", task_arg)) Err(format_err!("Cannot interpret {:?} as a task", task_arg))
} }
/// A command invocation contains all of the necessary regarding a single invocation of the CLI.
#[derive(Debug)]
pub struct CommandInvocation {
pub(crate) subcommand: Box<dyn super::SubCommandInvocation>,
}
impl CommandInvocation {
pub(crate) fn new(subcommand: Box<dyn super::SubCommandInvocation>) -> Self {
Self { subcommand }
}
pub fn run(self) -> Fallible<()> {
self.subcommand.run(&self)
}
// -- utilities for command invocations
pub(super) fn get_replica(&self) -> Replica {
Replica::new(Box::new(
taskstorage::KVStorage::new(Path::new("/tmp/tasks")).unwrap(),
))
}
pub(super) fn get_server(&self) -> impl server::Server {
server::LocalServer::new()
}
}

39
cli/src/cmd/sync.rs Normal file
View file

@ -0,0 +1,39 @@
use clap::{App, ArgMatches, SubCommand as ClapSubCommand};
use failure::Fallible;
use crate::cmd::{ArgMatchResult, CommandInvocation};
#[derive(Debug)]
struct Invocation {}
define_subcommand! {
fn decorate_app<'a>(&self, app: App<'a, 'a>) -> App<'a, 'a> {
app.subcommand(ClapSubCommand::with_name("sync").about("sync with the server"))
}
fn arg_match<'a>(&self, matches: &ArgMatches<'a>) -> ArgMatchResult {
match matches.subcommand() {
("sync", _) => ArgMatchResult::Ok(Box::new(Invocation {})),
_ => ArgMatchResult::None,
}
}
}
subcommand_invocation! {
fn run(&self, command: &CommandInvocation) -> Fallible<()> {
let mut replica = command.get_replica();
let mut server = command.get_server();
replica.sync(&mut server)?;
Ok(())
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn parse_command() {
with_subcommand_invocation!(vec!["task", "sync"], |_inv| {});
}
}

View file

@ -0,0 +1,79 @@
use crate::server::{
AddVersionResult, GetVersionResult, HistorySegment, Server, VersionId, NO_VERSION_ID,
};
use failure::Fallible;
use std::collections::HashMap;
use uuid::Uuid;
struct Version {
version_id: VersionId,
parent_version_id: VersionId,
history_segment: HistorySegment,
}
pub struct LocalServer {
latest_version_id: VersionId,
// NOTE: indexed by parent_version_id!
versions: HashMap<VersionId, Version>,
}
impl LocalServer {
/// A test server has no notion of clients, signatures, encryption, etc.
pub fn new() -> LocalServer {
LocalServer {
latest_version_id: NO_VERSION_ID,
versions: HashMap::new(),
}
}
}
impl Server for LocalServer {
/// Add a new version. If the given version number is incorrect, this responds with the
/// appropriate version and expects the caller to try again.
fn add_version(
&mut self,
parent_version_id: VersionId,
history_segment: HistorySegment,
) -> Fallible<AddVersionResult> {
// no client lookup
// no signature validation
// check the parent_version_id for linearity
if self.latest_version_id != NO_VERSION_ID {
if parent_version_id != self.latest_version_id {
return Ok(AddVersionResult::ExpectedParentVersion(
self.latest_version_id,
));
}
}
// invent a new ID for this version
let version_id = Uuid::new_v4();
self.versions.insert(
parent_version_id,
Version {
version_id,
parent_version_id,
history_segment,
},
);
self.latest_version_id = version_id;
Ok(AddVersionResult::Ok(version_id))
}
/// Get a vector of all versions after `since_version`
fn get_child_version(&self, parent_version_id: VersionId) -> Fallible<GetVersionResult> {
if let Some(version) = self.versions.get(&parent_version_id) {
Ok(GetVersionResult::Version {
version_id: version.version_id,
parent_version_id: version.parent_version_id,
history_segment: version.history_segment.clone(),
})
} else {
Ok(GetVersionResult::NoSuchVersion)
}
}
}

View file

@ -1,7 +1,9 @@
#[cfg(test)] #[cfg(test)]
pub(crate) mod test; pub(crate) mod test;
mod local;
mod signing; mod signing;
mod types; mod types;
pub use local::LocalServer;
pub use types::*; pub use types::*;