//! `continuum-party`: a party's client of a federation (`docs/federation.md`). It signs its //! party's events with one of its keys (an OpenSSH private key file, `--key`), puts them //! through a node's API (`--node`, its user and password in the URL, or `--token`), and //! keeps its party's record (`--record`, `client::Record`), by which it votes, written //! before a vote is sent. //! //! * `init PARTY`: begins a record of `PARTY`, on the version current now; //! * `write PATH VALUE`: writes `VALUE` (JSON) at `PATH`; //! * `keys KEY...`, `nodes NODE...`: writes the party's key set (`authorized_keys` lines) //! or node list (node IDs); //! * `propose FILE`: proposes the version `FILE` holds (JSON); //! * `vote PROPOSAL yes|no`: votes on the proposal of hash `PROPOSAL` on the current //! version, by the record; with `--through`, through the node that votes for the //! party by itself and keeps its record, as such a party votes by hand; //! * `again`: signs again what a move refused; //! * `twice RECORD...`: names, from the records of parties' clients, a party that voted //! twice. use std::collections::BTreeSet; use std::path::{Path, PathBuf}; use anyhow::{Context, Result, anyhow, bail}; use clap::{Arg, ArgAction, ArgMatches, Command}; use ed25519_dalek::SigningKey; use serde_json::Value as JsonValue; use super::client::{self, Record}; use super::event::{self, Does, Event, Signed}; use super::jcs::Json; use super::store::Id; use super::version::Version; use crate::access::sshsig::PublicKey; fn command() -> Command { let id = |name: &'static str| Arg::new(name).required(true); Command::new("continuum-party") .about("A party's client of a federation: signs its events, and votes by its record") .arg( Arg::new("node") .long("node") .value_name("URL") .default_value("http://localhost:3000") .help( "The node whose API it puts events through; its user and password in the URL", ), ) .arg( Arg::new("token") .long("token") .value_name("TOKEN") .help("A token the node issued, instead of a password"), ) .arg( Arg::new("key") .long("key") .value_name("FILE") .help("The party's key it signs with: an OpenSSH private key file, unencrypted"), ) .arg( Arg::new("record") .long("record") .value_name("FILE") .help("The party's record of its votes, written before each vote is sent"), ) .subcommand_required(true) .subcommand( Command::new("init") .about("Begins a record") .arg(id("party")), ) .subcommand( Command::new("write") .about("Writes a value (JSON) at a path") .arg(id("path")) .arg(id("value")), ) .subcommand( Command::new("keys") .about("Writes the party's key set") .arg(Arg::new("keys").num_args(1..).required(true)), ) .subcommand( Command::new("nodes") .about("Writes the party's node list") .arg(Arg::new("nodes").num_args(0..)), ) .subcommand( Command::new("propose") .about("Proposes the version a file holds (JSON)") .arg(id("file")), ) .subcommand( Command::new("vote") .about("Votes on a proposal on the current version, by its hash") .arg(id("proposal")) .arg(Arg::new("yes").required(true).value_parser(["yes", "no"])) .arg( Arg::new("through") .long("through") .action(ArgAction::SetTrue) .help("Through the node, which votes for the party and keeps its record"), ), ) .subcommand(Command::new("again").about("Signs again what a move refused")) .subcommand( Command::new("twice") .about("Names, from records, a party that voted twice") .arg( Arg::new("records") .num_args(1..) .required(true) .action(ArgAction::Append), ), ) } /// Runs the client, as its arguments say. pub(crate) async fn main() -> Result<()> { let matches = command().get_matches(); let (name, sub) = matches.subcommand().expect("a subcommand is required"); if name == "twice" { let records = sub .get_many::("records") .into_iter() .flatten() .map(|path| Record::load(Path::new(path)).map_err(|why| anyhow!(why))) .collect::>>()?; for (version, party, why) in client::voted_twice(&records) { println!("{party} voted twice on version {version}: {why}"); } return Ok(()); } let node = Node::new(&matches)?; // A party that has a node vote by itself votes by hand only through it. if name == "vote" && sub.get_flag("through") { let proposal = sub.get_one::("proposal").expect("required"); let yes = sub.get_one::("yes").map(String::as_str) == Some("yes"); let answer = node .post( "/admin/events/vote", &serde_json::json!({"proposal": proposal, "yes": yes}), ) .await?; println!("{} cast", answer["id"].as_str().unwrap_or_default()); return Ok(()); } let path = PathBuf::from( matches .get_one::("record") .context("--record names the party's record")?, ); if name == "init" { if path.exists() { bail!("{} holds a record already", path.display()); } let party = sub.get_one::("party").expect("required"); let (store, _) = node.summary().await?; let record = Record::begin(store, party, &node.current().await?); record.save(&path).map_err(|why| anyhow!(why))?; println!("began a record of {party}, of the store {store}"); return Ok(()); } let mut record = Record::load(&path).map_err(|why| anyhow!(why))?; let key = signing_key(&matches)?; let signer = Signer { key, party: record.party.clone(), }; match (name, sub) { ("write", sub) => { let path_to = sub.get_one::("path").expect("required"); let value: JsonValue = serde_json::from_str(sub.get_one::("value").expect("required")) .context("the value isn't JSON")?; let value = client::json(&value).map_err(|why| anyhow!(why))?; sign( &node, &signer, &mut record, &path, event::write(path_to, value), ) .await } ("keys", sub) => { let keys: Vec = strings(sub, "keys"); sign(&node, &signer, &mut record, &path, event::keys(&keys)).await } ("nodes", sub) => { let nodes: Vec = strings(sub, "nodes"); sign(&node, &signer, &mut record, &path, event::nodes(&nodes)).await } ("propose", sub) => { let file = sub.get_one::("file").expect("required"); let text = std::fs::read_to_string(file).with_context(|| format!("Reading {file}"))?; let version: JsonValue = serde_json::from_str(&text).with_context(|| format!("{file} isn't JSON"))?; let version = client::json(&version).map_err(|why| anyhow!(why))?; sign( &node, &signer, &mut record, &path, event::proposal(&version), ) .await } ("vote", sub) => { let proposal = Id::from_hex(sub.get_one::("proposal").expect("required")) .context("not a proposal's hash")?; let yes = sub.get_one::("yes").map(String::as_str) == Some("yes"); vote(&node, &signer, &mut record, &path, proposal, yes).await } ("again", _) => again(&node, &signer, &mut record, &path).await, _ => unreachable!("every subcommand handled"), } } fn strings(matches: &ArgMatches, name: &str) -> Vec { matches .get_many::(name) .into_iter() .flatten() .cloned() .collect() } fn signing_key(matches: &ArgMatches) -> Result { let file = matches .get_one::("key") .context("--key names the party's key")?; let text = std::fs::read_to_string(file).with_context(|| format!("Reading {file}"))?; client::signing_key(&text).map_err(|why| anyhow!("{file}: {why}")) } /// Who signs: the party, with one of its keys. struct Signer { key: SigningKey, party: String, } impl Signer { fn sign(&self, deps: &[Id], does: (&str, Json)) -> Vec { let line = PublicKey(self.key.verifying_key().to_bytes()).line(); event::signed(&self.key, &self.party, &line, deps, does) } } /// An event signed on the node's heads, recorded, and put. async fn sign( node: &Node, signer: &Signer, record: &mut Record, path: &Path, does: (&str, Json), ) -> Result<()> { let (_, heads) = node.summary().await?; let event = signer.sign(&heads, does); record.signed(&event); record.save(path).map_err(|why| anyhow!(why))?; node.put(&event).await } /// A vote, by the record: written to it before it is sent. async fn vote( node: &Node, signer: &Signer, record: &mut Record, path: &Path, proposal: Id, yes: bool, ) -> Result<()> { let counts = node.counts().await?; let current = current(&counts)?; let ballots = &counts["proposals"]; let ids = |hash: &Id, what: &str| -> Vec { ballots[hash.to_string()][what] .as_array() .into_iter() .flatten() .filter_map(|id| id.as_str().and_then(Id::from_hex)) .collect() }; let Some(proposing) = ids(&proposal, "proposals").first().copied() else { bail!("no proposal of hash {proposal} on the current version, as the node reads it"); }; let proposed = match Event::read(&node.event(&proposing).await?) { Some(Event::Signed(Signed { does: Does::Proposal { hash, version }, .. })) if hash == proposal => version, _ => bail!("the node's {proposing} isn't the proposal it names"), }; // The votes on its party's earlier proposals it backed, for the nays among them. let mut nays = Vec::new(); let backed: BTreeSet = record .votes .iter() .filter_map(|text| match Event::read_taken(text.as_bytes()) { Some(Event::Signed(Signed { does: Does::Vote { on, proposal, yes: true, }, .. })) if on == current.hash => Some(proposal), _ => None, }) .collect(); for earlier in &backed { for id in ids(earlier, "votes") { nays.push(node.event(&id).await?); } } let kept = record .may_vote(¤t, proposal, &proposed, yes, &nays) .map_err(|why| anyhow!(why))?; let (_, heads) = node.summary().await?; let cast = signer.sign(&heads, event::vote(current.hash, proposal, yes)); record.cast(¤t, &cast, kept); record.save(path).map_err(|why| anyhow!(why))?; node.put(&cast).await } /// Signs again what a move refused: of the latest event it signed at each place, its key /// set and its node list, those the node refuses as not above its checkpoint's heads, or /// as built on one it refuses. async fn again(node: &Node, signer: &Signer, record: &mut Record, path: &Path) -> Result<()> { let refused = node.get("/events/refused").await?; let moved: BTreeSet = refused["refused"] .as_array() .into_iter() .flatten() .filter(|entry| matches!(entry["kind"].as_str(), Some("notAbove" | "builtOn"))) .filter_map(|entry| entry["id"].as_str().and_then(Id::from_hex)) .collect(); let again = record.again(|id| moved.contains(id)); if again.is_empty() { println!("nothing to sign again"); } for (refused, does) in again { let does = match does { Does::Write { path, value } => event::write(&path.join("/"), value), Does::Keys(keys) => event::keys(&keys), Does::Nodes(nodes) => event::nodes(&nodes), Does::Proposal { .. } | Does::Vote { .. } => continue, }; println!("signing again {refused}"); sign(node, signer, record, path, does).await?; } Ok(()) } /// The current version, as `counts` names it, checked: its hash its own. fn current(counts: &JsonValue) -> Result { let json = client::json(&counts["version"]["version"]).map_err(|why| anyhow!(why))?; let version = Version::read(&json).map_err(|why| anyhow!("the node's current version: {why}"))?; if Some(version.hash.to_string().as_str()) != counts["version"]["hash"].as_str() { bail!("the node's current version isn't of the hash it names"); } Ok(version) } /// A node's API. struct Node { url: reqwest::Url, http: reqwest::Client, password: Option<(String, Option)>, token: Option, } impl Node { fn new(matches: &ArgMatches) -> Result { let _ = rustls::crypto::ring::default_provider().install_default(); let mut url: reqwest::Url = matches .get_one::("node") .expect("defaulted") .parse() .context("--node isn't a URL")?; let password = (!url.username().is_empty()) .then(|| (url.username().to_owned(), url.password().map(str::to_owned))); let _ = url.set_username(""); let _ = url.set_password(None); Ok(Node { url, http: reqwest::Client::new(), password, token: matches.get_one::("token").cloned(), }) } fn request(&self, method: reqwest::Method, path: &str) -> Result { let url = self.url.join(path).context("a path of the node's API")?; let request = self.http.request(method, url); Ok(match (&self.token, &self.password) { (Some(token), _) => request.bearer_auth(token), (None, Some((user, password))) => request.basic_auth(user, password.as_ref()), (None, None) => request, }) } async fn answer(response: reqwest::Response) -> Result { let status = response.status(); if status.is_success() { return Ok(response); } let body = response.text().await.unwrap_or_default(); bail!("the node answers {status}: {body}") } async fn get(&self, path: &str) -> Result { let response = self.request(reqwest::Method::GET, path)?.send().await?; Ok(Self::answer(response).await?.json().await?) } /// The store's ID, and its heads. async fn summary(&self) -> Result<(Id, Vec)> { let summary = self.get("/events").await?; let store = summary["store"] .as_str() .and_then(Id::from_hex) .context("the node names no store")?; let heads = summary["heads"] .as_array() .into_iter() .flatten() .filter_map(|id| id.as_str().and_then(Id::from_hex)) .collect(); Ok((store, heads)) } async fn counts(&self) -> Result { self.get("/events/counts").await } async fn current(&self) -> Result { current(&self.counts().await?) } /// The bytes of an event the node's store holds. async fn event(&self, id: &Id) -> Result> { let response = self .request(reqwest::Method::GET, &format!("/events/{id}"))? .send() .await?; let bytes = Self::answer(response).await?.bytes().await?.to_vec(); if Id::of(&bytes) != *id { bail!("the node's event {id} isn't of that ID"); } Ok(bytes) } async fn post(&self, path: &str, body: &JsonValue) -> Result { let response = self .request(reqwest::Method::POST, path)? .json(body) .send() .await?; Ok(Self::answer(response).await?.json().await?) } async fn put(&self, event: &[u8]) -> Result<()> { let response = self .request(reqwest::Method::POST, "/events")? .header(reqwest::header::CONTENT_TYPE, "application/json") .body(event.to_vec()) .send() .await?; let answer: JsonValue = Self::answer(response).await?.json().await?; println!( "{} {}", answer["id"].as_str().unwrap_or_default(), answer["event"].as_str().unwrap_or_default() ); Ok(()) } } #[cfg(test)] mod tests { #[test] fn its_arguments_are_well_formed() { super::command().debug_assert(); } }