edits.rs 86.4%

51 of 59 lines run, 8 of 20 functions · run #471 on main · run missed

//! Changes the hub makes for a signed-in user (hub spec §6.9, §6.10, §7.6):
//! built on the target state, authored by the user's linked identity,
//! signed by the hub key as that identity's delegate, and applied through
//! the same checks as a push.

use super::{RepoError, Repos};
use crate::repos::RepoName;
use oxy_core::hash::{ChangeHash, KeyId};
use oxy_core::identity::{Domain, Identity, SecretKey};
use oxy_core::repo::{FileEdit, PushReport, Repo};

type Result<T> = std::result::Result<T, RepoError>;

fn fail(msg: impl Into<String>) -> RepoError {
    RepoError::Oxy(oxy_core::repo::RepoError::Msg(msg.into()))
}

/// Who the change is for and who signs it.
pub struct Signer {
    /// The user's identity that lists the hub key as a delegate.
    pub author: Identity,
    pub hub_key: KeyId,
    pub hub_secret: SecretKey,
    pub hub_identity: Identity,
}

/// What a web edit did.
pub struct Committed {
    pub change: ChangeHash,
    pub bookmark: String,
    pub old_state: String,
    pub new_state: String,
    pub heads: Vec<ChangeHash>,
    pub report: PushReport,
}

/// Commit `edits` on top of `base_bookmark`'s state into `bookmark`
/// (the same bookmark, or a new one for a proposal).
pub async fn commit(
    repos: &Repos,
    repo: &RepoName,
    base_bookmark: String,
    bookmark: String,
    edits: Vec<FileEdit>,
    message: String,
    signer: Signer,
) -> Result<Committed> {
    repos
        .write(repo, move |r: &Repo, _| {
            let view = r.view()?;
            let base_heads = match view.bookmarks.get(&base_bookmark) {
                Some(st) => r.store().get_state(st)?.heads,
                None => return Err(fail(format!("no bookmark {base_bookmark}"))),
            };
            if bookmark != base_bookmark && view.bookmarks.contains_key(&bookmark) {
                return Err(fail(format!("bookmark {bookmark} exists; pick another name")));
            }
            let author = signer.author.hash();
            let change = r.build_change(&base_heads, &edits, &message, author)?;
            let hash = change.hash();
            let sig = signer.hub_secret.sign(Domain::Change, &signer.hub_key, &hash);
            let mut state = r.load_state(&base_heads)?;
            state.add(change.clone()).map_err(|e| fail(e.to_string()))?;
            let mut candidates = base_heads.clone();
            candidates.push(hash);
            let heads = state.maximal(&candidates);
            let update = r.host_ref_update(&bookmark, &heads, Some((&signer.hub_key, &signer.hub_secret)))?;
            let (old_state, new_state) = (update.old_state.to_hex(), update.new_state.to_hex());
            let report = r.apply_hosted(Some((change, vec![sig])), &[signer.hub_identity.clone(), signer.author.clone()], update)?;
            if let Some(refused) = report.results.iter().find(|x| !x.ok) {
                return Err(fail(format!("the repository refused the change: {}", refused.reason)));
            }
            Ok(Committed { change: hash, bookmark, old_state, new_state, heads, report })
        })
        .await
}

/// Move `bookmark` to `heads` with an attestation signed by the hub key on
/// the user's behalf (landing a proposal under a policy).
pub async fn move_bookmark(repos: &Repos, repo: &RepoName, bookmark: String, heads: Vec<ChangeHash>, signer: Signer) -> Result<PushReport> {
    repos
        .write(repo, move |r: &Repo, _| {
            let update = r.host_ref_update(&bookmark, &heads, Some((&signer.hub_key, &signer.hub_secret)))?;
            let report = r.apply_hosted(None, &[signer.hub_identity.clone(), signer.author.clone()], update)?;
            if let Some(refused) = report.results.iter().find(|x| !x.ok) {
                return Err(fail(format!("the repository refused the update: {}", refused.reason)));
            }
            Ok(report)
        })
        .await
}

