aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/bin/continuum-party.rs6
-rw-r--r--src/federation/mod.rs1
-rw-r--r--src/federation/party.rs459
-rw-r--r--src/lib.rs10
4 files changed, 475 insertions, 1 deletions
diff --git a/src/bin/continuum-party.rs b/src/bin/continuum-party.rs
new file mode 100644
index 0000000..b79492b
--- /dev/null
+++ b/src/bin/continuum-party.rs
@@ -0,0 +1,6 @@
+//! A party's client of a federation: the library's (`continuum::party`).
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+ continuum::party().await
+}
diff --git a/src/federation/mod.rs b/src/federation/mod.rs
index 25f4889..20ade61 100644
--- a/src/federation/mod.rs
+++ b/src/federation/mod.rs
@@ -17,6 +17,7 @@ pub(crate) mod jcs;
pub(crate) mod keys;
#[cfg(test)]
mod model;
+pub(crate) mod party;
#[cfg(test)]
mod properties;
pub(crate) mod store;
diff --git a/src/federation/party.rs b/src/federation/party.rs
new file mode 100644
index 0000000..8163fb3
--- /dev/null
+++ b/src/federation/party.rs
@@ -0,0 +1,459 @@
+//! `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;
+//! * `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"])),
+ )
+ .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::<String>("records")
+ .into_iter()
+ .flatten()
+ .map(|path| Record::load(Path::new(path)).map_err(|why| anyhow!(why)))
+ .collect::<Result<Vec<_>>>()?;
+ for (version, party, why) in client::voted_twice(&records) {
+ println!("{party} voted twice on version {version}: {why}");
+ }
+ return Ok(());
+ }
+ let node = Node::new(&matches)?;
+ let path = PathBuf::from(
+ matches
+ .get_one::<String>("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::<String>("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::<String>("path").expect("required");
+ let value: JsonValue =
+ serde_json::from_str(sub.get_one::<String>("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<String> = strings(sub, "keys");
+ sign(&node, &signer, &mut record, &path, event::keys(&keys)).await
+ }
+ ("nodes", sub) => {
+ let nodes: Vec<String> = strings(sub, "nodes");
+ sign(&node, &signer, &mut record, &path, event::nodes(&nodes)).await
+ }
+ ("propose", sub) => {
+ let file = sub.get_one::<String>("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::<String>("proposal").expect("required"))
+ .context("not a proposal's hash")?;
+ let yes = sub.get_one::<String>("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<String> {
+ matches
+ .get_many::<String>(name)
+ .into_iter()
+ .flatten()
+ .cloned()
+ .collect()
+}
+
+fn signing_key(matches: &ArgMatches) -> Result<SigningKey> {
+ let file = matches
+ .get_one::<String>("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<u8> {
+ 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<Id> {
+ 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<Id> = 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(&current, 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(&current, &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<Id> = 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<Version> {
+ 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<String>)>,
+ token: Option<String>,
+}
+
+impl Node {
+ fn new(matches: &ArgMatches) -> Result<Self> {
+ let _ = rustls::crypto::ring::default_provider().install_default();
+ let mut url: reqwest::Url = matches
+ .get_one::<String>("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::<String>("token").cloned(),
+ })
+ }
+
+ fn request(&self, method: reqwest::Method, path: &str) -> Result<reqwest::RequestBuilder> {
+ 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<reqwest::Response> {
+ 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<JsonValue> {
+ 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<Id>)> {
+ 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<JsonValue> {
+ self.get("/events/counts").await
+ }
+
+ async fn current(&self) -> Result<Version> {
+ current(&self.counts().await?)
+ }
+
+ /// The bytes of an event the node's store holds.
+ async fn event(&self, id: &Id) -> Result<Vec<u8>> {
+ 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 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();
+ }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 323bbc1..c3bfac9 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,5 +1,7 @@
//! continuum: a replicated Automerge document, read and written by path, synchronized
-//! over Mycelium, libp2p or Tor; as a library, which the node (`main.rs`) runs (`run`).
+//! over Mycelium, libp2p or Tor; as a library, which the node (`main.rs`) runs (`run`),
+//! and, behind the `federation` feature, a party's client (`bin/continuum-party.rs`,
+//! `party`).
//!
//! `run` only wires things together: arguments, the starting document, the node
//! (`node`), bootstrap and the HTTP server.
@@ -42,6 +44,12 @@ use document::replica::Epoch;
use swarm::bootstrap;
use transport::Transport;
+/// Runs a party's client of a federation (`continuum-party`), as its arguments say.
+#[cfg(feature = "federation")]
+pub async fn party() -> Result<()> {
+ federation::party::main().await
+}
+
/// Runs a node, as its arguments and configuration say, until it stops.
pub async fn run() -> Result<()> {
logging::init();