aboutsummaryrefslogtreecommitdiffstats
path: root/src/access/policy.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/access/policy.rs')
-rw-r--r--src/access/policy.rs127
1 files changed, 112 insertions, 15 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() {