edits.rs 89.0%

81 of 91 lines run, 12 of 30 functions · run #541 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
}

/// Land onto `bookmark` the state with `heads`, its conflicts settled by
/// `edits` (oxygen#145: union files' adjacent insertions, both sides kept):
/// a resolution change on `heads`, authored by the user and signed by the
/// hub key as their delegate, and the bookmark moved to it in one update.
/// The new heads.
pub async fn land_resolved(
    repos: &Repos,
    repo: &RepoName,
    bookmark: String,
    heads: Vec<ChangeHash>,
    edits: Vec<FileEdit>,
    message: String,
    signer: Signer,
) -> Result<Vec<ChangeHash>> {
    repos
        .write(repo, move |r: &Repo, _| {
            let change = r.build_change(&heads, &edits, &message, signer.author.hash())?;
            let hash = change.hash();
            let sig = signer.hub_secret.sign(Domain::Change, &signer.hub_key, &hash);
            let mut state = r.load_state(&heads)?;
            state.add(change.clone()).map_err(|e| fail(e.to_string()))?;
            let mut candidates = heads.clone();
            candidates.push(hash);
            let new_heads = state.maximal(&candidates);
            let update = r.host_ref_update(&bookmark, &new_heads, Some((&signer.hub_key, &signer.hub_secret)))?;
            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 landing: {}", refused.reason)));
            }
            Ok(new_heads)
        })
        .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	32×	pub async fn commit(
40	32×	repos: &Repos,
41	32×	repo: &RepoName,
42	32×	base_bookmark: String,
43	32×	bookmark: String,
44	32×	edits: Vec<FileEdit>,
45	32×	message: String,
46	32×	signer: Signer,
47	32×	) -> Result<Committed> {
48	32×	repos
49	32×	.write(repo, move \|r: &Repo, _\| {
50	32×	let view = r.view()?;
51	32×	let base_heads = match view.bookmarks.get(&base_bookmark) {
52	32×	Some(st) => r.store().get_state(st)?.heads,
53	0×	None => return Err(fail(format!("no bookmark {base_bookmark}"))),
54		};
55	32×	if bookmark != base_bookmark && view.bookmarks.contains_key(&bookmark) {
56	0×	return Err(fail(format!("bookmark {bookmark} exists; pick another name")));
57	32×	}
58	32×	let author = signer.author.hash();
59	32×	let change = r.build_change(&base_heads, &edits, &message, author)?;
60	31×	let hash = change.hash();
61	31×	let sig = signer.hub_secret.sign(Domain::Change, &signer.hub_key, &hash);
62	31×	let mut state = r.load_state(&base_heads)?;
63	31×	state.add(change.clone()).map_err(\|e\| fail(e.to_string()))?;
64	31×	let mut candidates = base_heads.clone();
65	31×	candidates.push(hash);
66	31×	let heads = state.maximal(&candidates);
67	31×	let update = r.host_ref_update(&bookmark, &heads, Some((&signer.hub_key, &signer.hub_secret)))?;
68	31×	let (old_state, new_state) = (update.old_state.to_hex(), update.new_state.to_hex());
69	31×	let report = r.apply_hosted(Some((change, vec![sig])), &[signer.hub_identity.clone(), signer.author.clone()], update)?;
70	31×	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	31×	}
73	31×	Ok(Committed { change: hash, bookmark, old_state, new_state, heads, report })
74	32×	})
75	32×	.await
76	32×	}
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	12×	pub async fn move_bookmark(repos: &Repos, repo: &RepoName, bookmark: String, heads: Vec<ChangeHash>, signer: Signer) -> Result<PushReport> {
81	12×	repos
82	12×	.write(repo, move \|r: &Repo, _\| {
83	12×	let update = r.host_ref_update(&bookmark, &heads, Some((&signer.hub_key, &signer.hub_secret)))?;
84	12×	let report = r.apply_hosted(None, &[signer.hub_identity.clone(), signer.author.clone()], update)?;
85	12×	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	12×	}
88	12×	Ok(report)
89	12×	})
90	12×	.await
91	12×	}
92
93		/// Land onto `bookmark` the state with `heads`, its conflicts settled by
94		/// `edits` (oxygen#145: union files' adjacent insertions, both sides kept):
95		/// a resolution change on `heads`, authored by the user and signed by the
96		/// hub key as their delegate, and the bookmark moved to it in one update.
97		/// The new heads.
98	1×	pub async fn land_resolved(
99	1×	repos: &Repos,
100	1×	repo: &RepoName,
101	1×	bookmark: String,
102	1×	heads: Vec<ChangeHash>,
103	1×	edits: Vec<FileEdit>,
104	1×	message: String,
105	1×	signer: Signer,
106	1×	) -> Result<Vec<ChangeHash>> {
107	1×	repos
108	1×	.write(repo, move \|r: &Repo, _\| {
109	1×	let change = r.build_change(&heads, &edits, &message, signer.author.hash())?;
110	1×	let hash = change.hash();
111	1×	let sig = signer.hub_secret.sign(Domain::Change, &signer.hub_key, &hash);
112	1×	let mut state = r.load_state(&heads)?;
113	1×	state.add(change.clone()).map_err(\|e\| fail(e.to_string()))?;
114	1×	let mut candidates = heads.clone();
115	1×	candidates.push(hash);
116	1×	let new_heads = state.maximal(&candidates);
117	1×	let update = r.host_ref_update(&bookmark, &new_heads, Some((&signer.hub_key, &signer.hub_secret)))?;
118	1×	let report = r.apply_hosted(Some((change, vec![sig])), &[signer.hub_identity.clone(), signer.author.clone()], update)?;
119	1×	if let Some(refused) = report.results.iter().find(\|x\| !x.ok) {
120	0×	return Err(fail(format!("the repository refused the landing: {}", refused.reason)));
121	1×	}
122	1×	Ok(new_heads)
123	1×	})
124	1×	.await
125	1×	}

`/`	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 89.0%

Keyboard