diff options
| author | tv <tv@krebsco.de> | 2026-11-16 19:35:23 +0000 |
|---|---|---|
| committer | tv <tv@krebsco.de> | 2026-11-16 21:25:02 +0100 |
| commit | 69d2aace79eb61d800afa3a0779cfe3a9dfe1039 (patch) | |
| tree | a768fdc2d1da949b8fb17824866623bb45bb37cc | |
| parent | 969767fa5270f90fb3b289177d83d6baab1cbdc2 (diff) | |
access: the policy of a swarm holding a store
`{"version": 2, "store": "<fold>"}` at the policy's place is a swarm holding a store of
that fold (`docs/store.md`, What the document holds). Behind the `federation` feature, a
node reads it as `Policy::Store` where the fold is one it has (`federation`) and nothing
else is written there: changes judged, and signed, as required; not strict. Its `store`
reads so only where it is a string, as `values` of a strict policy. A swarm holds a store
from its genesis change only, so `--bootstrap-policy` takes none.
Without the feature, a policy of version 2 stays one the node doesn't know.
| -rw-r--r-- | src/access/policy.rs | 127 | ||||
| -rw-r--r-- | src/document/events.rs | 2 |
2 files changed, 113 insertions, 16 deletions
diff --git a/src/access/policy.rs b/src/access/policy.rs index 9d6d198..e75dce5 100644 --- a/src/access/policy.rs +++ b/src/access/policy.rs @@ -10,7 +10,10 @@ //! (strict): signatures required, and what decides who may do what (the user registry, //! the policy and the rest of `_continuum/access`, bans) and the paths listed in //! `_continuum/access/userSigned` hold values their users signed (`access::envelope`), -//! so no member writes there but as a user signed it. A policy +//! so no member writes there but as a user signed it. `{"version": 2, "store": "<fold>"}`, +//! behind the `federation` feature: a swarm holding a store of that fold +//! (`docs/store.md`), written by its genesis change only (`document::events`), its +//! changes judged by what they write (`access::holding`) and signed, as required. A policy //! this node doesn't know (another version, or a setting it lacks) stops it from taking //! writes through the API, and it receives without judging: it can't judge as the //! others do, so it writes nothing they might refuse, until it is upgraded. @@ -19,8 +22,10 @@ use serde_json::Value as JsonValue; use crate::document::{ReadDoc, meta, store}; -/// The policy versions this node knows. +/// The policy versions this node knows: rules by path, and a swarm holding a store. pub(crate) const VERSION: u64 = 1; +#[cfg(feature = "federation")] +pub(crate) const STORE: u64 = 2; /// Where the policy is. pub(crate) fn path() -> Vec<String> { @@ -35,18 +40,32 @@ pub(crate) enum Policy { /// Rules by path enforced; with signatures `required`, only on changes a signature /// proves. Enforced { required: bool, strict: bool }, + /// A swarm holding a store of the fold so named: changes judged by what they write, + /// and signed. + #[cfg(feature = "federation")] + Store(&'static str), /// One this node doesn't know, and why. Unknown(String), } impl Policy { pub(crate) fn enforced(&self) -> bool { - matches!(self, Policy::Enforced { .. }) + match self { + Policy::Enforced { .. } => true, + #[cfg(feature = "federation")] + Policy::Store(_) => true, + _ => false, + } } - /// Whether changes need a signature (`signatures: "required"`). + /// Whether changes need a signature (`signatures: "required"`, or a store). pub(crate) fn required(&self) -> bool { - matches!(self, Policy::Enforced { required: true, .. }) + match self { + Policy::Enforced { required, .. } => *required, + #[cfg(feature = "federation")] + Policy::Store(_) => true, + _ => false, + } } /// Whether values at the user-signed paths need their users' signatures @@ -72,6 +91,11 @@ pub(crate) fn first( match as_written(&value).map_err(|error| format!("bootstrap-policy: {error}"))? { Policy::Unknown(why) => Err(format!("bootstrap-policy: one this node doesn't know: {why}")), Policy::Open => Err("bootstrap-policy: no policy".to_owned()), + #[cfg(feature = "federation")] + Policy::Store(_) => Err( + "bootstrap-policy: a swarm holds a store from its root's genesis change only (store-root)" + .to_owned(), + ), policy if policy.strict() && bootstrap_keys.is_empty() => Err( "bootstrap-policy: strict, but no bootstrap-keys: nobody could sign what decides who may do what" .to_owned(), @@ -90,16 +114,20 @@ pub(crate) fn as_written(value: &JsonValue) -> Result<Policy, String> { Ok(policy) } -/// The policy `doc` holds. Strict only where its `values` is a string, as continuum -/// writes it: an Automerge text there, or one holding the policy, reads as a string in -/// plain JSON, so a policy that would read strict only through a text is one nobody -/// knows, never what its characters spell. +/// The policy `doc` holds. Strict only where its `values` is a string, and a store's only +/// where its `store` is, as continuum writes them: an Automerge text there, or one holding +/// the policy, reads as a string in plain JSON, so a policy that would read so only +/// through a text is one nobody knows, never what its characters spell. pub(crate) fn of(doc: &impl ReadDoc) -> Policy { match store::read_plain(doc, &path()) { Ok(Some(value)) => match read(&value) { - policy if policy.strict() && !values_a_string(doc) => { + policy if policy.strict() && !a_string(doc, "values") => { Policy::Unknown("values not a string".to_owned()) } + #[cfg(feature = "federation")] + Policy::Store(_) if !a_string(doc, "store") => { + Policy::Unknown("store not a string".to_owned()) + } policy => policy, }, Ok(None) => Policy::Open, @@ -108,27 +136,32 @@ pub(crate) fn of(doc: &impl ReadDoc) -> Policy { } /// Whether the policy `doc` holds, read in typed JSON (where a text is tagged, and an -/// envelope reads as its payload), has a string for its `values`. -fn values_a_string(doc: &impl ReadDoc) -> bool { +/// envelope reads as its payload), has a string for its `key`. +fn a_string(doc: &impl ReadDoc, key: &str) -> bool { let typed = crate::document::typed::JsonForm { typed: true, ..Default::default() }; matches!( store::read_plain_as(doc, &path(), typed), - Ok(Some(value)) if value.get("values").is_some_and(JsonValue::is_string) + Ok(Some(value)) if value.get(key).is_some_and(JsonValue::is_string) ) } /// The policy `value`, as the policy's place holds it, says. pub(crate) fn read(value: &JsonValue) -> Policy { let version = value.get("version").and_then(JsonValue::as_u64); + #[cfg(feature = "federation")] + if version == Some(STORE) { + return store_of(value); + } if version != Some(VERSION) { return Policy::Unknown(format!( - "version {}, this node knows {VERSION}", + "version {}, this node knows {}", value .get("version") - .map_or("none".to_owned(), JsonValue::to_string) + .map_or("none".to_owned(), JsonValue::to_string), + known() )); } let strict = match value.get("values").and_then(JsonValue::as_str) { @@ -150,6 +183,30 @@ pub(crate) fn read(value: &JsonValue) -> Policy { } } +/// The versions this node knows, as its refusals name them. +fn known() -> &'static str { + #[cfg(feature = "federation")] + return "1 and 2"; + #[cfg(not(feature = "federation"))] + return "1"; +} + +/// The store a policy of version 2 names: one this node has, and nothing else written. +#[cfg(feature = "federation")] +fn store_of(value: &JsonValue) -> Policy { + use crate::federation::store::Fold; + let fold = crate::federation::fold::Federation::NAME; + match value.as_object() { + Some(policy) if policy.len() == 2 && policy.get("store") == Some(&fold.into()) => { + Policy::Store(fold) + } + _ => Policy::Unknown(format!( + "a store, other than {}", + crate::document::events::policy(fold) + )), + } +} + #[cfg(test)] mod tests { use super::*; @@ -198,6 +255,7 @@ mod tests { Policy::Unknown(_) )); assert!(matches!(with(json!({"version": 2})), Policy::Unknown(_))); + assert!(matches!(with(json!({"version": 3})), Policy::Unknown(_))); assert!(matches!( with(json!({"version": 1, "signatures": "sometimes"})), Policy::Unknown(_) @@ -229,6 +287,45 @@ mod tests { )); } + /// A swarm holding a store of a fold this node has, as its genesis change writes it, + /// and nothing else. + #[cfg(feature = "federation")] + #[test] + fn a_store_is_one_the_node_has() { + let store = with(json!({"version": 2, "store": "federation"})); + assert_eq!(store, Policy::Store("federation")); + assert!(store.enforced() && store.required() && !store.strict()); + assert!(matches!( + with(json!({"version": 2, "store": "test"})), + Policy::Unknown(_) + )); + assert!(matches!( + with(json!({"version": 2, "store": "federation", "values": "signed"})), + Policy::Unknown(_) + )); + let mut doc = Document::new(); + change(&mut doc, |doc| { + store::write_val_path( + doc, + &path(), + &crate::document::typed::Val::Map(vec![ + ( + "store".to_owned(), + crate::document::typed::Val::Text("federation".to_owned()), + ), + ( + "version".to_owned(), + crate::document::typed::Val::Scalar(2.into()), + ), + ]), + store::Writing::sticky(Default::default()), + ) + .unwrap(); + }); + assert!(matches!(of(&doc), Policy::Unknown(_))); + assert!(first(Some(r#"{"version": 2, "store": "federation"}"#), &[]).is_err()); + } + /// A new swarm's policy: one this node knows; strict, only with keys to sign. #[test] fn the_first_policy() { diff --git a/src/document/events.rs b/src/document/events.rs index 873d3e3..7b0fe5e 100644 --- a/src/document/events.rs +++ b/src/document/events.rs @@ -9,8 +9,8 @@ //! and it has no message. #![allow(dead_code)] -use automerge::transaction::CommitOptions; use automerge::legacy::OpType; +use automerge::transaction::CommitOptions; use automerge::{ObjId, ObjType, ScalarValue, Value}; use serde_json::Value as JsonValue; |