1		//! Changes the hub makes for a signed-in user (hub spec §6.9, §6.10, §7.6):
2		//! built on the target state, authored by the user's linked identity,
3		//! signed by the hub key as that identity's delegate, and applied through
4		//! the same checks as a push.
5
6		use super::{RepoError, Repos};
7		use crate::repos::RepoName;
8		use oxy_core::hash::{ChangeHash, KeyId};
9		use oxy_core::identity::{Domain, Identity, SecretKey};
10		use oxy_core::repo::{FileEdit, PushReport, Repo};
11
12		type Result<T> = std::result::Result<T, RepoError>;
13
14	0×	fn fail(msg: impl Into<String>) -> RepoError {
15	0×	RepoError::Oxy(oxy_core::repo::RepoError::Msg(msg.into()))
16	0×	}
17
18		/// Who the change is for and who signs it.
19		pub struct Signer {
20		/// The user's identity that lists the hub key as a delegate.
21		pub author: Identity,
22		pub hub_key: KeyId,
23		pub hub_secret: SecretKey,
24		pub hub_identity: Identity,
25		}
26
27		/// What a web edit did.
28		pub struct Committed {
29		pub change: ChangeHash,
30		pub bookmark: String,
31		pub old_state: String,
32		pub new_state: String,
33		pub heads: Vec<ChangeHash>,
34		pub report: PushReport,
35		}
36
37		/// Commit `edits` on top of `base_bookmark`'s state into `bookmark`
38		/// (the same bookmark, or a new one for a proposal).
39	23×	pub async fn commit(
40	23×	repos: &Repos,
41	23×	repo: &RepoName,
42	23×	base_bookmark: String,
43	23×	bookmark: String,
44	23×	edits: Vec<FileEdit>,
45	23×	message: String,
46	23×	signer: Signer,
47	23×	) -> Result<Committed> {
48	23×	repos
49	23×	.write(repo, move \|r: &Repo, _\| {
50	23×	let view = r.view()?;
51	23×	let base_heads = match view.bookmarks.get(&base_bookmark) {
52	23×	Some(st) => r.store().get_state(st)?.heads,
53	0×	None => return Err(fail(format!("no bookmark {base_bookmark}"))),
54		};
55	23×	if bookmark != base_bookmark && view.bookmarks.contains_key(&bookmark) {
56	0×	return Err(fail(format!("bookmark {bookmark} exists; pick another name")));
57	23×	}
58	23×	let author = signer.author.hash();
59	23×	let change = r.build_change(&base_heads, &edits, &message, author)?;
60	22×	let hash = change.hash();
61	22×	let sig = signer.hub_secret.sign(Domain::Change, &signer.hub_key, &hash);
62	22×	let mut state = r.load_state(&base_heads)?;
63	22×	state.add(change.clone()).map_err(\|e\| fail(e.to_string()))?;
64	22×	let mut candidates = base_heads.clone();
65	22×	candidates.push(hash);
66	22×	let heads = state.maximal(&candidates);
67	22×	let update = r.host_ref_update(&bookmark, &heads, Some((&signer.hub_key, &signer.hub_secret)))?;
68	22×	let (old_state, new_state) = (update.old_state.to_hex(), update.new_state.to_hex());
69	22×	let report = r.apply_hosted(Some((change, vec![sig])), &[signer.hub_identity.clone(), signer.author.clone()], update)?;
70	22×	if let Some(refused) = report.results.iter().find(\|x\| !x.ok) {
71	0×	return Err(fail(format!("the repository refused the change: {}", refused.reason)));
72	22×	}
73	22×	Ok(Committed { change: hash, bookmark, old_state, new_state, heads, report })
74	23×	})
75	23×	.await
76	23×	}
77
78		/// Move `bookmark` to `heads` with an attestation signed by the hub key on
79		/// the user's behalf (landing a proposal under a policy).
80	8×	pub async fn move_bookmark(repos: &Repos, repo: &RepoName, bookmark: String, heads: Vec<ChangeHash>, signer: Signer) -> Result<PushReport> {
81	8×	repos
82	8×	.write(repo, move \|r: &Repo, _\| {
83	8×	let update = r.host_ref_update(&bookmark, &heads, Some((&signer.hub_key, &signer.hub_secret)))?;
84	8×	let report = r.apply_hosted(None, &[signer.hub_identity.clone(), signer.author.clone()], update)?;
85	8×	if let Some(refused) = report.results.iter().find(\|x\| !x.ok) {
86	0×	return Err(fail(format!("the repository refused the update: {}", refused.reason)));
87	8×	}
88	8×	Ok(report)
89	8×	})
90	8×	.await
91	8×	}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

Coverage / crates/hub/src/repos/edits.rs 86.4%

Keyboard