diff --git a/Cargo.lock b/Cargo.lock index a41b6a4..ee465ca 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -82,6 +82,78 @@ dependencies = [ "rustversion", ] +[[package]] +name = "async-trait" +version = "0.1.92" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82f6aeea286b8eb4dd3431a1be1b59d290ace00f5bfd8e2a159bc2a05e2c1667" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.4", +] + +[[package]] +name = "atomic-waker" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" + +[[package]] +name = "axum" +version = "0.7.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edca88bc138befd0323b20752846e6587272d3b03b0343c8ea28a6f819e6e71f" +dependencies = [ + "async-trait", + "axum-core", + "bytes", + "futures-util", + "http", + "http-body", + "http-body-util", + "hyper", + "hyper-util", + "itoa", + "matchit", + "memchr", + "mime", + "percent-encoding", + "pin-project-lite", + "rustversion", + "serde", + "serde_json", + "serde_path_to_error", + "serde_urlencoded", + "sync_wrapper", + "tokio", + "tower", + "tower-layer", + "tower-service", + "tracing", +] + +[[package]] +name = "axum-core" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09f2bd6146b97ae3359fa0cc6d6b376d9539582c7b4220f041a33ec24c226199" +dependencies = [ + "async-trait", + "bytes", + "futures-util", + "http", + "http-body", + "http-body-util", + "mime", + "pin-project-lite", + "rustversion", + "sync_wrapper", + "tower-layer", + "tower-service", + "tracing", +] + [[package]] name = "bitflags" version = "1.3.2" @@ -120,6 +192,12 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" +[[package]] +name = "bytes" +version = "1.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04" + [[package]] name = "cfg-if" version = "1.0.4" @@ -293,6 +371,48 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" +[[package]] +name = "form_urlencoded" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "futures-channel" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1f9e3d69d39e4862ffed03ed071a76f9a13ba1d9109d355b0f0aa6b15e393c4" +dependencies = [ + "futures-core", +] + +[[package]] +name = "futures-core" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e" + +[[package]] +name = "futures-task" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd" + +[[package]] +name = "futures-util" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc" +dependencies = [ + "futures-core", + "futures-task", + "pin-project-lite", + "slab", +] + [[package]] name = "generic-array" version = "0.14.7" @@ -640,6 +760,86 @@ version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" +[[package]] +name = "http" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "918d3568bebf352712bc2ef3d46a8bcf1a75b373be6539de198e9105cbbf9ce0" +dependencies = [ + "bytes", + "itoa", +] + +[[package]] +name = "http-body" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca2a8f2913ee65f60facd6a5905613afaa448497a0230cc41ce022d93290bc2c" +dependencies = [ + "bytes", + "http", +] + +[[package]] +name = "http-body-util" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23169fe34a5fbcdd3f3862e78fb9b6fccd5f02a6dc6f732547005d45631ce71c" +dependencies = [ + "bytes", + "futures-core", + "http", + "http-body", + "pin-project-lite", +] + +[[package]] +name = "httparse" +version = "1.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" + +[[package]] +name = "httpdate" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9" + +[[package]] +name = "hyper" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27b501faa50e7a26c3d3560ca625132f4078a17771f4810baf70475ae48cbe43" +dependencies = [ + "atomic-waker", + "bytes", + "futures-channel", + "futures-core", + "http", + "http-body", + "httparse", + "httpdate", + "itoa", + "pin-project-lite", + "smallvec", + "tokio", +] + +[[package]] +name = "hyper-util" +version = "0.1.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0" +dependencies = [ + "bytes", + "http", + "http-body", + "hyper", + "pin-project-lite", + "tokio", + "tower-service", +] + [[package]] name = "is_terminal_polyfill" version = "1.70.2" @@ -732,6 +932,12 @@ version = "0.4.34" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6" +[[package]] +name = "matchit" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94" + [[package]] name = "memchr" version = "2.8.3" @@ -747,6 +953,12 @@ dependencies = [ "libc", ] +[[package]] +name = "mime" +version = "0.3.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a" + [[package]] name = "miniz_oxide" version = "0.8.9" @@ -757,6 +969,17 @@ dependencies = [ "simd-adler32", ] +[[package]] +name = "mio" +version = "1.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b18443e9c262bfe8fa82f51666e2642c53393f7e5c27b3e1aeab922cff5b9d8" +dependencies = [ + "libc", + "wasi", + "windows-sys", +] + [[package]] name = "once_cell" version = "1.21.4" @@ -792,6 +1015,18 @@ dependencies = [ "windows-link", ] +[[package]] +name = "percent-encoding" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" + +[[package]] +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + [[package]] name = "portable-atomic" version = "1.15.0" @@ -871,6 +1106,7 @@ name = "rit" version = "0.1.0" dependencies = [ "anyhow", + "axum", "clap", "diffy", "flate2", @@ -883,6 +1119,7 @@ dependencies = [ "sha1", "tempfile", "thiserror", + "tokio", ] [[package]] @@ -904,6 +1141,12 @@ version = "1.0.23" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f" +[[package]] +name = "ryu" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f" + [[package]] name = "same-file" version = "1.0.6" @@ -948,6 +1191,42 @@ dependencies = [ "syn 3.0.4", ] +[[package]] +name = "serde_json" +version = "1.0.151" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "serde_path_to_error" +version = "0.1.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10a9ff822e371bb5403e391ecd83e182e0e77ba7f6fe0160b795797109d1b457" +dependencies = [ + "itoa", + "serde", + "serde_core", +] + +[[package]] +name = "serde_urlencoded" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" +dependencies = [ + "form_urlencoded", + "itoa", + "ryu", + "serde", +] + [[package]] name = "sha1" version = "0.10.7" @@ -975,12 +1254,28 @@ version = "0.3.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea" +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + [[package]] name = "smallvec" version = "1.15.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90" +[[package]] +name = "socket2" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4" +dependencies = [ + "libc", + "windows-sys", +] + [[package]] name = "stable_deref_trait" version = "1.2.1" @@ -1015,6 +1310,12 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "sync_wrapper" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263" + [[package]] name = "tempfile" version = "3.27.0" @@ -1063,6 +1364,79 @@ version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" +[[package]] +name = "tokio" +version = "1.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "202caea871b69668250d242070849eb495be178ed697a3e98aebce5bc81a0bed" +dependencies = [ + "libc", + "mio", + "pin-project-lite", + "socket2", + "tokio-macros", + "windows-sys", +] + +[[package]] +name = "tokio-macros" +version = "2.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78773a2a397f451582ce068015985c33193cf6dea8b74d2a639fe457b2f07b0e" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.4", +] + +[[package]] +name = "tower" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4" +dependencies = [ + "futures-core", + "futures-util", + "pin-project-lite", + "sync_wrapper", + "tokio", + "tower-layer", + "tower-service", + "tracing", +] + +[[package]] +name = "tower-layer" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e" + +[[package]] +name = "tower-service" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3" + +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "log", + "pin-project-lite", + "tracing-core", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" +dependencies = [ + "once_cell", +] + [[package]] name = "typenum" version = "1.20.1" @@ -1106,6 +1480,12 @@ dependencies = [ "winapi-util", ] +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + [[package]] name = "winapi-util" version = "0.1.11" @@ -1144,3 +1524,9 @@ name = "zlib-rs" version = "0.6.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "34b31d188d9d685a4f9c7b46d6e36631b07058d2cfe190267adce54dc230bf12" + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/Cargo.toml b/Cargo.toml index 2952c05..d76284f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -31,5 +31,11 @@ globset = "=0.4.20" sha1 = "0.10" thiserror = "2" +# Smart-HTTP transport (Phase 3 C). axum/tokio power the async listener; the +# pkt-line/pack/negotiation logic stays in the synchronous core and is called +# from `spawn_blocking`, so no async colours the object/ref/pack plumbing. +axum = "0.7" +tokio = { version = "1", features = ["rt-multi-thread", "net"] } + [dev-dependencies] tempfile = "3" diff --git a/src/branch.rs b/src/branch.rs index 7fe8e87..21c7f6a 100644 --- a/src/branch.rs +++ b/src/branch.rs @@ -105,14 +105,7 @@ pub fn cmd_branch_create( let message = format!("branch: Created from {source_desc}"); repo.branch_create( - name, - start_oid, - force, - &sig.name, - &sig.email, - sig.time, - &sig.tz, - &message, + name, start_oid, force, &sig.name, &sig.email, sig.time, &sig.tz, &message, ) .with_context(|| format!("creating branch {name:?}"))?; @@ -125,11 +118,7 @@ pub fn cmd_branch_create( /// (equivalent to `git branch -D`). /// /// Prints a confirmation line for each deleted branch. -pub fn cmd_branch_delete( - repo: &Repository, - names: &[&str], - force: bool, -) -> anyhow::Result<()> { +pub fn cmd_branch_delete(repo: &Repository, names: &[&str], force: bool) -> anyhow::Result<()> { if names.is_empty() { bail!("branch --delete requires at least one branch name"); } @@ -159,13 +148,7 @@ pub fn cmd_branch_rename( sig: &Signature, ) -> anyhow::Result<()> { repo.branch_rename( - old_name, - new_name, - force, - &sig.name, - &sig.email, - sig.time, - &sig.tz, + old_name, new_name, force, &sig.name, &sig.email, sig.time, &sig.tz, ) .with_context(|| format!("renaming branch {old_name:?} → {new_name:?}"))?; println!("Renamed branch {old_name} to {new_name}."); @@ -177,10 +160,23 @@ pub fn cmd_branch_rename( /// Decoded branch operation — used by the convenience dispatcher. #[derive(Debug)] pub enum BranchOp<'a> { - List { verbose: bool }, - Create { name: &'a str, start: Option<&'a str>, force: bool }, - Delete { names: Vec<&'a str>, force: bool }, - Rename { old: &'a str, new: &'a str, force: bool }, + List { + verbose: bool, + }, + Create { + name: &'a str, + start: Option<&'a str>, + force: bool, + }, + Delete { + names: Vec<&'a str>, + force: bool, + }, + Rename { + old: &'a str, + new: &'a str, + force: bool, + }, } /// High-level branch dispatcher: given a decoded [`BranchOp`] and an actor @@ -188,16 +184,10 @@ pub enum BranchOp<'a> { /// /// The integrator calls this from their `cmd_branch` main.rs function after /// translating clap args into a `BranchOp`. -pub fn dispatch_branch( - repo: &Repository, - op: BranchOp<'_>, - sig: &Signature, -) -> anyhow::Result<()> { +pub fn dispatch_branch(repo: &Repository, op: BranchOp<'_>, sig: &Signature) -> anyhow::Result<()> { match op { BranchOp::List { verbose } => cmd_branch_list(repo, verbose), - BranchOp::Create { name, start, force } => { - cmd_branch_create(repo, name, start, force, sig) - } + BranchOp::Create { name, start, force } => cmd_branch_create(repo, name, start, force, sig), BranchOp::Delete { names, force } => cmd_branch_delete(repo, &names, force), BranchOp::Rename { old, new, force } => cmd_branch_rename(repo, old, new, force, sig), } diff --git a/src/checkout.rs b/src/checkout.rs index ec0cc80..4a5cb3a 100644 --- a/src/checkout.rs +++ b/src/checkout.rs @@ -90,19 +90,18 @@ pub fn cmd_switch(repo: &Repository, target: &str, create: bool) -> Result { - changes.push(TreeChange { + Some((old_mode, old_oid)) if old_oid != new_oid || old_mode != new_mode => changes + .push(TreeChange { path: path.clone(), kind: ChangeKind::Modified, old_mode: Some(old_mode.clone()), old_oid: Some(*old_oid), new_mode: Some(new_mode.clone()), new_oid: Some(*new_oid), - }) - } + }), Some(_) => {} // identical — not a change } } @@ -161,7 +160,8 @@ mod tests { fn tree(repo: &Repository, entries: Vec) -> ObjectId { let mut t = Tree { entries }; t.canonicalize(); - repo.hash_object(ObjectType::Tree, &t.serialize(), true).unwrap() + repo.hash_object(ObjectType::Tree, &t.serialize(), true) + .unwrap() } #[test] @@ -173,8 +173,16 @@ mod tests { let old = tree( &repo, vec![ - TreeEntry { mode: "100644".into(), name: b"a.txt".to_vec(), oid: a1 }, - TreeEntry { mode: "100644".into(), name: b"b.txt".to_vec(), oid: b1 }, + TreeEntry { + mode: "100644".into(), + name: b"a.txt".to_vec(), + oid: a1, + }, + TreeEntry { + mode: "100644".into(), + name: b"b.txt".to_vec(), + oid: b1, + }, ], ); let a2 = blob(&repo, b"two\n"); @@ -182,9 +190,21 @@ mod tests { let new = tree( &repo, vec![ - TreeEntry { mode: "100644".into(), name: b"a.txt".to_vec(), oid: a2 }, - TreeEntry { mode: "100644".into(), name: b"b.txt".to_vec(), oid: b1 }, - TreeEntry { mode: "100644".into(), name: b"c.txt".to_vec(), oid: c1 }, + TreeEntry { + mode: "100644".into(), + name: b"a.txt".to_vec(), + oid: a2, + }, + TreeEntry { + mode: "100644".into(), + name: b"b.txt".to_vec(), + oid: b1, + }, + TreeEntry { + mode: "100644".into(), + name: b"c.txt".to_vec(), + oid: c1, + }, ], ); let changes = diff_trees(repo.odb(), Some(old), Some(new)).unwrap(); @@ -196,6 +216,8 @@ mod tests { // Reverse diff sees the deletion. let rev = diff_trees(repo.odb(), Some(new), Some(old)).unwrap(); - assert!(rev.iter().any(|c| c.path == b"c.txt" && c.kind == ChangeKind::Deleted)); + assert!(rev + .iter() + .any(|c| c.path == b"c.txt" && c.kind == ChangeKind::Deleted)); } } diff --git a/src/diff_render.rs b/src/diff_render.rs index 7f99d82..99fcc76 100644 --- a/src/diff_render.rs +++ b/src/diff_render.rs @@ -257,7 +257,10 @@ fn commit_or_tree_oid(repo: &Repository, oid: ObjectId) -> Result { other => { return Err(ForgeError::malformed( "object", - format!("{current} is a {}, expected commit or tree", other.object_type()), + format!( + "{current} is a {}, expected commit or tree", + other.object_type() + ), )) } } @@ -482,11 +485,7 @@ fn flatten_tree( /// Fails with [`ForgeError::NoWorktree`] for bare repositories. fn repo_worktree(repo: &Repository) -> Result { let git_dir = repo.git_dir(); - if git_dir - .file_name() - .map(|n| n == ".git") - .unwrap_or(false) - { + if git_dir.file_name().map(|n| n == ".git").unwrap_or(false) { git_dir .parent() .map(|p| p.to_path_buf()) @@ -504,9 +503,7 @@ fn path_from_bytes(bytes: &[u8]) -> Result { let s = std::str::from_utf8(bytes) .map_err(|_| ForgeError::UnsafePath("non-UTF-8 path in index".into()))?; let p = Path::new(s); - if p.components() - .any(|c| !matches!(c, Component::Normal(_))) - { + if p.components().any(|c| !matches!(c, Component::Normal(_))) { return Err(ForgeError::UnsafePath(s.into())); } Ok(p.to_path_buf()) @@ -516,11 +513,7 @@ fn path_from_bytes(bytes: &[u8]) -> Result { mod tests { use super::*; - fn init_repo_with_file( - dir: &Path, - name: &str, - content: &[u8], - ) -> (Repository, ObjectId) { + fn init_repo_with_file(dir: &Path, name: &str, content: &[u8]) -> (Repository, ObjectId) { let repo = Repository::init(dir, false, Some("main")).unwrap(); let oid = repo.hash_object(ObjectType::Blob, content, true).unwrap(); (repo, oid) @@ -530,7 +523,9 @@ mod tests { fn diff_identical_trees_produces_no_output() { let dir = tempfile::tempdir().unwrap(); let repo = Repository::init(dir.path(), true, Some("main")).unwrap(); - let blob = repo.hash_object(ObjectType::Blob, b"hello\n", true).unwrap(); + let blob = repo + .hash_object(ObjectType::Blob, b"hello\n", true) + .unwrap(); let mut entry = crate::tree::Tree { entries: vec![crate::TreeEntry { @@ -540,11 +535,16 @@ mod tests { }], }; entry.canonicalize(); - let tree_oid = repo.hash_object(ObjectType::Tree, &entry.serialize(), true).unwrap(); + let tree_oid = repo + .hash_object(ObjectType::Tree, &entry.serialize(), true) + .unwrap(); let mut out = Vec::new(); diff_two_revs_with_trees(&repo, tree_oid, tree_oid, &mut out).unwrap(); - assert!(out.is_empty(), "identical trees should produce no diff output"); + assert!( + out.is_empty(), + "identical trees should produce no diff output" + ); } fn diff_two_revs_with_trees( @@ -564,7 +564,9 @@ mod tests { fn diff_addition_shows_new_file_mode_header() { let dir = tempfile::tempdir().unwrap(); let repo = Repository::init(dir.path(), true, Some("main")).unwrap(); - let blob = repo.hash_object(ObjectType::Blob, b"new content\n", true).unwrap(); + let blob = repo + .hash_object(ObjectType::Blob, b"new content\n", true) + .unwrap(); let empty_tree = repo.hash_object(ObjectType::Tree, b"", true).unwrap(); let mut new_tree_obj = crate::tree::Tree { @@ -575,13 +577,21 @@ mod tests { }], }; new_tree_obj.canonicalize(); - let new_tree = repo.hash_object(ObjectType::Tree, &new_tree_obj.serialize(), true).unwrap(); + let new_tree = repo + .hash_object(ObjectType::Tree, &new_tree_obj.serialize(), true) + .unwrap(); let mut out = Vec::new(); diff_two_revs_with_trees(&repo, empty_tree, new_tree, &mut out).unwrap(); let text = String::from_utf8(out).unwrap(); - assert!(text.contains("new file mode 100644"), "expected 'new file mode' header: {text}"); - assert!(text.contains("+++ b/new.txt"), "expected +++ header: {text}"); + assert!( + text.contains("new file mode 100644"), + "expected 'new file mode' header: {text}" + ); + assert!( + text.contains("+++ b/new.txt"), + "expected +++ header: {text}" + ); assert!(text.contains("+new content"), "expected added line: {text}"); } @@ -598,13 +608,18 @@ mod tests { }], }; old_tree_obj.canonicalize(); - let old_tree = repo.hash_object(ObjectType::Tree, &old_tree_obj.serialize(), true).unwrap(); + let old_tree = repo + .hash_object(ObjectType::Tree, &old_tree_obj.serialize(), true) + .unwrap(); let empty_tree = repo.hash_object(ObjectType::Tree, b"", true).unwrap(); let mut out = Vec::new(); diff_two_revs_with_trees(&repo, old_tree, empty_tree, &mut out).unwrap(); let text = String::from_utf8(out).unwrap(); - assert!(text.contains("deleted file mode"), "expected 'deleted file mode': {text}"); + assert!( + text.contains("deleted file mode"), + "expected 'deleted file mode': {text}" + ); assert!(text.contains("-gone"), "expected removed line: {text}"); } @@ -630,6 +645,9 @@ mod tests { ) .unwrap(); let text = String::from_utf8(out).unwrap(); - assert!(text.contains("Binary files"), "expected binary marker: {text}"); + assert!( + text.contains("Binary files"), + "expected binary marker: {text}" + ); } } diff --git a/src/http/mod.rs b/src/http/mod.rs new file mode 100644 index 0000000..986198a --- /dev/null +++ b/src/http/mod.rs @@ -0,0 +1,18 @@ +//! HTTP transport adapters for `rit`. +//! +//! This module owns the network-facing surface that lets a **stock `git` +//! client** clone, fetch, and push over HTTP against a repository served by +//! `rit`. It is deliberately thin: every byte of protocol semantics +//! (pkt-line framing, ref advertisement, negotiation, packfile generation, +//! quarantine, ref CAS) already lives in the synchronous core +//! (`upload_pack`, `receive_pack`, `wire`, `receive`). The code here only: +//! +//! 1. maps the Git **smart-HTTP** URL/verb grammar onto those core calls, and +//! 2. runs them on a blocking thread pool behind an async listener. +//! +//! No object, ref, or pack logic is reimplemented here — the adapter calls the +//! other modules' public functions and never reaches into their internals. +//! +//! See [`smart_http`] for the handlers, the router, and the listener. + +pub mod smart_http; diff --git a/src/http/smart_http.rs b/src/http/smart_http.rs new file mode 100644 index 0000000..6c74c55 --- /dev/null +++ b/src/http/smart_http.rs @@ -0,0 +1,445 @@ +//! Git **smart-HTTP** server for `rit`. +//! +//! Implements the three endpoints a stock `git` client drives when the remote +//! URL is `http(s)://…`: +//! +//! | Method + path | Purpose | +//! |-----------------------------------|-------------------------------------------| +//! | `GET /info/refs?service=git-upload-pack` | fetch/clone ref advertisement | +//! | `GET /info/refs?service=git-receive-pack` | push ref advertisement | +//! | `POST /git-upload-pack` | fetch/clone negotiation → `NAK` + packfile | +//! | `POST /git-receive-pack` | push: pack + ref commands → report-status | +//! +//! ## Layering +//! +//! The **sync core** ([`info_refs`], [`upload_pack_rpc`], [`receive_pack_rpc`]) +//! produces the exact response bytes from a [`Repository`]; it contains no async +//! and no socket code, so it is directly callable (and unit-testable) without a +//! runtime. It wraps the existing [`crate::upload_pack`] / [`crate::receive_pack`] +//! functions and adds only the smart-HTTP framing quirks: the +//! `# service=…\n` banner on `info/refs`, gzip request-body inflation, and the +//! `application/x-git-*` content types. +//! +//! The **async layer** ([`router`], [`serve`], [`serve_blocking`]) is a small +//! `axum` front door. Each handler moves the (fully buffered) request body onto +//! [`tokio::task::spawn_blocking`], opens the repository, and calls the sync +//! core — so the synchronous object/ref/pack plumbing is never run on an async +//! executor thread. +//! +//! ## Scope +//! +//! One repository per server instance (the endpoints live at the URL root). A +//! multi-repository forge composes several routers (or nests this one under a +//! per-repo path prefix); path-based repo routing, authentication, and TLS are +//! the embedding forge's concern, not this transport's. + +use std::net::SocketAddr; +use std::path::PathBuf; +use std::sync::Arc; + +use axum::body::Body; +use axum::extract::{DefaultBodyLimit, RawQuery, State}; +use axum::http::{header, HeaderMap, StatusCode}; +use axum::response::Response; +use axum::routing::{get, post}; +use axum::Router; + +use crate::error::{ForgeError, Result}; +use crate::receive::ReceiveLimits; +use crate::receive_pack::{ + advertise_receive_pack, execute_receive_pack, ReceivePackPolicy, RECEIVE_PACK_CAPABILITIES, +}; +use crate::repo::Repository; +use crate::upload_pack::{advertise_upload_pack, upload_pack_v0}; +use crate::wire::{ + encode_packet_line, encode_receive_status, parse_receive_pack_request, PacketLine, + PacketLineLimits, ReceiveStatus, +}; + +/// Default ceiling on a buffered request body (1 GiB). Push packs can be large; +/// the per-packet and per-pack limits in [`PacketLineLimits`]/[`ReceiveLimits`] +/// bound the *processing* cost, while this caps the *buffering* cost so a single +/// request cannot exhaust memory. +pub const DEFAULT_MAX_BODY_BYTES: usize = 1024 * 1024 * 1024; + +/// The two Git services reachable over smart-HTTP. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Service { + /// `git-upload-pack` — the fetch/clone (send objects to the client) side. + UploadPack, + /// `git-receive-pack` — the push (receive objects from the client) side. + ReceivePack, +} + +impl Service { + /// Map a `service=…` query value to a [`Service`]. Unknown values yield + /// `None`, which the caller turns into `403 Forbidden` (Git's convention for + /// a service that is not enabled). + pub fn from_query_value(value: &str) -> Option { + match value { + "git-upload-pack" => Some(Self::UploadPack), + "git-receive-pack" => Some(Self::ReceivePack), + _ => None, + } + } + + /// The wire service name (`git-upload-pack` / `git-receive-pack`). + pub fn name(self) -> &'static str { + match self { + Self::UploadPack => "git-upload-pack", + Self::ReceivePack => "git-receive-pack", + } + } +} + +/// Server-side policy applied to pushes — never inferred from the client. +#[derive(Clone, Debug, Default)] +pub struct SmartHttpConfig { + /// Branch short-names (e.g. `main`) whose direct push is refused with a + /// per-ref `ng` status, mirroring the CLI's protected-branch enforcement. + pub blocked_branches: Vec, + /// Allow a non-fast-forward branch update. A repository-owner decision, not + /// a capability the pushing client can grant itself. + pub allow_non_fast_forward: bool, + /// Maximum buffered request-body size in bytes. Defaults to + /// [`DEFAULT_MAX_BODY_BYTES`]. + pub max_body_bytes: usize, +} + +impl SmartHttpConfig { + /// A config with the default body cap and no protected branches. + pub fn new() -> Self { + Self { + blocked_branches: Vec::new(), + allow_non_fast_forward: false, + max_body_bytes: DEFAULT_MAX_BODY_BYTES, + } + } +} + +/// A fully-formed HTTP response produced by the synchronous core: a status, a +/// static content type, and a body. The async layer copies these onto the +/// framework's response type verbatim. +#[derive(Clone, Debug)] +pub struct SmartResponse { + pub status: u16, + pub content_type: &'static str, + pub body: Vec, +} + +impl SmartResponse { + fn ok(content_type: &'static str, body: Vec) -> Self { + Self { + status: 200, + content_type, + body, + } + } +} + +// --------------------------------------------------------------------------- +// Synchronous core — no async, no sockets. Testable against a `Repository`. +// --------------------------------------------------------------------------- + +/// Build the **smart-HTTP `info/refs` advertisement** for `service`. +/// +/// Unlike the stateful (SSH/local) advertisement, smart-HTTP prefixes the ref +/// list with a service banner and a flush: +/// +/// ```text +/// +/// 0000 +/// +/// ``` +/// +/// The banner and its flush are exactly what a stock client verifies before it +/// reads the refs; the ref lines and capabilities come straight from the core +/// [`advertise_upload_pack`] / [`advertise_receive_pack`] functions. +pub fn info_refs(repo: &Repository, service: Service) -> Result { + let mut body = encode_packet_line(&PacketLine::Data( + format!("# service={}\n", service.name()).into_bytes(), + ))?; + body.extend_from_slice(b"0000"); + match service { + Service::UploadPack => body.extend(advertise_upload_pack(repo)?), + Service::ReceivePack => { + body.extend(advertise_receive_pack(repo, RECEIVE_PACK_CAPABILITIES)?) + } + } + let content_type = match service { + Service::UploadPack => "application/x-git-upload-pack-advertisement", + Service::ReceivePack => "application/x-git-receive-pack-advertisement", + }; + Ok(SmartResponse::ok(content_type, body)) +} + +/// Serve a `POST /git-upload-pack` body: parse the `want`/`have`/`done` +/// negotiation and return `NAK` followed by the packfile. `body` must already +/// be inflated (see [`maybe_gunzip`]). +pub fn upload_pack_rpc(repo: &Repository, body: &[u8]) -> Result { + let out = upload_pack_v0(repo, body)?; + Ok(SmartResponse::ok( + "application/x-git-upload-pack-result", + out, + )) +} + +/// Serve a `POST /git-receive-pack` body: enforce protected-branch policy, then +/// quarantine the pack and apply the single ref update, returning the +/// report-status body. `body` must already be inflated (see [`maybe_gunzip`]). +pub fn receive_pack_rpc( + repo: &Repository, + body: &[u8], + config: &SmartHttpConfig, +) -> Result { + let packet_limits = PacketLineLimits::default(); + let receive_limits = ReceiveLimits::default(); + + // Protected-branch enforcement mirrors the CLI receive-pack: if any command + // targets a blocked branch, refuse the whole push with per-ref `ng` and + // never touch objects or refs. A parse failure here falls through to + // `execute_receive_pack`, which reports the framing error uniformly. + if !config.blocked_branches.is_empty() { + if let Ok(parsed) = + parse_receive_pack_request(body, RECEIVE_PACK_CAPABILITIES, packet_limits) + { + let blocked = parsed.commands.iter().any(|command| { + command + .name() + .strip_prefix("refs/heads/") + .map(|branch| config.blocked_branches.iter().any(|b| b == branch)) + .unwrap_or(false) + }); + if blocked { + let report_status = parsed.capabilities.contains("report-status") + || parsed.capabilities.contains("report-status-v2"); + let out = if report_status { + let statuses: Vec = parsed + .commands + .iter() + .map(|command| ReceiveStatus { + ref_name: command.name().to_string(), + error: Some( + "protected branch: direct push blocked, open a pull request".into(), + ), + }) + .collect(); + encode_receive_status(None, &statuses)? + } else { + Vec::new() + }; + return Ok(SmartResponse::ok( + "application/x-git-receive-pack-result", + out, + )); + } + } + } + + let execution = execute_receive_pack( + repo, + body, + RECEIVE_PACK_CAPABILITIES, + packet_limits, + receive_limits, + ReceivePackPolicy { + allow_non_fast_forward: config.allow_non_fast_forward, + }, + )?; + Ok(SmartResponse::ok( + "application/x-git-receive-pack-result", + execution.response, + )) +} + +/// Inflate a request body if it arrived `Content-Encoding: gzip`. Stock `git` +/// gzip-compresses the `git-upload-pack` negotiation body by default; the +/// `git-receive-pack` body (which already carries a compressed packfile) is +/// sent uncompressed. Returns the body unchanged when not gzip-encoded. +pub fn maybe_gunzip(body: Vec, gzip_encoded: bool) -> Result> { + if !gzip_encoded { + return Ok(body); + } + use std::io::Read; + let mut decoder = flate2::read::GzDecoder::new(&body[..]); + let mut out = Vec::new(); + decoder + .read_to_end(&mut out) + .map_err(|e| ForgeError::Decompress(format!("gzip request body: {e}")))?; + Ok(out) +} + +/// Extract the `service` value from a raw query string (`service=git-upload-pack`). +fn service_from_query(query: Option<&str>) -> Option { + let query = query?; + query + .split('&') + .filter_map(|pair| pair.split_once('=')) + .find(|(key, _)| *key == "service") + .and_then(|(_, value)| Service::from_query_value(value)) +} + +// --------------------------------------------------------------------------- +// Async layer — axum router + listener over the sync core. +// --------------------------------------------------------------------------- + +/// Shared handler state: where the (bare) repository lives and the push policy. +#[derive(Clone)] +pub struct SmartHttpState { + git_dir: Arc, + config: Arc, +} + +impl SmartHttpState { + /// Serve the repository whose Git directory is `git_dir` under `config`. + pub fn new(git_dir: impl Into, config: SmartHttpConfig) -> Self { + Self { + git_dir: Arc::new(git_dir.into()), + config: Arc::new(config), + } + } +} + +/// Build the smart-HTTP [`Router`] for one repository. +/// +/// Mount it at the URL root (a client clones `http://host/`) or nest it under a +/// path prefix for per-repo routing. The request-body limit follows +/// [`SmartHttpConfig::max_body_bytes`] so large pushes are accepted. +pub fn router(state: SmartHttpState) -> Router { + let body_limit = state.config.max_body_bytes; + Router::new() + .route("/info/refs", get(get_info_refs)) + .route("/git-upload-pack", post(post_upload_pack)) + .route("/git-receive-pack", post(post_receive_pack)) + .layer(DefaultBodyLimit::max(body_limit)) + .with_state(state) +} + +/// Bind `addr` and serve the smart-HTTP router until the process exits. +pub async fn serve(addr: SocketAddr, state: SmartHttpState) -> std::io::Result<()> { + let listener = tokio::net::TcpListener::bind(addr).await?; + axum::serve(listener, router(state)).await +} + +/// Blocking entry point for a synchronous CLI: build a multi-threaded Tokio +/// runtime and drive [`serve`] to completion. Lets a plain `fn main` host the +/// server without becoming async itself. +pub fn serve_blocking(addr: SocketAddr, state: SmartHttpState) -> Result<()> { + let runtime = tokio::runtime::Builder::new_multi_thread() + .enable_all() + .build() + .map_err(ForgeError::Io)?; + runtime.block_on(serve(addr, state)).map_err(ForgeError::Io) +} + +/// `GET /info/refs?service=git-(upload|receive)-pack`. +async fn get_info_refs(State(state): State, RawQuery(query): RawQuery) -> Response { + let Some(service) = service_from_query(query.as_deref()) else { + // No/unknown service: this transport speaks smart-HTTP only. + return error_response( + StatusCode::FORBIDDEN, + "service not enabled (smart HTTP only)", + ); + }; + let git_dir = state.git_dir.clone(); + let produced = + run_blocking(move || info_refs(&Repository::open_git_dir(&*git_dir)?, service)).await; + into_response(produced) +} + +/// `POST /git-upload-pack` — fetch/clone negotiation. +async fn post_upload_pack( + State(state): State, + headers: HeaderMap, + body: axum::body::Bytes, +) -> Response { + let gzip = is_gzip(&headers); + let git_dir = state.git_dir.clone(); + let raw = body.to_vec(); + let produced = run_blocking(move || { + let body = maybe_gunzip(raw, gzip)?; + upload_pack_rpc(&Repository::open_git_dir(&*git_dir)?, &body) + }) + .await; + into_response(produced) +} + +/// `POST /git-receive-pack` — push. +async fn post_receive_pack( + State(state): State, + headers: HeaderMap, + body: axum::body::Bytes, +) -> Response { + let gzip = is_gzip(&headers); + let git_dir = state.git_dir.clone(); + let config = state.config.clone(); + let raw = body.to_vec(); + let produced = run_blocking(move || { + let body = maybe_gunzip(raw, gzip)?; + receive_pack_rpc(&Repository::open_git_dir(&*git_dir)?, &body, &config) + }) + .await; + into_response(produced) +} + +/// Run a blocking, `Repository`-touching closure on the blocking pool. +async fn run_blocking(f: F) -> Result +where + F: FnOnce() -> Result + Send + 'static, +{ + match tokio::task::spawn_blocking(f).await { + Ok(result) => result, + Err(join) => Err(ForgeError::ResourceLimit(format!( + "smart-http worker task failed: {join}" + ))), + } +} + +/// Was the request body gzip-encoded? +fn is_gzip(headers: &HeaderMap) -> bool { + headers + .get(header::CONTENT_ENCODING) + .and_then(|value| value.to_str().ok()) + .map(|value| value.split(',').any(|token| token.trim() == "gzip")) + .unwrap_or(false) +} + +/// Map a sync-core result onto the framework response, hiding internal error +/// detail behind a generic `500` (server-side context stays in the error type +/// for the caller to log). +fn into_response(produced: Result) -> Response { + match produced { + Ok(smart) => Response::builder() + .status(smart.status) + .header(header::CONTENT_TYPE, smart.content_type) + // Advertisements and RPC results must never be cached by proxies. + .header( + header::CACHE_CONTROL, + "no-cache, max-age=0, must-revalidate", + ) + .header(header::PRAGMA, "no-cache") + .body(Body::from(smart.body)) + .unwrap_or_else(|_| { + error_response(StatusCode::INTERNAL_SERVER_ERROR, "response build failed") + }), + Err(error) => { + let status = match error { + ForgeError::NotARepository(_) | ForgeError::ObjectNotFound(_) => { + StatusCode::NOT_FOUND + } + ForgeError::ResourceLimit(_) => StatusCode::PAYLOAD_TOO_LARGE, + _ => StatusCode::INTERNAL_SERVER_ERROR, + }; + error_response(status, "smart-http request failed") + } + } +} + +/// A plain-text error response with the given status. +fn error_response(status: StatusCode, message: &str) -> Response { + Response::builder() + .status(status) + .header(header::CONTENT_TYPE, "text/plain; charset=utf-8") + .body(Body::from(format!("{message}\n"))) + .expect("static error response is always valid") +} diff --git a/src/lib.rs b/src/lib.rs index e1665f1..c209346 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -65,8 +65,10 @@ pub mod diff_render; pub mod error; pub mod fsck; pub mod headers; +pub mod http; pub mod index; pub mod merge; +pub mod merge_cmd; pub mod object; pub mod odb; pub mod oid; @@ -76,9 +78,11 @@ pub mod receive_pack; pub mod reflog; pub mod refs; pub mod repo; +pub mod sequencer; pub mod server; pub mod show; pub mod signature; +pub mod stash; pub mod tag; pub mod tag_ops; pub mod tree; @@ -87,43 +91,63 @@ pub mod wire; pub mod worktree; pub use blob::Blob; +pub use branch::{ + cmd_branch_create, cmd_branch_delete, cmd_branch_list, cmd_branch_rename, dispatch_branch, + BranchOp, +}; +pub use checkout::{cmd_switch, SwitchHead, SwitchResult}; pub use commit::Commit; pub use diff::{diff_trees, ChangeKind, TreeChange}; +pub use diff_render::cmd_diff; pub use error::{ForgeError, Result}; pub use fsck::{ check_connectivity, is_ancestor, ConnectivityLimits, ConnectivityReport, ObjectReader, }; +pub use http::smart_http::{ + info_refs, maybe_gunzip, receive_pack_rpc, router as smart_http_router, + serve as smart_http_serve, serve_blocking as smart_http_serve_blocking, upload_pack_rpc, + Service, SmartHttpConfig, SmartHttpState, SmartResponse, DEFAULT_MAX_BODY_BYTES, +}; pub use index::{Index, IndexEntry}; pub use merge::{merge_base, merge_bases, merge_commits, merge_trees, MergeOutcome}; +pub use merge_cmd::{abort_merge, cmd_merge, continue_merge, MergeKind, MergeResult}; pub use object::{hash_content, parse_loose, Object, ObjectType}; pub use odb::Odb; pub use oid::ObjectId; pub use pack::PackStore; -pub use receive::{ReceiveLimits, ReceiveObject, ReceiveOutcome, ReceiveTransaction, RefUpdate}; +pub use receive::{ + AtomicRefResult, AtomicRefUpdate, ReceiveAtomicOutcome, ReceiveLimits, ReceiveObject, + ReceiveOutcome, ReceiveTransaction, RefUpdate, +}; pub use receive_pack::{ advertise_receive_pack, execute_receive_pack, DeletedRef, ReceivePackExecution, ReceivePackPolicy, RECEIVE_PACK_CAPABILITIES, }; -pub use refs::{validate_refname, RefTarget, Refs}; +pub use reflog::{append_reflog_file, log_path_for_ref, read_reflog, ReflogEntry, NULL_OID_HEX}; +pub use refs::{validate_refname, AtomicRefError, RefChange, RefCommand, RefTarget, Refs}; pub use repo::Repository; +pub use sequencer::{ + cmd_cherry_pick, cmd_rebase, cmd_sequencer_abort, cmd_sequencer_continue, cmd_sequencer_skip, + SequencerStatus, +}; pub use server::{dumb_info_refs, objects_info_packs, update_server_info}; +pub use show::cmd_show; pub use signature::Signature; +pub use stash::{ + cmd_stash_apply, cmd_stash_drop, cmd_stash_pop, cmd_stash_push, stash_list, StashApply, +}; pub use tag::Tag; +pub use tag_ops::{ + cmd_tag_create_annotated, cmd_tag_create_lightweight, cmd_tag_delete, cmd_tag_list, + dispatch_tag, TagOp, +}; pub use tree::{Tree, TreeEntry}; pub use upload_pack::{ - advertise_upload_pack, generate_pack, parse_fetch_request, reachable_objects, upload_pack_v0, - FetchRequest, UPLOAD_PACK_CAPABILITIES, + advertise_upload_pack, generate_pack, generate_pack_with_options, parse_fetch_request, + reachable_objects, upload_pack_v0, FetchRequest, PackOptions, UPLOAD_PACK_CAPABILITIES, }; pub use wire::{ decode_packet_lines, encode_packet_line, encode_receive_status, parse_receive_pack_request, PacketLine, PacketLineLimits, ReceivePackCommand, ReceivePackRequest, ReceiveStatus, }; pub use worktree::{StatusEntry, WorktreeState}; -pub use branch::{BranchOp, dispatch_branch, cmd_branch_list, cmd_branch_create, - cmd_branch_delete, cmd_branch_rename}; -pub use checkout::{cmd_switch, SwitchHead, SwitchResult}; -pub use diff_render::cmd_diff; -pub use show::cmd_show; -pub use tag_ops::{TagOp, dispatch_tag, cmd_tag_list, cmd_tag_create_lightweight, - cmd_tag_create_annotated, cmd_tag_delete}; -pub use reflog::{ReflogEntry, read_reflog, append_reflog_file, log_path_for_ref, NULL_OID_HEX}; diff --git a/src/main.rs b/src/main.rs index cb92637..2e197dd 100644 --- a/src/main.rs +++ b/src/main.rs @@ -10,10 +10,13 @@ use anyhow::{bail, Context, Result}; use clap::{Args, Parser, Subcommand}; use rit::object::Object; use rit::{ - advertise_receive_pack, cmd_diff, cmd_show, cmd_switch, dispatch_branch, dispatch_tag, - execute_receive_pack, parse_receive_pack_request, BranchOp, ObjectType, PacketLineLimits, - ReceiveLimits, ReceivePackCommand, ReceivePackPolicy, Repository, Signature, SwitchHead, TagOp, - WorktreeState, RECEIVE_PACK_CAPABILITIES, + abort_merge, advertise_receive_pack, cmd_cherry_pick, cmd_diff, cmd_merge, cmd_rebase, + cmd_sequencer_abort, cmd_sequencer_continue, cmd_sequencer_skip, cmd_show, cmd_stash_apply, + cmd_stash_drop, cmd_stash_pop, cmd_stash_push, cmd_switch, continue_merge, dispatch_branch, + dispatch_tag, execute_receive_pack, parse_receive_pack_request, smart_http_serve_blocking, + stash_list, BranchOp, MergeKind, ObjectType, PacketLineLimits, ReceiveLimits, + ReceivePackCommand, ReceivePackPolicy, Repository, SequencerStatus, Signature, SmartHttpConfig, + SmartHttpState, StashApply, SwitchHead, TagOp, WorktreeState, RECEIVE_PACK_CAPABILITIES, }; #[derive(Parser)] @@ -73,6 +76,16 @@ enum Command { ReceivePack(ReceivePackArgs), /// Serve Git upload-pack through the installed open-source Git backend. UploadPack(UploadPackArgs), + /// Join another branch's history into the current one. Like `git merge`. + Merge(MergeArgs), + /// Reapply commits on top of another base tip. Like `git rebase`. + Rebase(RebaseArgs), + /// Apply the changes of existing commits. Like `git cherry-pick`. + CherryPick(CherryPickArgs), + /// Stash the dirty worktree/index away and restore it later. Like `git stash`. + Stash(StashArgs), + /// Serve one repository over the Git smart-HTTP protocol. + ServeHttp(ServeHttpArgs), } #[derive(Args)] @@ -254,6 +267,108 @@ struct UploadPackArgs { git_dir: PathBuf, } +#[derive(Args)] +struct MergeArgs { + /// Create a merge commit even when a fast-forward is possible. Like `git merge --no-ff`. + #[arg(long = "no-ff")] + no_ff: bool, + /// Conclude a conflicted merge after resolving the worktree. Like `git merge --continue`. + #[arg(long = "continue", conflicts_with_all = ["abort", "target"])] + cont: bool, + /// Abort an in-progress merge and restore the pre-merge state. Like `git merge --abort`. + #[arg(long = "abort", conflicts_with_all = ["cont", "target"])] + abort: bool, + /// Merge commit message (defaults to a generated `Merge ...` line). + #[arg(short = 'm', long = "message")] + message: Option, + /// Branch, tag, or commit to merge into the current branch. + target: Option, +} + +#[derive(Args)] +struct RebaseArgs { + /// Reset onto this base instead of ``. Like `git rebase --onto`. + #[arg(long = "onto")] + onto: Option, + /// Resume after resolving a conflict. Like `git rebase --continue`. + #[arg(long = "continue", conflicts_with_all = ["abort", "skip", "upstream"])] + cont: bool, + /// Abort and return to the pre-rebase branch tip. Like `git rebase --abort`. + #[arg(long = "abort", conflicts_with_all = ["cont", "skip", "upstream"])] + abort: bool, + /// Drop the current commit and continue. Like `git rebase --skip`. + #[arg(long = "skip", conflicts_with_all = ["cont", "abort", "upstream"])] + skip: bool, + /// Upstream branch/commit whose `..HEAD` commits are replayed. + upstream: Option, +} + +#[derive(Args)] +struct CherryPickArgs { + /// Resume after resolving a conflict. Like `git cherry-pick --continue`. + #[arg(long = "continue", conflicts_with_all = ["abort", "skip", "revs"])] + cont: bool, + /// Abort the in-progress cherry-pick sequence. Like `git cherry-pick --abort`. + #[arg(long = "abort", conflicts_with_all = ["cont", "skip", "revs"])] + abort: bool, + /// Drop the current commit and continue. Like `git cherry-pick --skip`. + #[arg(long = "skip", conflicts_with_all = ["cont", "abort", "revs"])] + skip: bool, + /// One or more commits to replay onto the current branch. + revs: Vec, +} + +#[derive(Args)] +struct StashArgs { + #[command(subcommand)] + action: Option, +} + +#[derive(Subcommand)] +enum StashAction { + /// Record the dirty worktree/index and reset back to HEAD (default action). + Push { + /// Optional description for the stash entry. + #[arg(short = 'm', long = "message")] + message: Option, + }, + /// List the stash entries, newest first. + List, + /// Apply a stash entry without removing it from the stack. + Apply { + /// Stash index (0 = most recent). + #[arg(default_value_t = 0)] + index: usize, + }, + /// Apply a stash entry and drop it on a clean apply. + Pop { + /// Stash index (0 = most recent). + #[arg(default_value_t = 0)] + index: usize, + }, + /// Delete a stash entry from the stack. + Drop { + /// Stash index (0 = most recent). + #[arg(default_value_t = 0)] + index: usize, + }, +} + +#[derive(Args)] +struct ServeHttpArgs { + /// Exact bare repository/git directory to serve at the URL root. + git_dir: PathBuf, + /// Address to bind, e.g. `127.0.0.1:8080`. + #[arg(long = "addr", default_value = "127.0.0.1:8080")] + addr: String, + /// Branch (short name) whose direct push is blocked. Repeatable. + #[arg(long = "block-branch")] + block_branch: Vec, + /// Allow non-fast-forward branch updates (a repository-owner decision). + #[arg(long = "allow-non-ff")] + allow_non_ff: bool, +} + fn main() { if let Err(err) = run() { eprintln!("rit: {err:#}"); @@ -284,9 +399,187 @@ fn run() -> Result<()> { Command::Restore(args) => cmd_restore(&cli, args), Command::ReceivePack(args) => cmd_receive_pack(args), Command::UploadPack(args) => cmd_upload_pack(args), + Command::Merge(args) => cmd_merge_cli(&cli, args), + Command::Rebase(args) => cmd_rebase_cli(&cli, args), + Command::CherryPick(args) => cmd_cherry_pick_cli(&cli, args), + Command::Stash(args) => cmd_stash_cli(&cli, args), + Command::ServeHttp(args) => cmd_serve_http(args), } } +fn cmd_merge_cli(cli: &Cli, args: &MergeArgs) -> Result<()> { + let repo = Repository::discover(&cli.repo) + .with_context(|| format!("opening repo at {}", cli.repo.display()))?; + + if args.abort { + abort_merge(&repo)?; + println!("merge aborted"); + return Ok(()); + } + + let sig = current_signature(repo.git_dir())?; + + if args.cont { + let oid = continue_merge(&repo, &sig, args.message.as_deref())?; + println!("{oid}"); + return Ok(()); + } + + let target = args + .target + .as_deref() + .context("merge requires a target (or --continue/--abort)")?; + let result = cmd_merge(&repo, target, &sig, args.message.as_deref(), args.no_ff)?; + match result.kind { + MergeKind::AlreadyUpToDate => println!("Already up to date."), + MergeKind::FastForward(oid) => println!("Fast-forward to {oid}"), + MergeKind::Merged(oid) => println!("Merge made by the three-way strategy: {oid}"), + MergeKind::Conflicts(paths) => { + report_conflicts("merge", &paths); + std::process::exit(1); + } + } + Ok(()) +} + +fn cmd_rebase_cli(cli: &Cli, args: &RebaseArgs) -> Result<()> { + let repo = Repository::discover(&cli.repo) + .with_context(|| format!("opening repo at {}", cli.repo.display()))?; + + if args.abort { + cmd_sequencer_abort(&repo)?; + println!("rebase aborted"); + return Ok(()); + } + + let sig = current_signature(repo.git_dir())?; + let status = if args.cont { + cmd_sequencer_continue(&repo, &sig)? + } else if args.skip { + cmd_sequencer_skip(&repo, &sig)? + } else { + let upstream = args + .upstream + .as_deref() + .context("rebase requires an upstream (or --continue/--abort/--skip)")?; + cmd_rebase(&repo, upstream, args.onto.as_deref(), &sig)? + }; + report_sequencer("rebase", &status) +} + +fn cmd_cherry_pick_cli(cli: &Cli, args: &CherryPickArgs) -> Result<()> { + let repo = Repository::discover(&cli.repo) + .with_context(|| format!("opening repo at {}", cli.repo.display()))?; + + if args.abort { + cmd_sequencer_abort(&repo)?; + println!("cherry-pick aborted"); + return Ok(()); + } + + let sig = current_signature(repo.git_dir())?; + let status = if args.cont { + cmd_sequencer_continue(&repo, &sig)? + } else if args.skip { + cmd_sequencer_skip(&repo, &sig)? + } else { + if args.revs.is_empty() { + bail!("cherry-pick requires at least one commit (or --continue/--abort/--skip)"); + } + let revs: Vec<&str> = args.revs.iter().map(String::as_str).collect(); + cmd_cherry_pick(&repo, &revs, &sig)? + }; + report_sequencer("cherry-pick", &status) +} + +/// Print a sequencer outcome, exiting non-zero when it stopped on a conflict. +fn report_sequencer(op: &str, status: &SequencerStatus) -> Result<()> { + match status { + SequencerStatus::Completed => { + println!("{op} completed"); + Ok(()) + } + SequencerStatus::Stopped { conflicts } => { + report_conflicts(op, conflicts); + std::process::exit(1); + } + } +} + +fn report_conflicts(op: &str, paths: &[String]) { + eprintln!("{op} stopped due to conflicts in:"); + for path in paths { + eprintln!("\t{path}"); + } + eprintln!("resolve them, then run `rit {op} --continue` (or `--abort`)"); +} + +fn cmd_stash_cli(cli: &Cli, args: &StashArgs) -> Result<()> { + let repo = Repository::discover(&cli.repo) + .with_context(|| format!("opening repo at {}", cli.repo.display()))?; + + match args.action.as_ref() { + Some(StashAction::List) => { + for (index, message) in stash_list(&repo)? { + println!("stash@{{{index}}}: {message}"); + } + Ok(()) + } + Some(StashAction::Apply { index }) => report_stash_apply(cmd_stash_apply(&repo, *index)?), + Some(StashAction::Pop { index }) => report_stash_apply(cmd_stash_pop(&repo, *index)?), + Some(StashAction::Drop { index }) => { + cmd_stash_drop(&repo, *index)?; + println!("dropped stash@{{{index}}}"); + Ok(()) + } + // `rit stash` with no subcommand defaults to push, like `git stash`. + Some(StashAction::Push { .. }) | None => { + let message = match args.action.as_ref() { + Some(StashAction::Push { message }) => message.as_deref(), + _ => None, + }; + let sig = current_signature(repo.git_dir())?; + match cmd_stash_push(&repo, &sig, message)? { + Some(oid) => println!("Saved working directory and index state: {oid}"), + None => println!("No local changes to save"), + } + Ok(()) + } + } +} + +fn report_stash_apply(result: StashApply) -> Result<()> { + match result { + StashApply::Clean => Ok(()), + StashApply::Conflicts(paths) => { + report_conflicts("stash apply", &paths); + std::process::exit(1); + } + } +} + +/// Serve one repository over Git smart-HTTP until the process is stopped. +fn cmd_serve_http(args: &ServeHttpArgs) -> Result<()> { + let addr: std::net::SocketAddr = args + .addr + .parse() + .with_context(|| format!("invalid --addr {:?} (expected ip:port)", args.addr))?; + + // Validate the repository up front so a bad path fails before we bind. + Repository::open_git_dir(&args.git_dir) + .with_context(|| format!("opening bare repo at {}", args.git_dir.display()))?; + + let config = SmartHttpConfig { + blocked_branches: args.block_branch.clone(), + allow_non_fast_forward: args.allow_non_ff, + ..SmartHttpConfig::new() + }; + let state = SmartHttpState::new(args.git_dir.clone(), config); + eprintln!("rit: serving {} on http://{addr}/", args.git_dir.display()); + smart_http_serve_blocking(addr, state)?; + Ok(()) +} + /// Serve a **native** stateful (SSH/process) upload-pack session over /// stdin/stdout — no `git upload-pack` backend. Writes the v0 ref advertisement, /// reads the client's `want`/`have`/`done` negotiation (answering `NAK` after @@ -410,7 +703,9 @@ fn read_pkt_line(input: &mut impl Read) -> Result { 4 => Ok(PktLine::Other), // empty payload _ => { let mut payload = vec![0u8; length - 4]; - input.read_exact(&mut payload).context("reading pkt-line payload")?; + input + .read_exact(&mut payload) + .context("reading pkt-line payload")?; let line = String::from_utf8_lossy(&payload); let line = line.trim_end(); if let Some(rest) = line.strip_prefix("want ") { @@ -449,7 +744,8 @@ fn cmd_receive_pack(args: &ReceivePackArgs) -> Result<()> { // targets a blocked branch, reject the whole push with a per-ref `ng` status // and never touch objects or refs. if !args.block_branch.is_empty() { - let parsed = parse_receive_pack_request(&request, RECEIVE_PACK_CAPABILITIES, packet_limits)?; + let parsed = + parse_receive_pack_request(&request, RECEIVE_PACK_CAPABILITIES, packet_limits)?; let blocked = parsed.commands.iter().any(|cmd| { cmd.name() .strip_prefix("refs/heads/") @@ -559,8 +855,14 @@ fn read_receive_pack_request( } let parsed = parse_receive_pack_request(&request, RECEIVE_PACK_CAPABILITIES, packet_limits)?; - let needs_pack = parsed.commands.len() == 1 - && !matches!(parsed.commands[0], ReceivePackCommand::Delete { .. }); + // A pack follows whenever any command creates or updates a ref (including a + // multi-ref push). A push made up solely of deletions carries no pack, and + // Git keeps its write side open awaiting status, so reading for EOF there + // would deadlock. + let needs_pack = parsed + .commands + .iter() + .any(|command| !matches!(command, ReceivePackCommand::Delete { .. })); if needs_pack { let max_pack = usize::try_from(receive_limits.max_pack_bytes) .context("receive pack limit does not fit this platform")?; @@ -844,10 +1146,7 @@ fn cmd_init(args: &InitArgs) -> Result<()> { }; let kind = if args.bare { "bare " } else { "" }; let git_dir = std::fs::canonicalize(repo.git_dir()).unwrap_or_else(|_| repo.git_dir().into()); - println!( - "{action} {kind}Git repository in {}/", - git_dir.display() - ); + println!("{action} {kind}Git repository in {}/", git_dir.display()); Ok(()) } diff --git a/src/merge.rs b/src/merge.rs index 7770634..3a1584e 100644 --- a/src/merge.rs +++ b/src/merge.rs @@ -241,10 +241,7 @@ fn is_binary(data: &[u8]) -> bool { } /// Flatten an optional tree; `None` → empty map. -fn flatten_opt( - repo: &Repository, - tree: Option, -) -> Result, Entry>> { +fn flatten_opt(repo: &Repository, tree: Option) -> Result, Entry>> { match tree { Some(oid) => flatten(repo, oid), None => Ok(BTreeMap::new()), @@ -405,7 +402,8 @@ mod tests { .collect(), }; t.canonicalize(); - repo.hash_object(ObjectType::Tree, &t.serialize(), true).unwrap() + repo.hash_object(ObjectType::Tree, &t.serialize(), true) + .unwrap() } fn tree_modes(repo: &Repository, entries: Vec<(&str, &str, ObjectId)>) -> ObjectId { @@ -420,11 +418,13 @@ mod tests { .collect(), }; t.canonicalize(); - repo.hash_object(ObjectType::Tree, &t.serialize(), true).unwrap() + repo.hash_object(ObjectType::Tree, &t.serialize(), true) + .unwrap() } fn commit(repo: &Repository, tree: ObjectId, parents: Vec) -> ObjectId { - repo.commit_tree(tree, parents, sig(), sig(), b"c\n", None).unwrap() + repo.commit_tree(tree, parents, sig(), sig(), b"c\n", None) + .unwrap() } #[test] @@ -441,7 +441,11 @@ mod tests { let ours_only = blob(&repo, b"ours\n"); let ours_tree = tree( &repo, - vec![("a.txt", a_ours), ("shared.txt", shared), ("ours.txt", ours_only)], + vec![ + ("a.txt", a_ours), + ("shared.txt", shared), + ("ours.txt", ours_only), + ], ); let ours = commit(&repo, ours_tree, vec![base]); // theirs: change line 3 + add theirs.txt @@ -449,7 +453,11 @@ mod tests { let theirs_only = blob(&repo, b"theirs\n"); let theirs_tree = tree( &repo, - vec![("a.txt", a_theirs), ("shared.txt", shared), ("theirs.txt", theirs_only)], + vec![ + ("a.txt", a_theirs), + ("shared.txt", shared), + ("theirs.txt", theirs_only), + ], ); let theirs = commit(&repo, theirs_tree, vec![base]); @@ -497,9 +505,16 @@ mod tests { let g1 = commit(&repo, tree(&repo, vec![("a.txt", blob0)]), vec![root]); let g2 = commit(&repo, tree(&repo, vec![("a.txt", blob0)]), vec![g1]); // Distinct trees so the two tips are distinct commits (not the same oid). - let ours = commit(&repo, tree(&repo, vec![("a.txt", blob(&repo, b"ours\n"))]), vec![g2]); - let theirs = - commit(&repo, tree(&repo, vec![("a.txt", blob(&repo, b"theirs\n"))]), vec![g2]); + let ours = commit( + &repo, + tree(&repo, vec![("a.txt", blob(&repo, b"ours\n"))]), + vec![g2], + ); + let theirs = commit( + &repo, + tree(&repo, vec![("a.txt", blob(&repo, b"theirs\n"))]), + vec![g2], + ); assert_eq!(merge_bases(&repo, ours, theirs).unwrap(), vec![g2]); assert_eq!(merge_base(&repo, ours, theirs).unwrap(), Some(g2)); @@ -518,11 +533,27 @@ mod tests { let repo = Repository::init(dir.path(), true, Some("main")).unwrap(); let blob0 = blob(&repo, b"0\n"); let root = commit(&repo, tree(&repo, vec![("a.txt", blob0)]), vec![]); - let a = commit(&repo, tree(&repo, vec![("a.txt", blob(&repo, b"a\n"))]), vec![root]); - let b = commit(&repo, tree(&repo, vec![("a.txt", blob(&repo, b"b\n"))]), vec![root]); + let a = commit( + &repo, + tree(&repo, vec![("a.txt", blob(&repo, b"a\n"))]), + vec![root], + ); + let b = commit( + &repo, + tree(&repo, vec![("a.txt", blob(&repo, b"b\n"))]), + vec![root], + ); // Two independent merges of the same pair of branches => criss-cross. - let m1 = commit(&repo, tree(&repo, vec![("a.txt", blob(&repo, b"m1\n"))]), vec![a, b]); - let m2 = commit(&repo, tree(&repo, vec![("a.txt", blob(&repo, b"m2\n"))]), vec![a, b]); + let m1 = commit( + &repo, + tree(&repo, vec![("a.txt", blob(&repo, b"m1\n"))]), + vec![a, b], + ); + let m2 = commit( + &repo, + tree(&repo, vec![("a.txt", blob(&repo, b"m2\n"))]), + vec![a, b], + ); let mut bases = merge_bases(&repo, m1, m2).unwrap(); bases.sort(); @@ -543,10 +574,18 @@ mod tests { let repo = Repository::init(dir.path(), true, Some("main")).unwrap(); let a0 = blob(&repo, b"base\n"); let keep = blob(&repo, b"keep\n"); - let base = commit(&repo, tree(&repo, vec![("a.txt", a0), ("k.txt", keep)]), vec![]); + let base = commit( + &repo, + tree(&repo, vec![("a.txt", a0), ("k.txt", keep)]), + vec![], + ); // ours modifies a.txt; theirs deletes a.txt (tree omits it). let a_mod = blob(&repo, b"changed\n"); - let ours = commit(&repo, tree(&repo, vec![("a.txt", a_mod), ("k.txt", keep)]), vec![base]); + let ours = commit( + &repo, + tree(&repo, vec![("a.txt", a_mod), ("k.txt", keep)]), + vec![base], + ); let theirs = commit(&repo, tree(&repo, vec![("k.txt", keep)]), vec![base]); match merge_commits(&repo, ours, theirs).unwrap() { @@ -562,12 +601,23 @@ mod tests { let dir = tempfile::tempdir().unwrap(); let repo = Repository::init(dir.path(), true, Some("main")).unwrap(); let content = blob(&repo, b"x\n"); - let base = commit(&repo, tree_modes(&repo, vec![("s.sh", "100644", content)]), vec![]); + let base = commit( + &repo, + tree_modes(&repo, vec![("s.sh", "100644", content)]), + vec![], + ); // ours: chmod +x, same content. theirs: same mode, new content. - let ours = commit(&repo, tree_modes(&repo, vec![("s.sh", "100755", content)]), vec![base]); + let ours = commit( + &repo, + tree_modes(&repo, vec![("s.sh", "100755", content)]), + vec![base], + ); let new_content = blob(&repo, b"y\n"); - let theirs = - commit(&repo, tree_modes(&repo, vec![("s.sh", "100644", new_content)]), vec![base]); + let theirs = commit( + &repo, + tree_modes(&repo, vec![("s.sh", "100644", new_content)]), + vec![base], + ); match merge_commits(&repo, ours, theirs).unwrap() { MergeOutcome::Conflict(paths) => assert_eq!(paths, vec!["s.sh".to_string()]), @@ -586,9 +636,16 @@ mod tests { // new.txt is the add/add-identical path under test. let ours_only = blob(&repo, b"o\n"); let theirs_only = blob(&repo, b"t\n"); - let ours = commit(&repo, tree(&repo, vec![("new.txt", same), ("o.txt", ours_only)]), vec![base]); - let theirs = - commit(&repo, tree(&repo, vec![("new.txt", same), ("t.txt", theirs_only)]), vec![base]); + let ours = commit( + &repo, + tree(&repo, vec![("new.txt", same), ("o.txt", ours_only)]), + vec![base], + ); + let theirs = commit( + &repo, + tree(&repo, vec![("new.txt", same), ("t.txt", theirs_only)]), + vec![base], + ); match merge_commits(&repo, ours, theirs).unwrap() { MergeOutcome::Clean(t) => { @@ -609,9 +666,16 @@ mod tests { let repo = Repository::init(dir.path(), true, Some("main")).unwrap(); let base_bin = blob(&repo, b"\x00base"); let base = commit(&repo, tree(&repo, vec![("a.bin", base_bin)]), vec![]); - let ours = commit(&repo, tree(&repo, vec![("a.bin", blob(&repo, b"\x00ours"))]), vec![base]); - let theirs = - commit(&repo, tree(&repo, vec![("a.bin", blob(&repo, b"\x00theirs"))]), vec![base]); + let ours = commit( + &repo, + tree(&repo, vec![("a.bin", blob(&repo, b"\x00ours"))]), + vec![base], + ); + let theirs = commit( + &repo, + tree(&repo, vec![("a.bin", blob(&repo, b"\x00theirs"))]), + vec![base], + ); match merge_commits(&repo, ours, theirs).unwrap() { MergeOutcome::Conflict(paths) => assert_eq!(paths, vec!["a.bin".to_string()]), diff --git a/src/merge_cmd.rs b/src/merge_cmd.rs new file mode 100644 index 0000000..1fb19bb --- /dev/null +++ b/src/merge_cmd.rs @@ -0,0 +1,619 @@ +//! `git merge` porcelain — wire the from-scratch three-way [`crate::merge`] +//! engine into a real command that produces a two-parent commit or surfaces +//! conflicts (conflict-marker worktree + unmerged index + `MERGE_HEAD`). +//! +//! This module also owns the **shared history-editing primitives** that the +//! [`crate::sequencer`] (rebase / cherry-pick) and [`crate::stash`] modules +//! build on: +//! +//! - [`build_worktree_merge`] — a three-way tree merge that, unlike +//! [`crate::merge::merge_trees`], also returns the conflict-marker content and +//! the stage 1/2/3 index entries needed to *represent* a conflict on disk; +//! - [`install_unmerged`] — install those unmerged stages into `.git/index`; +//! - [`force_reset`] — discard worktree/index state back to a target tree +//! (used by `--abort` / `--skip` where the safe [`Repository::checkout_tree`] +//! would refuse because of conflict-marker "local changes"); +//! - small `.git`-directory state-file helpers (`MERGE_HEAD`, `ORIG_HEAD`, …). +//! +//! The CLI dispatch (clap wiring) is intentionally **not** here — the integrator +//! calls [`cmd_merge`], [`continue_merge`], and [`abort_merge`] from `main.rs`. + +use std::collections::{BTreeMap, BTreeSet}; +use std::io::Write; +use std::path::{Path, PathBuf}; + +use crate::error::{ForgeError, Result}; +use crate::fsck::{is_ancestor as fsck_is_ancestor, ConnectivityLimits}; +use crate::index::{Index, IndexEntry}; +use crate::object::ObjectType; +use crate::oid::ObjectId; +use crate::refs::RefTarget; +use crate::repo::Repository; +use crate::signature::Signature; +use crate::tree::{Tree, TreeEntry}; + +/// Bound on tree recursion while flattening for a merge. +const MAX_MERGE_DEPTH: usize = 256; + +// ── public command surface ────────────────────────────────────────────────── + +/// How a completed [`cmd_merge`] resolved. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum MergeKind { + /// `theirs` was already reachable from `HEAD`; nothing to do. + AlreadyUpToDate, + /// `HEAD` was an ancestor of `theirs`; the branch was fast-forwarded. + FastForward(ObjectId), + /// A real three-way merge produced this two-parent commit. + Merged(ObjectId), + /// The merge conflicted on these paths; `MERGE_HEAD` was recorded and the + /// worktree now contains conflict markers. + Conflicts(Vec), +} + +/// Outcome of a [`cmd_merge`] invocation. +#[derive(Clone, Debug)] +pub struct MergeResult { + /// The resolution. + pub kind: MergeKind, + /// The other side's commit that was merged (the `theirs` tip). + pub theirs: ObjectId, +} + +/// `git merge ` into the current branch. +/// +/// Resolves the merge base, then: +/// - returns [`MergeKind::AlreadyUpToDate`] when `target` is reachable from HEAD; +/// - fast-forwards (unless `no_ff`) when HEAD is an ancestor of `target`; +/// - otherwise performs a three-way merge, writing a two-parent commit on a +/// clean merge or recording `MERGE_HEAD` + conflict markers on a conflict. +/// +/// Fails closed with [`ForgeError::MergeMultipleBases`] on a criss-cross +/// history, matching the single-base scope of [`crate::merge`]. +pub fn cmd_merge( + repo: &Repository, + target: &str, + sig: &Signature, + message: Option<&str>, + no_ff: bool, +) -> Result { + let git_dir = repo.git_dir(); + let head_ref = head_branch(repo)?; + let ours = repo.head().map_err(|_| { + ForgeError::InvalidRef("cannot merge into an empty repository (no HEAD commit)".into()) + })?; + let theirs = repo.resolve(target)?; + // Peel a tag/target to its commit so a two-parent merge always links commits. + let theirs = peel_commit_oid(repo, theirs)?; + + // ORIG_HEAD is Git's "where I was before this operation" anchor. + write_gitdir_file(git_dir, "ORIG_HEAD", format!("{ours}\n").as_bytes())?; + + if ours == theirs || is_ancestor(repo, theirs, ours)? { + return Ok(MergeResult { + kind: MergeKind::AlreadyUpToDate, + theirs, + }); + } + + if !no_ff && is_ancestor(repo, ours, theirs)? { + let tree = repo.peel_to_commit(theirs)?.tree; + repo.checkout_tree(tree)?; + repo.refs() + .compare_and_swap(&head_ref, Some(ours), theirs)?; + let msg = format!("merge {target}: Fast-forward"); + let _ = repo.refs().append_reflog( + &head_ref, + Some(ours), + theirs, + &sig.name, + &sig.email, + sig.time, + &sig.tz, + &msg, + ); + return Ok(MergeResult { + kind: MergeKind::FastForward(theirs), + theirs, + }); + } + + // True three-way merge. + let bases = crate::merge::merge_bases(repo, ours, theirs)?; + if bases.len() > 1 { + return Err(ForgeError::MergeMultipleBases(bases.len())); + } + let base_tree = match bases.first() { + Some(oid) => Some(repo.peel_to_commit(*oid)?.tree), + None => None, + }; + let ours_tree = repo.peel_to_commit(ours)?.tree; + let theirs_tree = repo.peel_to_commit(theirs)?.tree; + + let message = normalize_message(message, || default_merge_msg(repo, target)); + + match build_worktree_merge(repo, base_tree, ours_tree, theirs_tree)? { + WorktreeMerge::Clean(tree) => { + repo.checkout_tree(tree)?; + let new = repo.commit_tree( + tree, + vec![ours, theirs], + sig.clone(), + sig.clone(), + message.as_bytes(), + Some(&head_ref), + )?; + Ok(MergeResult { + kind: MergeKind::Merged(new), + theirs, + }) + } + WorktreeMerge::Conflict { + tree, + conflicts, + stages, + } => { + repo.checkout_tree(tree)?; + install_unmerged(git_dir, &stages)?; + write_gitdir_file(git_dir, "MERGE_HEAD", format!("{theirs}\n").as_bytes())?; + write_gitdir_file(git_dir, "MERGE_MSG", message.as_bytes())?; + Ok(MergeResult { + kind: MergeKind::Conflicts(conflicts), + theirs, + }) + } + } +} + +/// `git merge --continue` / `git commit` after resolving a conflicted merge. +/// +/// Requires a resolved (stage-0) index and a recorded `MERGE_HEAD`. Creates the +/// two-parent merge commit from `ORIG_HEAD` (ours) and `MERGE_HEAD` (theirs), +/// advances the branch, and clears the merge state files. +pub fn continue_merge( + repo: &Repository, + sig: &Signature, + message: Option<&str>, +) -> Result { + let git_dir = repo.git_dir(); + let theirs = read_gitdir_oid(git_dir, "MERGE_HEAD") + .ok_or_else(|| ForgeError::InvalidRef("no MERGE_HEAD: not in a conflicted merge".into()))?; + let ours = repo.head()?; + let head_ref = head_branch(repo)?; + // write_tree fails closed if any path is still at an unmerged stage. + let tree = repo.write_tree()?; + let stored = read_gitdir_string(git_dir, "MERGE_MSG"); + let message = normalize_message(message.or(stored.as_deref()), || { + format!("Merge commit '{theirs}'\n") + }); + let new = repo.commit_tree( + tree, + vec![ours, theirs], + sig.clone(), + sig.clone(), + message.as_bytes(), + Some(&head_ref), + )?; + remove_gitdir_file(git_dir, "MERGE_HEAD"); + remove_gitdir_file(git_dir, "MERGE_MSG"); + Ok(new) +} + +/// `git merge --abort`: discard a conflicted merge, restoring `ORIG_HEAD`. +pub fn abort_merge(repo: &Repository) -> Result<()> { + let git_dir = repo.git_dir(); + let orig = read_gitdir_oid(git_dir, "ORIG_HEAD") + .ok_or_else(|| ForgeError::InvalidRef("no ORIG_HEAD to abort to".into()))?; + let head_ref = head_branch(repo)?; + let current = repo.head()?; + repo.refs() + .compare_and_swap(&head_ref, Some(current), orig)?; + force_reset(repo, repo.peel_to_commit(orig)?.tree)?; + remove_gitdir_file(git_dir, "MERGE_HEAD"); + remove_gitdir_file(git_dir, "MERGE_MSG"); + Ok(()) +} + +// ── shared three-way merge (content + stages) ─────────────────────────────── + +/// One unmerged index entry (a stage-1/2/3 slot for a conflicted path). +#[derive(Clone, Debug)] +pub(crate) struct StageEntry { + pub path: Vec, + pub stage: u8, + pub mode: String, + pub oid: ObjectId, +} + +/// The result of a three-way tree merge that carries enough detail to +/// materialize a conflict on disk. +pub(crate) enum WorktreeMerge { + /// A clean merge producing this tree (all entries stage 0). + Clean(ObjectId), + /// A conflicting merge. `tree` is materializable into the worktree (clean + /// paths + conflict-marker/ours blobs for conflicted paths); `stages` are + /// the unmerged index entries to install after checkout. + Conflict { + tree: ObjectId, + conflicts: Vec, + stages: Vec, + }, +} + +/// Three-way merge three trees, producing merged content **and** conflict +/// representation. `base` is `None` for an empty/unrelated common ancestor. +pub(crate) fn build_worktree_merge( + repo: &Repository, + base: Option, + ours: ObjectId, + theirs: ObjectId, +) -> Result { + let base_map = match base { + Some(oid) => flatten_tree(repo, oid)?, + None => BTreeMap::new(), + }; + let ours_map = flatten_tree(repo, ours)?; + let theirs_map = flatten_tree(repo, theirs)?; + + let mut paths: Vec> = base_map + .keys() + .chain(ours_map.keys()) + .chain(theirs_map.keys()) + .cloned() + .collect(); + paths.sort(); + paths.dedup(); + + let mut result: BTreeMap, Entry> = BTreeMap::new(); + let mut conflicts: Vec = Vec::new(); + let mut stages: Vec = Vec::new(); + + for path in paths { + let b = base_map.get(&path); + let o = ours_map.get(&path); + let t = theirs_map.get(&path); + + // Both sides identical (including both absent) → take either. + if o == t { + if let Some(entry) = o { + result.insert(path, entry.clone()); + } + continue; + } + // Ours unchanged vs base → take theirs' change (possibly a deletion). + if o == b { + if let Some(entry) = t { + result.insert(path, entry.clone()); + } + continue; + } + // Theirs unchanged vs base → take ours' change. + if t == b { + if let Some(entry) = o { + result.insert(path, entry.clone()); + } + continue; + } + + // Genuine divergence: resolve or record a conflict. + match (o, t) { + (Some((omode, ooid)), Some((tmode, toid))) => { + let base_bytes = match b { + Some((_, boid)) => repo.blob(boid)?.data, + None => Vec::new(), + }; + let ours_bytes = repo.blob(ooid)?.data; + let theirs_bytes = repo.blob(toid)?.data; + + let text_mergeable = omode == tmode + && !is_binary(&base_bytes) + && !is_binary(&ours_bytes) + && !is_binary(&theirs_bytes); + let worktree = if text_mergeable { + match diffy::merge_bytes(&base_bytes, &ours_bytes, &theirs_bytes) { + Ok(bytes) => { + let oid = repo.hash_object(ObjectType::Blob, &bytes, true)?; + result.insert(path.clone(), (omode.clone(), oid)); + continue; + } + // Err carries the diff3 output *with* conflict markers. + Err(markers) => { + let oid = repo.hash_object(ObjectType::Blob, &markers, true)?; + (omode.clone(), oid) + } + } + } else { + // Binary or mode conflict: keep ours in the worktree. + (omode.clone(), *ooid) + }; + result.insert(path.clone(), worktree); + if let Some((bmode, boid)) = b { + stages.push(stage_entry(&path, 1, bmode, *boid)); + } + stages.push(stage_entry(&path, 2, omode, *ooid)); + stages.push(stage_entry(&path, 3, tmode, *toid)); + conflicts.push(display(&path)); + } + // Modify/delete: ours changed, theirs removed. + (Some((omode, ooid)), None) => { + result.insert(path.clone(), (omode.clone(), *ooid)); + if let Some((bmode, boid)) = b { + stages.push(stage_entry(&path, 1, bmode, *boid)); + } + stages.push(stage_entry(&path, 2, omode, *ooid)); + conflicts.push(display(&path)); + } + // Delete/modify: ours removed, theirs changed. + (None, Some((tmode, toid))) => { + result.insert(path.clone(), (tmode.clone(), *toid)); + if let Some((bmode, boid)) = b { + stages.push(stage_entry(&path, 1, bmode, *boid)); + } + stages.push(stage_entry(&path, 3, tmode, *toid)); + conflicts.push(display(&path)); + } + // o == t already handled the (None, None) case. + (None, None) => unreachable!("o != t guarantees at least one side present"), + } + } + + let tree = write_tree_from_entries(repo, &result)?; + if conflicts.is_empty() { + Ok(WorktreeMerge::Clean(tree)) + } else { + conflicts.sort(); + conflicts.dedup(); + Ok(WorktreeMerge::Conflict { + tree, + conflicts, + stages, + }) + } +} + +/// Install unmerged (stage 1/2/3) entries for conflicted paths into +/// `.git/index`, replacing whatever stage-0 entry a prior checkout left. +pub(crate) fn install_unmerged(git_dir: &Path, stages: &[StageEntry]) -> Result<()> { + if stages.is_empty() { + return Ok(()); + } + let conflicted: BTreeSet> = stages.iter().map(|s| s.path.clone()).collect(); + Index::mutate(git_dir, |index| { + index + .entries + .retain(|entry| !conflicted.contains(&entry.path)); + for stage in stages { + let mode = u32::from_str_radix(&stage.mode, 8).unwrap_or(0o100644); + let flags = + (((stage.stage & 0x3) as u16) << 12) | (stage.path.len().min(0x0fff) as u16); + index.entries.push(IndexEntry { + mode, + file_size: 0, + oid: stage.oid, + flags, + path: stage.path.clone(), + }); + } + index + .entries + .sort_by(|a, b| a.path.cmp(&b.path).then(a.stage().cmp(&b.stage()))); + Ok(()) + }) +} + +// ── reset / state-file primitives (shared) ────────────────────────────────── + +/// Discard worktree + index state back to `tree`, unconditionally. +/// +/// [`Repository::checkout_tree`] refuses to overwrite "locally modified" paths — +/// but after a conflict the worktree *is* full of intentional local changes +/// (conflict markers). This first restages the worktree so those changes are no +/// longer seen as modifications, then applies `tree`. Used by `--abort` / +/// `--skip` and `stash` reset. +pub(crate) fn force_reset(repo: &Repository, tree: ObjectId) -> Result<()> { + // Restage everything so tracked worktree state == index (no "local changes"). + repo.add(&[PathBuf::from(".")])?; + repo.checkout_tree(tree)?; + Ok(()) +} + +/// The full ref name HEAD symbolically points at, or an error on detached HEAD. +pub(crate) fn head_branch(repo: &Repository) -> Result { + match repo.refs().read_head()? { + RefTarget::Symbolic(name) => Ok(name), + RefTarget::Direct(_) => Err(ForgeError::InvalidRef( + "HEAD is detached; this operation requires being on a branch".into(), + )), + } +} + +/// Write a small `.git/` state file (fsynced), creating parent dirs. +pub(crate) fn write_gitdir_file(git_dir: &Path, rel: &str, content: &[u8]) -> Result<()> { + let path = git_dir.join(rel); + if let Some(parent) = path.parent() { + std::fs::create_dir_all(parent)?; + } + let mut file = std::fs::File::create(&path)?; + file.write_all(content)?; + file.sync_all()?; + Ok(()) +} + +/// Remove a `.git/` state file if present (absence is not an error). +pub(crate) fn remove_gitdir_file(git_dir: &Path, rel: &str) { + let _ = std::fs::remove_file(git_dir.join(rel)); +} + +/// Read a `.git/` file as a single object id, if present and valid. +pub(crate) fn read_gitdir_oid(git_dir: &Path, rel: &str) -> Option { + let raw = std::fs::read_to_string(git_dir.join(rel)).ok()?; + ObjectId::from_hex(raw.trim()).ok() +} + +/// Read a `.git/` file as a UTF-8 string, if present. +pub(crate) fn read_gitdir_string(git_dir: &Path, rel: &str) -> Option { + std::fs::read_to_string(git_dir.join(rel)).ok() +} + +/// Peel a tag/target oid to the underlying commit oid (bounded). +pub(crate) fn peel_commit_oid(repo: &Repository, oid: ObjectId) -> Result { + use crate::object::Object; + let mut current = oid; + for _ in 0..10 { + match repo.read_object(¤t)? { + Object::Commit(_) => return Ok(current), + Object::Tag(tag) => current = tag.object, + other => { + return Err(ForgeError::malformed( + "object", + format!("{current} is a {}, expected a commit", other.object_type()), + )) + } + } + } + Err(ForgeError::InvalidRef(format!( + "{oid} does not peel to a commit" + ))) +} + +// ── internal helpers ──────────────────────────────────────────────────────── + +type Entry = (String, ObjectId); + +fn is_ancestor(repo: &Repository, ancestor: ObjectId, descendant: ObjectId) -> Result { + fsck_is_ancestor( + repo.odb(), + ancestor, + descendant, + ConnectivityLimits::default(), + ) +} + +fn is_binary(data: &[u8]) -> bool { + data.contains(&0) +} + +fn display(path: &[u8]) -> String { + String::from_utf8_lossy(path).into_owned() +} + +fn stage_entry(path: &[u8], stage: u8, mode: &str, oid: ObjectId) -> StageEntry { + StageEntry { + path: path.to_vec(), + stage, + mode: mode.to_string(), + oid, + } +} + +fn normalize_message(message: Option<&str>, default: impl FnOnce() -> String) -> String { + match message { + Some(msg) if msg.ends_with('\n') => msg.to_string(), + Some(msg) => format!("{msg}\n"), + None => default(), + } +} + +fn default_merge_msg(repo: &Repository, target: &str) -> String { + if repo.refs().resolve(&format!("refs/heads/{target}")).is_ok() { + format!("Merge branch '{target}'\n") + } else { + format!("Merge commit '{target}'\n") + } +} + +/// Flatten a tree to path → (mode, oid) leaf entries (bounded recursion). +pub(crate) fn flatten_tree(repo: &Repository, tree: ObjectId) -> Result, Entry>> { + let mut out = BTreeMap::new(); + flatten_into(repo, tree, Vec::new(), 0, &mut out)?; + Ok(out) +} + +fn flatten_into( + repo: &Repository, + tree_oid: ObjectId, + prefix: Vec, + depth: usize, + out: &mut BTreeMap, Entry>, +) -> Result<()> { + if depth > MAX_MERGE_DEPTH { + return Err(ForgeError::ResourceLimit(format!( + "merge tree depth exceeds {MAX_MERGE_DEPTH}" + ))); + } + for entry in repo.tree(&tree_oid)?.entries { + let mut path = prefix.clone(); + if !path.is_empty() { + path.push(b'/'); + } + path.extend_from_slice(&entry.name); + if entry.kind() == "tree" { + flatten_into(repo, entry.oid, path, depth + 1, out)?; + } else { + out.insert(path, (entry.mode.clone(), entry.oid)); + } + } + Ok(()) +} + +/// Reconstruct a canonical Git tree from flattened path → (mode, oid) entries. +pub(crate) fn write_tree_from_entries( + repo: &Repository, + entries: &BTreeMap, Entry>, +) -> Result { + let mut root = MergeTreeNode::default(); + for (path, (mode, oid)) in entries { + root.insert(path, mode.clone(), *oid); + } + root.write(repo) +} + +#[derive(Default)] +struct MergeTreeNode { + files: BTreeMap, Entry>, + dirs: BTreeMap, MergeTreeNode>, +} + +impl MergeTreeNode { + fn insert(&mut self, path: &[u8], mode: String, oid: ObjectId) { + let mut parts = path.split(|b| *b == b'/').peekable(); + let mut node = self; + while let Some(part) = parts.next() { + if parts.peek().is_none() { + // File/dir collision: a directory already claims this name; the + // directory wins (a single tree cannot hold both). Rare edge — + // three-way merge marks such paths as conflicts anyway. + if node.dirs.contains_key(part) { + return; + } + node.files.insert(part.to_vec(), (mode, oid)); + return; + } + // A file previously claimed this name but a deeper path needs a + // directory here; the directory wins. + node.files.remove(part); + node = node.dirs.entry(part.to_vec()).or_default(); + } + } + + fn write(&self, repo: &Repository) -> Result { + let mut entries = Vec::with_capacity(self.files.len() + self.dirs.len()); + for (name, (mode, oid)) in &self.files { + entries.push(TreeEntry { + mode: mode.clone(), + name: name.clone(), + oid: *oid, + }); + } + for (name, child) in &self.dirs { + entries.push(TreeEntry { + mode: "40000".into(), + name: name.clone(), + oid: child.write(repo)?, + }); + } + let mut tree = Tree { entries }; + tree.canonicalize(); + repo.hash_object(ObjectType::Tree, &tree.serialize(), true) + } +} diff --git a/src/receive.rs b/src/receive.rs index 466c192..fe5e2e4 100644 --- a/src/receive.rs +++ b/src/receive.rs @@ -3,8 +3,10 @@ //! Network and pack negotiation are deliberately outside this module. Once an //! open-source pack decoder yields typed payloads, this is the safety boundary: //! isolate them, verify declared identities, fsck the complete overlay graph, -//! enforce fast-forward policy, publish immutable objects, then move one ref by -//! compare-and-swap. A failed transaction never moves the ref. +//! enforce fast-forward policy, publish immutable objects, then move the ref(s). +//! [`ReceiveTransaction::finish`] moves exactly one ref by compare-and-swap; +//! [`ReceiveTransaction::finish_atomic`] applies a whole multi-ref push as one +//! all-or-nothing transaction. A failed transaction never moves any ref. use std::collections::BTreeSet; use std::io::Cursor; @@ -20,7 +22,7 @@ use crate::fsck::{check_connectivity, is_ancestor, ConnectivityLimits, ObjectRea use crate::object::{Object, ObjectType, MAX_OBJECT_SIZE}; use crate::odb::Odb; use crate::oid::ObjectId; -use crate::refs::validate_refname; +use crate::refs::{validate_refname, RefChange, RefCommand}; use crate::Repository; static NEXT_QUARANTINE: AtomicU64 = AtomicU64::new(0); @@ -53,9 +55,9 @@ pub struct ReceiveObject { pub payload: Vec, } -/// One ref update. This first safe receive slice deliberately owns exactly one -/// ref per transaction; multi-ref atomic transactions remain a later wire-layer -/// capability rather than pretending sequential renames are globally atomic. +/// One ref update for the single-ref [`ReceiveTransaction::finish`] path. +/// Multi-ref pushes use [`AtomicRefUpdate`] with +/// [`ReceiveTransaction::finish_atomic`] instead. #[derive(Clone, Debug, PartialEq, Eq)] pub struct RefUpdate { pub name: String, @@ -73,6 +75,58 @@ pub struct ReceiveOutcome { pub published_objects: usize, } +/// One ref command in an atomic multi-ref receive. `new == None` is a deletion +/// (and then `expected_old` must be the required current value); otherwise it is +/// a create (`expected_old == None`) or an update (`expected_old == Some`). +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct AtomicRefUpdate { + pub name: String, + pub expected_old: Option, + pub new: Option, + pub allow_non_fast_forward: bool, +} + +/// Per-ref result of an atomic receive. `error == None` means the ref was (or +/// would have been) accepted; every ref shares the same accept/reject verdict. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct AtomicRefResult { + pub name: String, + pub error: Option, +} + +/// Outcome of [`ReceiveTransaction::finish_atomic`]: the per-ref results plus +/// whether the batch was actually committed. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct ReceiveAtomicOutcome { + pub results: Vec, + pub published_objects: usize, + pub committed: bool, +} + +/// Pair each update name with its per-ref error into ordered results. +fn build_results(updates: &[AtomicRefUpdate], errors: Vec>) -> Vec { + updates + .iter() + .zip(errors) + .map(|(update, error)| AtomicRefResult { + name: update.name.clone(), + error, + }) + .collect() +} + +/// Stable, privacy-safe report-status reason for a rejected ref transaction. +fn atomic_ref_public_reason(error: &ForgeError) -> &'static str { + match error { + ForgeError::NonFastForward { .. } => "non-fast-forward", + ForgeError::RefConflict { .. } => "stale info", + ForgeError::RefLocked(_) => "ref locked", + ForgeError::ReceiveRejected(_) => "receive policy rejected", + ForgeError::ResourceLimit(_) => "resource limit", + _ => "server error", + } +} + /// Isolated decoded-object transaction tied to one target repository. pub struct ReceiveTransaction<'repo> { repository: &'repo Repository, @@ -368,6 +422,155 @@ impl<'repo> ReceiveTransaction<'repo> { }) } + /// Validate and publish the complete staged graph, then apply **every** + /// requested ref change as one atomic transaction (the multi-ref push). + /// + /// The whole batch is accepted or rejected together, matching Git's + /// `--atomic` receive: object publication and connectivity are checked once + /// over the union of all new tips, then [`Refs::atomic_update`] commits or + /// rejects the refs in a single locked transaction. + /// + /// Return semantics separate two failure classes so the transport can build + /// an accurate report-status: + /// - `Err(..)` is a whole-graph problem (bad connectivity, disconnected + /// objects, unreadable object) that the caller maps to the same reason on + /// every ref, exactly as the single-ref [`finish`](Self::finish) does. + /// - `Ok(outcome)` with `committed == false` is a per-ref rejection: the + /// offending ref(s) carry a specific reason and the rest carry a generic + /// "atomic transaction failed", and **no** ref moved. + pub fn finish_atomic(self, updates: Vec) -> Result { + if let Some(reason) = &self.pack_import_failed { + return Err(ForgeError::ReceiveRejected(format!( + "an earlier pack import failed after staging began: {reason}" + ))); + } + if updates.is_empty() { + return Err(ForgeError::ReceiveRejected( + "atomic receive requires at least one ref command".into(), + )); + } + for update in &updates { + validate_refname(&update.name)?; + if update.new.is_none() && update.expected_old.is_none() { + return Err(ForgeError::ReceiveRejected(format!( + "deletion of {} must specify the expected current value", + update.name + ))); + } + } + + let reader = OverlayReader { + quarantine: &self.quarantine_odb, + target: self.repository.odb(), + staged: &self.staged, + }; + + // Connectivity is checked once over the union of every non-delete tip. + // A push that stages objects unreachable from any surviving tip is a + // whole-graph rejection, just like the single-ref path. + let tips: Vec = updates.iter().filter_map(|update| update.new).collect(); + if !tips.is_empty() { + let report = check_connectivity(&reader, &tips, self.limits.connectivity)?; + if !self.staged.iter().all(|oid| report.reachable.contains(oid)) { + return Err(ForgeError::ReceiveRejected( + "quarantine contains objects disconnected from every proposed ref tip".into(), + )); + } + } else if !self.staged.is_empty() { + return Err(ForgeError::ReceiveRejected( + "received objects but no ref update would make them reachable".into(), + )); + } + + // Per-ref semantic checks (branch tip must be a commit; fast-forward + // unless the server allows a rewind). These are per-ref because one bad + // ref must not blame the others for its specific reason. + let mut errors: Vec> = vec![None; updates.len()]; + let mut any_error = false; + for (index, update) in updates.iter().enumerate() { + let Some(new) = update.new else { continue }; + if update.name.starts_with("refs/heads/") { + match reader.read_object(&new)? { + Object::Commit(_) => {} + _ => { + errors[index] = Some("branch tip is not a commit".into()); + any_error = true; + continue; + } + } + } + if let Some(old) = update.expected_old { + if !update.allow_non_fast_forward + && !is_ancestor(&reader, old, new, self.limits.connectivity)? + { + errors[index] = Some("non-fast-forward".into()); + any_error = true; + } + } + } + if any_error { + return Ok(ReceiveAtomicOutcome { + results: build_results(&updates, errors), + published_objects: 0, + committed: false, + }); + } + + // Publish immutable objects first. If the ref transaction then loses a + // race, only unreachable objects remain — never a moved ref. + for oid in &self.staged { + let (object_type, payload) = self.quarantine_odb.read_raw(oid)?; + let published = self.repository.odb().write(object_type, &payload)?; + if published != *oid { + return Err(ForgeError::HashMismatch { + looked_up: oid.to_hex(), + computed: published.to_hex(), + }); + } + } + + let commands: Vec = updates + .iter() + .map(|update| RefCommand { + name: update.name.clone(), + change: match update.new { + Some(new) => RefChange::Update { + expected: update.expected_old, + new, + }, + None => RefChange::Delete { + old: update + .expected_old + .expect("delete validated to carry an old value"), + }, + }, + }) + .collect(); + + match self.repository.refs().atomic_update(&commands) { + Ok(()) => Ok(ReceiveAtomicOutcome { + results: build_results(&updates, vec![None; updates.len()]), + published_objects: self.staged.len(), + committed: true, + }), + Err(error) => { + let reason = atomic_ref_public_reason(&error.source); + for (index, update) in updates.iter().enumerate() { + errors[index] = Some(if update.name == error.name { + reason.to_string() + } else { + "atomic transaction failed".to_string() + }); + } + Ok(ReceiveAtomicOutcome { + results: build_results(&updates, errors), + published_objects: 0, + committed: false, + }) + } + } + } + pub fn staged_objects(&self) -> usize { self.staged.len() } diff --git a/src/receive_pack.rs b/src/receive_pack.rs index 2dcbcd6..4669cbc 100644 --- a/src/receive_pack.rs +++ b/src/receive_pack.rs @@ -7,20 +7,25 @@ //! storage transactions are implemented. use crate::error::{ForgeError, Result}; -use crate::receive::{ReceiveLimits, ReceiveOutcome, ReceiveTransaction, RefUpdate}; +use crate::receive::{ + AtomicRefUpdate, ReceiveAtomicOutcome, ReceiveLimits, ReceiveOutcome, ReceiveTransaction, +}; +use crate::refs::{AtomicRefError, RefChange, RefCommand}; use crate::wire::{ encode_packet_line, encode_receive_status, parse_receive_pack_request, PacketLine, PacketLineLimits, ReceivePackCommand, ReceivePackRequest, ReceiveStatus, }; use crate::Repository; -/// Capabilities implemented by the current one-ref SHA-1 receive server. -/// Unsupported features (atomic multi-ref, push-options, sideband) -/// are intentionally absent so stock Git will not negotiate them. +/// Capabilities implemented by the SHA-1 receive server. Every push is applied +/// as one all-or-nothing transaction, so `atomic` is advertised and honored for +/// multi-ref pushes. Unsupported features (push-options, sideband) are +/// intentionally absent so stock Git will not negotiate them. pub const RECEIVE_PACK_CAPABILITIES: &[&str] = &[ "report-status", "report-status-v2", "delete-refs", + "atomic", "ofs-delta", "object-format=sha1", "agent=rit/0.1", @@ -116,65 +121,41 @@ pub fn execute_receive_pack( let report_status = request.capabilities.contains("report-status") || request.capabilities.contains("report-status-v2"); - if request.commands.len() != 1 { - let rejection = - ForgeError::ReceiveRejected("atomic multi-ref receive is not implemented".into()); - return rejected_refs( + // Whether any command carries objects (create/update) and therefore expects + // a packfile. A push made up solely of deletions carries no pack. + let carries_objects = request + .commands + .iter() + .any(|command| !matches!(command, ReceivePackCommand::Delete { .. })); + + if carries_objects { + execute_with_pack( + repository, + input, &request, report_status, - None, - "atomic multi-ref receive is not supported", - rejection, - ); + receive_limits, + policy, + ) + } else { + execute_delete_only(repository, input, &request, report_status) } +} - let update = match &request.commands[0] { - ReceivePackCommand::Create { new, name } => RefUpdate { - name: name.clone(), - expected_old: None, - new: *new, - allow_non_fast_forward: policy.allow_non_fast_forward, - }, - ReceivePackCommand::Update { old, new, name } => RefUpdate { - name: name.clone(), - expected_old: Some(*old), - new: *new, - allow_non_fast_forward: policy.allow_non_fast_forward, - }, - ReceivePackCommand::Delete { old, name } => { - if request.pack_offset != input.len() { - return rejected_refs( - &request, - report_status, - None, - "unexpected pack for deletion", - ForgeError::ReceiveRejected( - "single-ref deletion request carried unexpected pack bytes".into(), - ), - ); - } - return match repository.refs().compare_and_delete(name, *old) { - Ok(()) => Ok(ReceivePackExecution { - response: status_response(&request, report_status, None, None)?, - outcome: None, - deleted: Some(DeletedRef { - name: name.clone(), - old: *old, - }), - rejection: None, - }), - Err(error) => { - let public_reason = public_ref_rejection(&error); - rejected_refs(&request, report_status, None, public_reason, error) - } - }; - } - }; - +/// Apply a push that stages a pack (any mix of create/update, optionally with +/// deletions) as one atomic multi-ref transaction. +fn execute_with_pack( + repository: &Repository, + input: &[u8], + request: &ReceivePackRequest, + report_status: bool, + receive_limits: ReceiveLimits, + policy: ReceivePackPolicy, +) -> Result { let mut transaction = ReceiveTransaction::begin(repository, receive_limits)?; if let Err(error) = transaction.stage_pack(&input[request.pack_offset..]) { return rejected_refs( - &request, + request, report_status, Some("pack rejected"), "unpacker error", @@ -182,20 +163,223 @@ pub fn execute_receive_pack( ); } - match transaction.finish(update) { - Ok(outcome) => Ok(ReceivePackExecution { - response: status_response(&request, report_status, None, None)?, - outcome: Some(outcome), - deleted: None, - rejection: None, - }), + let updates: Vec = request + .commands + .iter() + .map(|command| atomic_update_from_command(command, policy)) + .collect(); + + match transaction.finish_atomic(updates) { + Ok(outcome) => Ok(execution_from_atomic(request, report_status, outcome)?), Err(error) => { + // A whole-graph failure (bad connectivity, disconnected objects): + // report the same stable reason on every ref, as the single-ref + // path did, and never move a ref. let public_reason = public_ref_rejection(&error); - rejected_refs(&request, report_status, None, public_reason, error) + rejected_refs(request, report_status, None, public_reason, error) } } } +/// Apply a deletion-only push (no pack) as one atomic ref transaction. +fn execute_delete_only( + repository: &Repository, + input: &[u8], + request: &ReceivePackRequest, + report_status: bool, +) -> Result { + if request.pack_offset != input.len() { + return rejected_refs( + request, + report_status, + None, + "unexpected pack for deletion", + ForgeError::ReceiveRejected( + "deletion-only request carried unexpected pack bytes".into(), + ), + ); + } + + let commands: Vec = request + .commands + .iter() + .map(|command| match command { + ReceivePackCommand::Delete { old, name } => RefCommand { + name: name.clone(), + change: RefChange::Delete { old: *old }, + }, + // `carries_objects` guaranteed every command here is a deletion. + other => unreachable!("non-delete command in deletion-only push: {other:?}"), + }) + .collect(); + + match repository.refs().atomic_update(&commands) { + Ok(()) => { + let statuses = request + .commands + .iter() + .map(|command| ReceiveStatus { + ref_name: command.name().to_string(), + error: None, + }) + .collect::>(); + Ok(ReceivePackExecution { + response: encode_status_body(report_status, None, &statuses)?, + outcome: None, + deleted: single_deleted_ref(&commands), + rejection: None, + }) + } + Err(error) => atomic_failure_execution(request, report_status, error), + } +} + +/// Translate one wire command into an [`AtomicRefUpdate`], applying the server's +/// non-fast-forward policy (never inferred from the client). +fn atomic_update_from_command( + command: &ReceivePackCommand, + policy: ReceivePackPolicy, +) -> AtomicRefUpdate { + match command { + ReceivePackCommand::Create { new, name } => AtomicRefUpdate { + name: name.clone(), + expected_old: None, + new: Some(*new), + allow_non_fast_forward: policy.allow_non_fast_forward, + }, + ReceivePackCommand::Update { old, new, name } => AtomicRefUpdate { + name: name.clone(), + expected_old: Some(*old), + new: Some(*new), + allow_non_fast_forward: policy.allow_non_fast_forward, + }, + ReceivePackCommand::Delete { old, name } => AtomicRefUpdate { + name: name.clone(), + expected_old: Some(*old), + new: None, + allow_non_fast_forward: policy.allow_non_fast_forward, + }, + } +} + +/// Build the transport execution from a finished atomic outcome, encoding the +/// per-ref report-status and surfacing a typed rejection when nothing committed. +fn execution_from_atomic( + request: &ReceivePackRequest, + report_status: bool, + outcome: ReceiveAtomicOutcome, +) -> Result { + let statuses = outcome + .results + .iter() + .map(|result| ReceiveStatus { + ref_name: result.name.clone(), + error: result.error.clone(), + }) + .collect::>(); + let response = encode_status_body(report_status, None, &statuses)?; + + if outcome.committed { + Ok(ReceivePackExecution { + response, + outcome: single_receive_outcome(request, &outcome), + deleted: None, + rejection: None, + }) + } else { + let reason = outcome + .results + .iter() + .find_map(|result| result.error.clone()) + .unwrap_or_else(|| "receive rejected".into()); + Ok(ReceivePackExecution { + response, + outcome: None, + deleted: None, + rejection: Some(ForgeError::ReceiveRejected(reason)), + }) + } +} + +/// Preserve the single-ref `outcome` summary for the common one-ref update push. +fn single_receive_outcome( + request: &ReceivePackRequest, + outcome: &ReceiveAtomicOutcome, +) -> Option { + let [command] = request.commands.as_slice() else { + return None; + }; + match command { + ReceivePackCommand::Create { new, name } => Some(ReceiveOutcome { + ref_name: name.clone(), + old: None, + new: *new, + published_objects: outcome.published_objects, + }), + ReceivePackCommand::Update { old, new, name } => Some(ReceiveOutcome { + ref_name: name.clone(), + old: Some(*old), + new: *new, + published_objects: outcome.published_objects, + }), + ReceivePackCommand::Delete { .. } => None, + } +} + +/// Preserve the single-ref `deleted` summary for the common one-ref delete push. +fn single_deleted_ref(commands: &[RefCommand]) -> Option { + let [command] = commands else { + return None; + }; + match &command.change { + RefChange::Delete { old } => Some(DeletedRef { + name: command.name.clone(), + old: *old, + }), + RefChange::Update { .. } => None, + } +} + +/// Map a rejected deletion-only atomic transaction into per-ref `ng` statuses. +fn atomic_failure_execution( + request: &ReceivePackRequest, + report_status: bool, + error: AtomicRefError, +) -> Result { + let reason = public_ref_rejection(&error.source); + let statuses = request + .commands + .iter() + .map(|command| ReceiveStatus { + ref_name: command.name().to_string(), + error: Some(if command.name() == error.name { + reason.to_string() + } else { + "atomic transaction failed".to_string() + }), + }) + .collect::>(); + Ok(ReceivePackExecution { + response: encode_status_body(report_status, None, &statuses)?, + outcome: None, + deleted: None, + rejection: Some(error.source), + }) +} + +/// Encode a report-status body, or an empty body when the client did not +/// negotiate report-status/report-status-v2. +fn encode_status_body( + report_status: bool, + unpack_error: Option<&str>, + statuses: &[ReceiveStatus], +) -> Result> { + if !report_status { + return Ok(Vec::new()); + } + encode_receive_status(unpack_error, statuses) +} + fn rejected_refs( request: &ReceivePackRequest, report_status: bool, @@ -256,7 +440,7 @@ mod tests { } #[test] - fn rejects_multi_ref_before_unpacking_and_reports_every_ref() { + fn multi_ref_push_with_invalid_pack_rejects_every_ref_atomically() { let dir = tempfile::tempdir().unwrap(); std::fs::create_dir_all(dir.path().join("objects")).unwrap(); let repo = Repository::open_git_dir(dir.path()).unwrap(); @@ -285,11 +469,10 @@ mod tests { ReceivePackPolicy::default(), ) .unwrap(); + // Multi-ref is now processed atomically, but an undecodable pack rejects + // the whole batch: no ref moves and every ref reports `ng`. assert!(execution.outcome.is_none()); - assert!(matches!( - execution.rejection, - Some(ForgeError::ReceiveRejected(_)) - )); + assert!(matches!(execution.rejection, Some(ForgeError::Pack(_)))); let status = decode_packet_lines(&execution.response, PacketLineLimits::default()).unwrap(); assert_eq!(status.len(), 4); assert!( @@ -333,7 +516,8 @@ mod tests { assert!( matches!(&packets[0], PacketLine::Data(line) if line.starts_with(b"0000000000000000000000000000000000000000 capabilities^{}\0")) ); - assert!(!empty + // Atomic multi-ref receive is now advertised and honored. + assert!(empty .windows(b"atomic".len()) .any(|window| window == b"atomic")); assert!(empty diff --git a/src/reflog.rs b/src/reflog.rs index e34653c..32a3595 100644 --- a/src/reflog.rs +++ b/src/reflog.rs @@ -191,7 +191,8 @@ mod tests { #[test] fn name_with_spaces_parses() { - let line = "0000000000000000000000000000000000000000 1111111111111111111111111111111111111111 \ + let line = + "0000000000000000000000000000000000000000 1111111111111111111111111111111111111111 \ Joe Q Public 1700000001 +0100\tbranch: Created from HEAD"; let e = ReflogEntry::parse(line).unwrap(); assert_eq!(e.name, "Joe Q Public"); @@ -238,8 +239,14 @@ mod tests { // Read unbounded — should return newest first. let entries = read_reflog(git_dir, "refs/heads/main", 100).unwrap(); assert_eq!(entries.len(), 2); - assert_eq!(entries[0].new_oid, "2222222222222222222222222222222222222222"); - assert_eq!(entries[1].new_oid, "1111111111111111111111111111111111111111"); + assert_eq!( + entries[0].new_oid, + "2222222222222222222222222222222222222222" + ); + assert_eq!( + entries[1].new_oid, + "1111111111111111111111111111111111111111" + ); } #[test] diff --git a/src/refs.rs b/src/refs.rs index 31fa37f..db8eae2 100644 --- a/src/refs.rs +++ b/src/refs.rs @@ -238,6 +238,137 @@ impl Refs { result } + /// Apply several ref changes as one all-or-nothing transaction. + /// + /// Phase 1 locks every ref with the same `.lock` protocol as + /// [`compare_and_swap`](Self::compare_and_swap) and verifies each current + /// value against its command's expectation. If any lock cannot be taken or + /// any expectation is stale, nothing is modified and the offending ref is + /// named in the returned [`AtomicRefError`] so the caller can report a + /// precise per-ref status. Locks are non-blocking (`create_new`), so two + /// conflicting transactions never deadlock — the loser observes an existing + /// `.lock` and aborts. + /// + /// Phase 2 publishes each change (write+rename for updates, unlink for + /// deletes). Because every expectation was already verified under lock, this + /// phase only fails on an unexpected filesystem error; the decision to accept + /// or reject the batch is fully atomic even though the physical commit, like + /// Git's own loose-ref backend, is not perfectly crash-atomic across files. + pub fn atomic_update( + &self, + commands: &[RefCommand], + ) -> std::result::Result<(), AtomicRefError> { + let fail = |name: &str, source: ForgeError| AtomicRefError { + name: name.to_string(), + source, + }; + + let mut held: Vec = Vec::new(); + for (index, command) in commands.iter().enumerate() { + match self.lock_and_verify(index, command) { + Ok(lock) => held.push(lock), + Err(source) => { + rollback_ref_locks(&held); + return Err(fail(&command.name, source)); + } + } + } + + for position in 0..held.len() { + let command = &commands[held[position].index]; + if let Err(source) = commit_ref_change(&mut held[position], &command.change) { + // The physical commit failed mid-batch. Clean every remaining + // lock so a retry is possible; earlier renames cannot be undone. + rollback_ref_locks(&held); + return Err(fail(&command.name, source)); + } + } + Ok(()) + } + + /// Lock one ref and verify its current value matches `command`'s expectation. + /// On success the returned guard owns the `.lock` file for the commit phase. + fn lock_and_verify(&self, index: usize, command: &RefCommand) -> Result { + validate_refname(&command.name)?; + let path = self.git_dir.join(&command.name); + let parent = path + .parent() + .ok_or_else(|| ForgeError::UnsafePath(command.name.clone()))?; + std::fs::create_dir_all(parent)?; + reject_symlink_components(&self.git_dir, parent)?; + if std::fs::symlink_metadata(&path) + .map(|metadata| metadata.file_type().is_symlink()) + .unwrap_or(false) + { + return Err(ForgeError::UnsafePath(path.display().to_string())); + } + + let lock_path = PathBuf::from(format!("{}.lock", path.display())); + let lock = match OpenOptions::new() + .write(true) + .create_new(true) + .open(&lock_path) + { + Ok(file) => file, + Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => { + return Err(ForgeError::RefLocked(command.name.clone())) + } + Err(error) => return Err(error.into()), + }; + + let verify = (|| { + let actual = match self.resolve(&command.name) { + Ok(oid) => Some(oid), + Err(ForgeError::InvalidRef(_)) => None, + Err(error) => return Err(error), + }; + match &command.change { + RefChange::Update { expected, .. } => { + if actual != *expected { + return Err(ForgeError::RefConflict { + name: command.name.clone(), + expected: expected + .map(|oid| oid.to_hex()) + .unwrap_or_else(|| "".into()), + actual: actual + .map(|oid| oid.to_hex()) + .unwrap_or_else(|| "".into()), + }); + } + } + RefChange::Delete { old } => { + if actual != Some(*old) { + return Err(ForgeError::RefConflict { + name: command.name.clone(), + expected: old.to_hex(), + actual: actual + .map(|oid| oid.to_hex()) + .unwrap_or_else(|| "".into()), + }); + } + if self.read_packed_refs()?.contains_key(&command.name) { + return Err(ForgeError::ReceiveRejected(format!( + "cannot safely delete packed ref {} with the loose-ref transaction", + command.name + ))); + } + } + } + Ok(()) + })(); + + if let Err(error) = verify { + let _ = std::fs::remove_file(&lock_path); + return Err(error); + } + Ok(HeldRefLock { + index, + path, + lock_path, + lock, + }) + } + /// Append one reflog entry to `.git/logs/` and, when this ref is /// HEAD's current symbolic target, also to `.git/logs/HEAD`. /// @@ -323,6 +454,76 @@ impl Refs { } } +/// One ref change requested inside an atomic multi-ref transaction. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum RefChange { + /// Set the ref to `new`, requiring its current value to equal `expected` + /// (`None` means the ref must not currently exist — a creation). + Update { + expected: Option, + new: ObjectId, + }, + /// Delete the ref, requiring its current value to equal `old`. + Delete { old: ObjectId }, +} + +/// A named [`RefChange`] for [`Refs::atomic_update`]. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct RefCommand { + pub name: String, + pub change: RefChange, +} + +/// Failure from [`Refs::atomic_update`], naming the offending ref so a caller can +/// report a precise per-ref status while failing every other ref generically. +#[derive(Debug)] +pub struct AtomicRefError { + pub name: String, + pub source: ForgeError, +} + +/// A ref lock held between the verify and commit phases of an atomic update. +struct HeldRefLock { + /// Position of the originating command, so the commit phase can recover it. + index: usize, + path: PathBuf, + lock_path: PathBuf, + lock: std::fs::File, +} + +/// Best-effort release of every acquired `.lock` file (used to abort a batch). +fn rollback_ref_locks(held: &[HeldRefLock]) { + for lock in held { + let _ = std::fs::remove_file(&lock.lock_path); + } +} + +/// Publish one verified change: write+rename for an update, unlink for a delete. +fn commit_ref_change(held: &mut HeldRefLock, change: &RefChange) -> Result<()> { + match change { + RefChange::Update { new, .. } => { + writeln!(held.lock, "{new}")?; + held.lock.sync_all()?; + std::fs::rename(&held.lock_path, &held.path)?; + if let Some(parent) = held.path.parent() { + std::fs::File::open(parent)?.sync_all()?; + } + } + RefChange::Delete { .. } => { + match std::fs::remove_file(&held.path) { + Ok(()) => {} + Err(error) if error.kind() == std::io::ErrorKind::NotFound => {} + Err(error) => return Err(error.into()), + } + if let Some(parent) = held.path.parent() { + std::fs::File::open(parent)?.sync_all()?; + } + std::fs::remove_file(&held.lock_path)?; + } + } + Ok(()) +} + /// Interpret raw ref file / HEAD content. fn parse_ref_content(content: &str) -> Result { if let Some(target) = content.strip_prefix("ref:") { diff --git a/src/repo.rs b/src/repo.rs index f73b74f..0244eb8 100644 --- a/src/repo.rs +++ b/src/repo.rs @@ -79,7 +79,10 @@ impl Repository { // HEAD points at the (not-yet-existing) default branch. Preserve an // existing HEAD so reinitialization does not move the current branch. - write_if_absent(&git_dir.join("HEAD"), format!("ref: {head_ref}\n").as_bytes())?; + write_if_absent( + &git_dir.join("HEAD"), + format!("ref: {head_ref}\n").as_bytes(), + )?; // Minimal but real config. `bare` reflects the requested mode so that // downstream tools (and `worktree_root`) behave correctly. @@ -810,15 +813,10 @@ impl Repository { let mut branches: Vec<(String, ObjectId, bool)> = all .into_iter() .filter_map(|(refname, oid)| { - refname - .strip_prefix("refs/heads/") - .map(|short| { - let is_current = current - .as_deref() - .map(|c| c == refname) - .unwrap_or(false); - (short.to_string(), oid, is_current) - }) + refname.strip_prefix("refs/heads/").map(|short| { + let is_current = current.as_deref().map(|c| c == refname).unwrap_or(false); + (short.to_string(), oid, is_current) + }) }) .collect(); branches.sort_by(|a, b| a.0.cmp(&b.0)); @@ -1004,9 +1002,10 @@ impl Repository { pub fn tag_delete(&self, name: &str) -> Result<()> { let refname = format!("refs/tags/{name}"); validate_refname(&refname)?; - let tip = self.refs.resolve(&refname).map_err(|_| { - ForgeError::InvalidRef(format!("tag {name} not found")) - })?; + let tip = self + .refs + .resolve(&refname) + .map_err(|_| ForgeError::InvalidRef(format!("tag {name} not found")))?; self.refs.compare_and_delete(&refname, tip)?; Ok(()) } diff --git a/src/sequencer.rs b/src/sequencer.rs new file mode 100644 index 0000000..b74cd7c --- /dev/null +++ b/src/sequencer.rs @@ -0,0 +1,447 @@ +//! The on-disk sequencer: rebase and cherry-pick as a resumable state machine. +//! +//! Git records multi-commit history edits under `.git/sequencer/` (a `todo` +//! list and a `done` log) plus the single-pick anchors `CHERRY_PICK_HEAD` / +//! `REBASE_HEAD`. This module reproduces that model on top of the from-scratch +//! three-way merge in [`crate::merge_cmd`]: +//! +//! - **cherry-pick** replays each named commit onto HEAD (base = the commit's +//! first parent, ours = HEAD, theirs = the commit); +//! - **rebase** resets the branch to `onto` and replays `upstream..HEAD` on top; +//! - a conflict stops the sequence, leaving conflict markers + an unmerged index +//! + `CHERRY_PICK_HEAD`, so the user can resolve and `--continue`, drop the +//! commit with `--skip`, or unwind with `--abort`. +//! +//! State layout (all under the repository's git dir): +//! +//! ```text +//! sequencer/head original HEAD oid (the abort target) +//! sequencer/onto rebase target oid (rebase only) +//! sequencer/todo remaining "pick " lines, oldest first +//! sequencer/done applied "pick " lines +//! CHERRY_PICK_HEAD the commit currently being applied (present on conflict) +//! MERGE_MSG that commit's message (for --continue) +//! ``` +//! +//! The CLI wiring lives in `main.rs`; the integrator calls [`cmd_cherry_pick`], +//! [`cmd_rebase`], [`cmd_sequencer_continue`], [`cmd_sequencer_abort`], and +//! [`cmd_sequencer_skip`]. + +use std::collections::HashSet; +use std::collections::VecDeque; + +use crate::error::{ForgeError, Result}; +use crate::merge_cmd::{ + build_worktree_merge, force_reset, head_branch, install_unmerged, read_gitdir_oid, + read_gitdir_string, remove_gitdir_file, write_gitdir_file, WorktreeMerge, +}; +use crate::object::Object; +use crate::oid::ObjectId; +use crate::repo::Repository; +use crate::signature::Signature; + +const TODO: &str = "sequencer/todo"; +const DONE: &str = "sequencer/done"; +const HEAD_FILE: &str = "sequencer/head"; +const ONTO: &str = "sequencer/onto"; +const CHERRY_PICK_HEAD: &str = "CHERRY_PICK_HEAD"; +const REBASE_HEAD: &str = "REBASE_HEAD"; +const MERGE_MSG: &str = "MERGE_MSG"; + +/// Bound on the ancestry walk used to compute the rebase commit list. +const MAX_REBASE_WALK: usize = 500_000; + +/// Whether a sequence ran to completion or stopped on a conflict. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum SequencerStatus { + /// Every step applied; no state remains. + Completed, + /// Stopped on a conflict on these paths; state is persisted for `--continue`. + Stopped { conflicts: Vec }, +} + +// ── cherry-pick ───────────────────────────────────────────────────────────── + +/// `git cherry-pick ...`: replay each commit onto the current branch. +pub fn cmd_cherry_pick( + repo: &Repository, + revs: &[&str], + sig: &Signature, +) -> Result { + if revs.is_empty() { + return Err(ForgeError::InvalidRef( + "cherry-pick requires at least one commit".into(), + )); + } + let orig = repo.head().map_err(|_| { + ForgeError::InvalidRef("cannot cherry-pick onto an empty repository".into()) + })?; + head_branch(repo)?; // fail fast on detached HEAD + + let mut oids = Vec::with_capacity(revs.len()); + for rev in revs { + oids.push(peel_commit(repo, repo.resolve(rev)?)?); + } + + let git_dir = repo.git_dir(); + write_gitdir_file(git_dir, HEAD_FILE, format!("{orig}\n").as_bytes())?; + remove_gitdir_file(git_dir, ONTO); + write_todo(repo, &oids)?; + write_gitdir_file(git_dir, DONE, b"")?; + + run_todo(repo, sig) +} + +// ── rebase ────────────────────────────────────────────────────────────────── + +/// `git rebase [--onto ] `: reset the current branch to `onto` +/// (default `upstream`) and replay `upstream..HEAD` on top. +pub fn cmd_rebase( + repo: &Repository, + upstream: &str, + onto: Option<&str>, + sig: &Signature, +) -> Result { + let head_ref = head_branch(repo)?; + let head_oid = repo + .head() + .map_err(|_| ForgeError::InvalidRef("cannot rebase an empty repository".into()))?; + let upstream_oid = peel_commit(repo, repo.resolve(upstream)?)?; + let onto_oid = match onto { + Some(spec) => peel_commit(repo, repo.resolve(spec)?)?, + None => upstream_oid, + }; + + let commits = commits_to_replay(repo, upstream_oid, head_oid)?; + + let git_dir = repo.git_dir(); + write_gitdir_file(git_dir, HEAD_FILE, format!("{head_oid}\n").as_bytes())?; + write_gitdir_file(git_dir, ONTO, format!("{onto_oid}\n").as_bytes())?; + write_todo(repo, &commits)?; + write_gitdir_file(git_dir, DONE, b"")?; + + // Detach the worktree/branch onto the new base before replaying. + if onto_oid != head_oid { + repo.checkout_tree(repo.peel_to_commit(onto_oid)?.tree)?; + repo.refs() + .compare_and_swap(&head_ref, Some(head_oid), onto_oid)?; + let _ = repo.refs().append_reflog( + &head_ref, + Some(head_oid), + onto_oid, + &sig.name, + &sig.email, + sig.time, + &sig.tz, + "rebase: checkout onto", + ); + } + + run_todo(repo, sig) +} + +// ── continue / abort / skip ───────────────────────────────────────────────── + +/// `--continue`: finalize the in-progress pick (from the now-resolved index), +/// then resume the remaining todo. Also handles finishing a conflicted merge. +pub fn cmd_sequencer_continue(repo: &Repository, sig: &Signature) -> Result { + let git_dir = repo.git_dir(); + + if read_gitdir_oid(git_dir, CHERRY_PICK_HEAD).is_some() { + finalize_pick(repo, sig)?; + } else if read_gitdir_oid(git_dir, "MERGE_HEAD").is_some() { + // A plain `merge` conflict was resolved; complete it. + crate::merge_cmd::continue_merge(repo, sig, None)?; + return Ok(SequencerStatus::Completed); + } + + if git_dir.join(TODO).exists() { + run_todo(repo, sig) + } else { + finish(repo); + Ok(SequencerStatus::Completed) + } +} + +/// `--abort`: unwind to the original HEAD recorded at the start of the sequence. +pub fn cmd_sequencer_abort(repo: &Repository) -> Result<()> { + let git_dir = repo.git_dir(); + let orig = read_gitdir_oid(git_dir, HEAD_FILE) + .or_else(|| read_gitdir_oid(git_dir, "ORIG_HEAD")) + .ok_or_else(|| ForgeError::InvalidRef("no sequencer state to abort".into()))?; + let head_ref = head_branch(repo)?; + let current = repo.head()?; + if current != orig { + repo.refs() + .compare_and_swap(&head_ref, Some(current), orig)?; + } + force_reset(repo, repo.peel_to_commit(orig)?.tree)?; + finish(repo); + Ok(()) +} + +/// `--skip`: drop the conflicted commit and resume the remaining todo. +pub fn cmd_sequencer_skip(repo: &Repository, sig: &Signature) -> Result { + let git_dir = repo.git_dir(); + // Discard the half-applied worktree/index back to the current HEAD. + let head_tree = repo.peel_to_commit(repo.head()?)?.tree; + force_reset(repo, head_tree)?; + remove_gitdir_file(git_dir, CHERRY_PICK_HEAD); + remove_gitdir_file(git_dir, REBASE_HEAD); + remove_gitdir_file(git_dir, MERGE_MSG); + + if git_dir.join(TODO).exists() { + run_todo(repo, sig) + } else { + finish(repo); + Ok(SequencerStatus::Completed) + } +} + +// ── core loop ─────────────────────────────────────────────────────────────── + +/// Pop and apply todo entries until the list drains or a pick conflicts. +fn run_todo(repo: &Repository, sig: &Signature) -> Result { + loop { + let todo = read_todo(repo)?; + let Some((&next, rest)) = todo.split_first() else { + finish(repo); + return Ok(SequencerStatus::Completed); + }; + // Persist the remaining list *before* attempting, so a conflict leaves a + // correct resume point (the current pick lives in CHERRY_PICK_HEAD). + write_todo(repo, rest)?; + + let head = repo.head()?; + match pick_onto(repo, head, next, sig)? { + PickOutcome::Applied | PickOutcome::Empty => { + append_done(repo, next)?; + } + PickOutcome::Conflicted(conflicts) => { + write_gitdir_file(repo.git_dir(), REBASE_HEAD, format!("{next}\n").as_bytes())?; + return Ok(SequencerStatus::Stopped { conflicts }); + } + } + } +} + +enum PickOutcome { + Applied, + /// The pick produced no change (already applied) — silently skipped. + Empty, + Conflicted(Vec), +} + +/// Apply one commit on top of `head` using three-way merge semantics. +/// +/// On a clean apply, a new commit is written (author preserved from the picked +/// commit, committer = `sig`) and the branch advances. On a conflict, the +/// worktree/index are left conflicted and `CHERRY_PICK_HEAD` is recorded. +fn pick_onto( + repo: &Repository, + head: ObjectId, + commit_oid: ObjectId, + sig: &Signature, +) -> Result { + let commit = repo.commit(&commit_oid)?; + let base_tree = match commit.parents.first() { + Some(parent) => Some(repo.peel_to_commit(*parent)?.tree), + None => None, + }; + let ours_tree = repo.peel_to_commit(head)?.tree; + let theirs_tree = commit.tree; + let head_ref = head_branch(repo)?; + + match build_worktree_merge(repo, base_tree, ours_tree, theirs_tree)? { + WorktreeMerge::Clean(tree) => { + if tree == ours_tree { + return Ok(PickOutcome::Empty); + } + repo.checkout_tree(tree)?; + let message = if commit.message.is_empty() { + b"cherry-pick\n".to_vec() + } else { + commit.message.clone() + }; + // The commit is written and the branch ref advanced as a side effect; + // the sequencer resumes from the ref, so the new oid isn't needed here. + repo.commit_tree( + tree, + vec![head], + commit.author.clone(), + sig.clone(), + &message, + Some(&head_ref), + )?; + Ok(PickOutcome::Applied) + } + WorktreeMerge::Conflict { + tree, + conflicts, + stages, + } => { + repo.checkout_tree(tree)?; + install_unmerged(repo.git_dir(), &stages)?; + write_gitdir_file( + repo.git_dir(), + CHERRY_PICK_HEAD, + format!("{commit_oid}\n").as_bytes(), + )?; + let message = if commit.message.is_empty() { + b"cherry-pick\n".to_vec() + } else { + commit.message.clone() + }; + write_gitdir_file(repo.git_dir(), MERGE_MSG, &message)?; + Ok(PickOutcome::Conflicted(conflicts)) + } + } +} + +/// Create the commit for a conflict that the user has now resolved and staged. +fn finalize_pick(repo: &Repository, sig: &Signature) -> Result { + let git_dir = repo.git_dir(); + let cherry = read_gitdir_oid(git_dir, CHERRY_PICK_HEAD) + .ok_or_else(|| ForgeError::InvalidRef("no CHERRY_PICK_HEAD to continue".into()))?; + let picked = repo.commit(&cherry)?; + let head = repo.head()?; + let head_ref = head_branch(repo)?; + // Fails closed unless every conflicted path has been resolved to stage 0. + let tree = repo.write_tree()?; + let message = read_gitdir_string(git_dir, MERGE_MSG) + .map(String::into_bytes) + .unwrap_or_else(|| picked.message.clone()); + let message = if message.is_empty() { + b"cherry-pick\n".to_vec() + } else { + message + }; + let new = repo.commit_tree( + tree, + vec![head], + picked.author.clone(), + sig.clone(), + &message, + Some(&head_ref), + )?; + append_done(repo, cherry)?; + remove_gitdir_file(git_dir, CHERRY_PICK_HEAD); + remove_gitdir_file(git_dir, REBASE_HEAD); + remove_gitdir_file(git_dir, MERGE_MSG); + Ok(new) +} + +// ── todo/done persistence ─────────────────────────────────────────────────── + +fn write_todo(repo: &Repository, oids: &[ObjectId]) -> Result<()> { + write_gitdir_file(repo.git_dir(), TODO, &encode_list(oids)) +} + +fn read_todo(repo: &Repository) -> Result> { + match read_gitdir_string(repo.git_dir(), TODO) { + Some(content) => decode_list(&content), + None => Ok(Vec::new()), + } +} + +fn append_done(repo: &Repository, oid: ObjectId) -> Result<()> { + let mut done = read_gitdir_string(repo.git_dir(), DONE).unwrap_or_default(); + done.push_str(&format!("pick {oid}\n")); + write_gitdir_file(repo.git_dir(), DONE, done.as_bytes()) +} + +fn encode_list(oids: &[ObjectId]) -> Vec { + let mut out = String::new(); + for oid in oids { + out.push_str(&format!("pick {oid}\n")); + } + out.into_bytes() +} + +fn decode_list(content: &str) -> Result> { + let mut oids = Vec::new(); + for line in content.lines() { + let line = line.trim(); + if line.is_empty() || line.starts_with('#') { + continue; + } + // "pick " (accept a bare oid too). + let token = line.split_whitespace().nth(1).unwrap_or(line); + oids.push(ObjectId::from_hex(token)?); + } + Ok(oids) +} + +/// Remove every sequencer state file at the end of (or on abort of) a sequence. +fn finish(repo: &Repository) { + let git_dir = repo.git_dir(); + remove_gitdir_file(git_dir, TODO); + remove_gitdir_file(git_dir, DONE); + remove_gitdir_file(git_dir, HEAD_FILE); + remove_gitdir_file(git_dir, ONTO); + remove_gitdir_file(git_dir, CHERRY_PICK_HEAD); + remove_gitdir_file(git_dir, REBASE_HEAD); + remove_gitdir_file(git_dir, MERGE_MSG); + let _ = std::fs::remove_dir(git_dir.join("sequencer")); +} + +// ── revision helpers ──────────────────────────────────────────────────────── + +fn peel_commit(repo: &Repository, oid: ObjectId) -> Result { + crate::merge_cmd::peel_commit_oid(repo, oid) +} + +/// The commits reachable from `head` along first-parent history but not already +/// contained in `upstream`, ordered oldest → newest (the rebase replay order). +fn commits_to_replay( + repo: &Repository, + upstream: ObjectId, + head: ObjectId, +) -> Result> { + let upstream_ancestors = ancestors(repo, upstream)?; + let mut list = Vec::new(); + let mut current = head; + loop { + if upstream_ancestors.contains(¤t) { + break; + } + let commit = match repo.read_object(¤t)? { + Object::Commit(commit) => commit, + _ => break, + }; + list.push(current); + if list.len() > MAX_REBASE_WALK { + return Err(ForgeError::ResourceLimit( + "rebase commit list exceeds limit".into(), + )); + } + match commit.parents.first() { + Some(parent) => current = *parent, + None => break, + } + } + list.reverse(); + Ok(list) +} + +/// All ancestors of `start` (inclusive), bounded. +fn ancestors(repo: &Repository, start: ObjectId) -> Result> { + let mut set = HashSet::new(); + let mut queue = VecDeque::from([start]); + while let Some(oid) = queue.pop_front() { + if !set.insert(oid) { + continue; + } + if set.len() > MAX_REBASE_WALK { + return Err(ForgeError::ResourceLimit( + "rebase ancestry walk exceeds limit".into(), + )); + } + if let Ok(Object::Commit(commit)) = repo.read_object(&oid) { + for parent in commit.parents { + queue.push_back(parent); + } + } + } + Ok(set) +} diff --git a/src/server.rs b/src/server.rs index ab76ab2..cede1a0 100644 --- a/src/server.rs +++ b/src/server.rs @@ -83,7 +83,10 @@ pub fn update_server_info(repo: &Repository) -> Result<()> { let objects_info = git_dir.join("objects").join("info"); std::fs::create_dir_all(&objects_info)?; - write_atomic(&objects_info.join("packs"), objects_info_packs(repo)?.as_bytes())?; + write_atomic( + &objects_info.join("packs"), + objects_info_packs(repo)?.as_bytes(), + )?; Ok(()) } @@ -152,7 +155,10 @@ mod tests { .unwrap(); let advertised = dumb_info_refs(&repo).unwrap(); - assert_eq!(advertised, format!("{}\trefs/heads/main\n", commit.to_hex())); + assert_eq!( + advertised, + format!("{}\trefs/heads/main\n", commit.to_hex()) + ); // update_server_info writes the same content to disk. update_server_info(&repo).unwrap(); diff --git a/src/show.rs b/src/show.rs index aec8424..b0c23f4 100644 --- a/src/show.rs +++ b/src/show.rs @@ -176,7 +176,9 @@ mod tests { }], }; tree_obj.canonicalize(); - let tree_oid = repo.hash_object(ObjectType::Tree, &tree_obj.serialize(), true).unwrap(); + let tree_oid = repo + .hash_object(ObjectType::Tree, &tree_obj.serialize(), true) + .unwrap(); let sig = Signature::parse("Test 1700000000 +0000", "test").unwrap(); let commit_oid = repo @@ -204,7 +206,10 @@ mod tests { assert!(text.contains("commit "), "expected 'commit' header: {text}"); assert!(text.contains("Author: Test"), "expected author: {text}"); assert!(text.contains(" root commit"), "expected message: {text}"); - assert!(text.contains("new file mode 100644"), "expected new file: {text}"); + assert!( + text.contains("new file mode 100644"), + "expected new file: {text}" + ); assert!(text.contains("+hello"), "expected diff line: {text}"); } @@ -234,7 +239,9 @@ mod tests { }], }; tree_obj.canonicalize(); - let tree_oid = repo.hash_object(ObjectType::Tree, &tree_obj.serialize(), true).unwrap(); + let tree_oid = repo + .hash_object(ObjectType::Tree, &tree_obj.serialize(), true) + .unwrap(); let mut out = Vec::new(); cmd_show(&repo, Some(&tree_oid.to_hex()), &mut out).unwrap(); @@ -251,7 +258,9 @@ mod tests { let sig = Signature::parse("Test 1700000000 +0000", "test").unwrap(); // First commit: file.txt = "version 1\n" - let blob1 = repo.hash_object(ObjectType::Blob, b"version 1\n", true).unwrap(); + let blob1 = repo + .hash_object(ObjectType::Blob, b"version 1\n", true) + .unwrap(); let mut t1 = Tree { entries: vec![TreeEntry { mode: "100644".into(), @@ -260,13 +269,24 @@ mod tests { }], }; t1.canonicalize(); - let tree1 = repo.hash_object(ObjectType::Tree, &t1.serialize(), true).unwrap(); + let tree1 = repo + .hash_object(ObjectType::Tree, &t1.serialize(), true) + .unwrap(); let commit1 = repo - .commit_tree(tree1, vec![], sig.clone(), sig.clone(), b"v1\n", Some("refs/heads/main")) + .commit_tree( + tree1, + vec![], + sig.clone(), + sig.clone(), + b"v1\n", + Some("refs/heads/main"), + ) .unwrap(); // Second commit: file.txt = "version 2\n" - let blob2 = repo.hash_object(ObjectType::Blob, b"version 2\n", true).unwrap(); + let blob2 = repo + .hash_object(ObjectType::Blob, b"version 2\n", true) + .unwrap(); let mut t2 = Tree { entries: vec![TreeEntry { mode: "100644".into(), @@ -275,16 +295,31 @@ mod tests { }], }; t2.canonicalize(); - let tree2 = repo.hash_object(ObjectType::Tree, &t2.serialize(), true).unwrap(); + let tree2 = repo + .hash_object(ObjectType::Tree, &t2.serialize(), true) + .unwrap(); let commit2 = repo - .commit_tree(tree2, vec![commit1], sig.clone(), sig, b"v2\n", Some("refs/heads/main")) + .commit_tree( + tree2, + vec![commit1], + sig.clone(), + sig, + b"v2\n", + Some("refs/heads/main"), + ) .unwrap(); let mut out = Vec::new(); cmd_show(&repo, Some(&commit2.to_hex()), &mut out).unwrap(); let text = String::from_utf8(out).unwrap(); - assert!(text.contains("-version 1"), "expected deletion line: {text}"); - assert!(text.contains("+version 2"), "expected addition line: {text}"); + assert!( + text.contains("-version 1"), + "expected deletion line: {text}" + ); + assert!( + text.contains("+version 2"), + "expected addition line: {text}" + ); } } diff --git a/src/stash.rs b/src/stash.rs new file mode 100644 index 0000000..8b6b66c --- /dev/null +++ b/src/stash.rs @@ -0,0 +1,227 @@ +//! `git stash`: save the dirty worktree + index as commits, then restore them. +//! +//! A stash entry is a commit exactly as Git builds it — no bespoke format: +//! +//! ```text +//! i-commit tree = staged index, parent = [HEAD] +//! w-commit tree = full worktree, parents = [HEAD, i-commit] +//! ``` +//! +//! `refs/stash` points at the newest w-commit and its **reflog is the stack**: +//! `stash@{0}` is the newest reflog entry, `stash@{1}` the next, and so on — +//! which is why [`stash_list`] and [`stash_drop`] read and rewrite +//! `.git/logs/refs/stash` directly. +//! +//! Restoring (`apply`/`pop`) is a three-way merge of the stashed worktree tree +//! back onto the current HEAD (base = the HEAD the stash was taken against), +//! reusing the shared engine in [`crate::merge_cmd`]. +//! +//! The CLI wiring lives in `main.rs`; the integrator calls [`cmd_stash_push`], +//! [`cmd_stash_pop`], [`cmd_stash_apply`], [`stash_list`], and [`cmd_stash_drop`]. + +use std::path::PathBuf; + +use crate::error::{ForgeError, Result}; +use crate::merge_cmd::{ + build_worktree_merge, force_reset, head_branch, install_unmerged, WorktreeMerge, +}; +use crate::oid::ObjectId; +use crate::reflog::{log_path_for_ref, read_reflog, ReflogEntry}; +use crate::repo::Repository; +use crate::signature::Signature; + +const STASH_REF: &str = "refs/stash"; +/// Upper bound on stash entries read from the reflog stack. +const MAX_STASH_ENTRIES: usize = 100_000; + +/// Outcome of restoring a stash entry. +#[derive(Clone, Debug, PartialEq, Eq)] +pub enum StashApply { + /// The stash applied cleanly. + Clean, + /// Applying produced conflicts on these paths (index left unmerged). + Conflicts(Vec), +} + +// ── push ──────────────────────────────────────────────────────────────────── + +/// `git stash push`: record the index and worktree as a stash entry, then reset +/// the worktree + index back to HEAD. Returns `None` when there is nothing to +/// stash (a clean worktree), or the new w-commit oid otherwise. +pub fn cmd_stash_push( + repo: &Repository, + sig: &Signature, + message: Option<&str>, +) -> Result> { + let head = repo + .head() + .map_err(|_| ForgeError::InvalidRef("cannot stash without an initial commit".into()))?; + let head_commit = repo.peel_to_commit(head)?; + let branch = head_branch(repo) + .ok() + .and_then(|refname| refname.strip_prefix("refs/heads/").map(String::from)) + .unwrap_or_else(|| "HEAD".to_string()); + + // The staged tree (index as it stands) becomes the i-commit. + let index_tree = repo.write_tree()?; + + // Stage the full worktree to capture unstaged changes; this rewrites the + // index, but we reset it back to HEAD at the end regardless. + repo.add(&[PathBuf::from(".")])?; + let worktree_tree = repo.write_tree()?; + + // Nothing changed relative to HEAD → nothing to stash. + if worktree_tree == head_commit.tree && index_tree == head_commit.tree { + return Ok(None); + } + + let short = &head.to_hex()[..7.min(head.to_hex().len())]; + let summary = head_commit.summary(); + let index_msg = format!("index on {branch}: {short} {summary}\n"); + let i_commit = repo.commit_tree( + index_tree, + vec![head], + sig.clone(), + sig.clone(), + index_msg.as_bytes(), + None, + )?; + + let subject = match message { + Some(text) => format!("On {branch}: {text}"), + None => format!("WIP on {branch}: {short} {summary}"), + }; + let w_commit = repo.commit_tree( + worktree_tree, + vec![head, i_commit], + sig.clone(), + sig.clone(), + format!("{subject}\n").as_bytes(), + None, + )?; + + // Push onto the stack: advance refs/stash and append the reflog entry. + let previous = repo.refs().resolve(STASH_REF).ok(); + repo.refs() + .compare_and_swap(STASH_REF, previous, w_commit)?; + repo.refs().append_reflog( + STASH_REF, previous, w_commit, &sig.name, &sig.email, sig.time, &sig.tz, &subject, + )?; + + // Restore the working tree + index to a clean HEAD. + force_reset(repo, head_commit.tree)?; + Ok(Some(w_commit)) +} + +// ── list ──────────────────────────────────────────────────────────────────── + +/// `git stash list`: the stack newest-first as `(index, "stash@{i}: ")`. +pub fn stash_list(repo: &Repository) -> Result> { + let entries = read_reflog(repo.git_dir(), STASH_REF, MAX_STASH_ENTRIES)?; + Ok(entries + .into_iter() + .enumerate() + .map(|(index, entry)| (index, format!("stash@{{{index}}}: {}", entry.message))) + .collect()) +} + +// ── apply / pop ───────────────────────────────────────────────────────────── + +/// `git stash apply []`: restore a stash entry without removing it. +pub fn cmd_stash_apply(repo: &Repository, index: usize) -> Result { + let w_commit_oid = stash_commit(repo, index)?; + apply_commit(repo, w_commit_oid) +} + +/// `git stash pop []`: restore a stash entry and, if it applied cleanly, +/// drop it from the stack. A conflicting pop leaves the entry in place (like +/// Git) so the user does not lose it. +pub fn cmd_stash_pop(repo: &Repository, index: usize) -> Result { + let outcome = cmd_stash_apply(repo, index)?; + if matches!(outcome, StashApply::Clean) { + cmd_stash_drop(repo, index)?; + } + Ok(outcome) +} + +fn apply_commit(repo: &Repository, w_commit_oid: ObjectId) -> Result { + let w_commit = repo.commit(&w_commit_oid)?; + // The stash's first parent is the HEAD it was taken against — the base. + let base_tree = match w_commit.parents.first() { + Some(parent) => Some(repo.peel_to_commit(*parent)?.tree), + None => None, + }; + let ours_tree = repo.peel_to_commit(repo.head()?)?.tree; + let theirs_tree = w_commit.tree; + + match build_worktree_merge(repo, base_tree, ours_tree, theirs_tree)? { + WorktreeMerge::Clean(tree) => { + repo.checkout_tree(tree)?; + Ok(StashApply::Clean) + } + WorktreeMerge::Conflict { + tree, + conflicts, + stages, + } => { + repo.checkout_tree(tree)?; + install_unmerged(repo.git_dir(), &stages)?; + Ok(StashApply::Conflicts(conflicts)) + } + } +} + +// ── drop ──────────────────────────────────────────────────────────────────── + +/// `git stash drop []`: remove one entry from the stack, rewriting the +/// `refs/stash` reflog and repointing (or deleting) the ref. +pub fn cmd_stash_drop(repo: &Repository, index: usize) -> Result<()> { + let git_dir = repo.git_dir(); + let log_path = log_path_for_ref(git_dir, STASH_REF); + let raw = std::fs::read_to_string(&log_path).map_err(|_| { + ForgeError::InvalidRef(format!("stash@{{{index}}} not found (empty stash)")) + })?; + // Reflog file is oldest-first; the stack index is newest-first. + let mut entries: Vec = raw.lines().filter_map(ReflogEntry::parse).collect(); + let count = entries.len(); + if index >= count { + return Err(ForgeError::InvalidRef(format!( + "stash@{{{index}}} not found" + ))); + } + let file_pos = count - 1 - index; + entries.remove(file_pos); + + if entries.is_empty() { + // Stack emptied: delete the ref and its log. + if let Ok(current) = repo.refs().resolve(STASH_REF) { + let _ = repo.refs().compare_and_delete(STASH_REF, current); + } + let _ = std::fs::remove_file(&log_path); + return Ok(()); + } + + // Repoint refs/stash at the new top (the last, newest reflog line). + let new_top = ObjectId::from_hex(&entries.last().expect("non-empty").new_oid)?; + let current = repo.refs().resolve(STASH_REF).ok(); + repo.refs().compare_and_swap(STASH_REF, current, new_top)?; + + let mut rewritten = String::new(); + for entry in &entries { + rewritten.push_str(&entry.format_line()); + rewritten.push('\n'); + } + std::fs::write(&log_path, rewritten)?; + Ok(()) +} + +// ── helpers ───────────────────────────────────────────────────────────────── + +/// The w-commit oid for `stash@{index}` (newest-first). +fn stash_commit(repo: &Repository, index: usize) -> Result { + let entries = read_reflog(repo.git_dir(), STASH_REF, MAX_STASH_ENTRIES)?; + let entry = entries + .get(index) + .ok_or_else(|| ForgeError::InvalidRef(format!("stash@{{{index}}} not found")))?; + ObjectId::from_hex(&entry.new_oid) +} diff --git a/src/tag_ops.rs b/src/tag_ops.rs index 60674b0..420308c 100644 --- a/src/tag_ops.rs +++ b/src/tag_ops.rs @@ -52,16 +52,10 @@ pub fn cmd_tag_list(repo: &Repository, show_annotation: bool) -> anyhow::Result< .ok() .and_then(|obj| match obj { crate::object::Object::Tag(t) => { - t.message_str() - .lines() - .next() - .map(|l| l.trim().to_string()) + t.message_str().lines().next().map(|l| l.trim().to_string()) } crate::object::Object::Commit(c) => { - c.message_str() - .lines() - .next() - .map(|l| l.trim().to_string()) + c.message_str().lines().next().map(|l| l.trim().to_string()) } _ => None, }) @@ -160,10 +154,23 @@ pub fn cmd_tag_delete(repo: &Repository, names: &[&str]) -> anyhow::Result<()> { /// Decoded tag operation — used by the convenience dispatcher. #[derive(Debug)] pub enum TagOp<'a> { - List { show_annotation: bool }, - CreateLightweight { name: &'a str, target: Option<&'a str>, force: bool }, - CreateAnnotated { name: &'a str, target: Option<&'a str>, message: &'a str, force: bool }, - Delete { names: Vec<&'a str> }, + List { + show_annotation: bool, + }, + CreateLightweight { + name: &'a str, + target: Option<&'a str>, + force: bool, + }, + CreateAnnotated { + name: &'a str, + target: Option<&'a str>, + message: &'a str, + force: bool, + }, + Delete { + names: Vec<&'a str>, + }, } /// High-level tag dispatcher: given a decoded [`TagOp`] and an optional actor @@ -178,12 +185,19 @@ pub fn dispatch_tag( ) -> anyhow::Result<()> { match op { TagOp::List { show_annotation } => cmd_tag_list(repo, show_annotation), - TagOp::CreateLightweight { name, target, force } => { - cmd_tag_create_lightweight(repo, name, target, force) - } - TagOp::CreateAnnotated { name, target, message, force } => { - let tagger = sig - .ok_or_else(|| anyhow::anyhow!("annotated tag requires an actor signature"))?; + TagOp::CreateLightweight { + name, + target, + force, + } => cmd_tag_create_lightweight(repo, name, target, force), + TagOp::CreateAnnotated { + name, + target, + message, + force, + } => { + let tagger = + sig.ok_or_else(|| anyhow::anyhow!("annotated tag requires an actor signature"))?; cmd_tag_create_annotated(repo, name, target, message, tagger, force)?; Ok(()) } diff --git a/src/upload_pack.rs b/src/upload_pack.rs index 72ff470..cd6ad8e 100644 --- a/src/upload_pack.rs +++ b/src/upload_pack.rs @@ -8,13 +8,15 @@ //! haves), computed by walking commits → trees → blobs (+ tags); //! - [`generate_pack`] — a real, self-describing **packfile** (`PACK` header, //! per-object type/size varint + zlib payload, SHA-1 trailer). Objects are -//! emitted **undeltified** (full), which is a valid pack `git index-pack` -//! accepts and `git fsck` validates. +//! emitted either **full** or as `OFS_DELTA` entries against a nearby base +//! inside a bounded window (see [`generate_pack_with_options`]); either shape +//! is a valid, self-contained pack that `git index-pack`/`git unpack-objects` +//! decode and `git fsck` validates. //! //! [`upload_pack_v0`] ties them together for the stateless-RPC (HTTP) case: //! parse the request, compute the set, and return `NAK` + the pack. -use std::collections::{HashSet, VecDeque}; +use std::collections::{HashMap, HashSet, VecDeque}; use crate::error::{ForgeError, Result}; use crate::object::{Object, ObjectType}; @@ -28,7 +30,9 @@ use std::io::Write; /// Capabilities `rit` advertises for upload-pack. Intentionally minimal: no /// multi-ack and no side-band, so the negotiation is a single `NAK` + raw pack. -pub const UPLOAD_PACK_CAPABILITIES: &[&str] = &["agent=rit/0.1", "object-format=sha1"]; +/// `ofs-delta` is advertised because [`generate_pack`] may emit `OFS_DELTA` +/// entries; the offsets are always intra-pack and self-contained (never thin). +pub const UPLOAD_PACK_CAPABILITIES: &[&str] = &["agent=rit/0.1", "object-format=sha1", "ofs-delta"]; /// Upper bound on objects walked/sent (fail-closed against pathological repos). const MAX_OBJECTS: usize = 5_000_000; @@ -46,7 +50,10 @@ pub fn advertise_upload_pack(repo: &Repository) -> Result> { // A `symref=HEAD:refs/heads/` cap lets `clone` check out the right // branch; derive it from the HEAD symbolic ref when present. - let mut caps: Vec = UPLOAD_PACK_CAPABILITIES.iter().map(|c| c.to_string()).collect(); + let mut caps: Vec = UPLOAD_PACK_CAPABILITIES + .iter() + .map(|c| c.to_string()) + .collect(); if let Ok(crate::RefTarget::Symbolic(target)) = repo.refs().read_head() { caps.push(format!("symref=HEAD:{target}")); } @@ -154,7 +161,9 @@ fn walk( continue; } if seen.len() > MAX_OBJECTS { - return Err(ForgeError::ResourceLimit("fetch object walk too large".into())); + return Err(ForgeError::ResourceLimit( + "fetch object walk too large".into(), + )); } out.push(oid); match repo.odb().read(&oid)? { @@ -185,7 +194,9 @@ fn walk_tree( continue; } if seen.len() > MAX_OBJECTS { - return Err(ForgeError::ResourceLimit("fetch tree walk too large".into())); + return Err(ForgeError::ResourceLimit( + "fetch tree walk too large".into(), + )); } out.push(oid); for entry in repo.tree(&oid)?.entries { @@ -228,24 +239,105 @@ fn encode_object_header(type_code: u8, size: usize) -> Vec { out } -/// Build a full (undeltified) packfile containing exactly `oids`. +/// The pack object type code for the `OFS_DELTA` representation. +const OFS_DELTA: u8 = 6; + +/// Tuning for [`generate_pack_with_options`]. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct PackOptions { + /// How many preceding candidates (in the type/size-sorted order) each object + /// may be deltified against. `0` disables deltification entirely. + pub window: usize, + /// Hard cap on the length of any single `OFS_DELTA` base chain. Bounds the + /// work a reader must do to reconstruct one object and keeps our own encoder + /// from stacking pathologically deep chains. + pub max_chain_depth: usize, +} + +impl Default for PackOptions { + fn default() -> Self { + // A window of 10 matches Git's default `pack.window`. + Self { + window: 10, + max_chain_depth: 50, + } + } +} + +/// One object's decoded bytes, kept in memory while we search for delta bases. +struct RawObject { + object_type: ObjectType, + payload: Vec, +} + +/// Build a self-contained packfile containing exactly `oids`, using the default +/// delta [`PackOptions`]. Objects that compress better as a delta of a nearby +/// object are emitted as `OFS_DELTA`; the rest are emitted full. The result is a +/// valid non-thin pack (every delta base is included in the same pack). pub fn generate_pack(repo: &Repository, oids: &[ObjectId]) -> Result> { + generate_pack_with_options(repo, oids, PackOptions::default()) +} + +/// Build a self-contained packfile with an explicit delta [`PackOptions`]. +pub fn generate_pack_with_options( + repo: &Repository, + oids: &[ObjectId], + options: PackOptions, +) -> Result> { let count = u32::try_from(oids.len()) .map_err(|_| ForgeError::ResourceLimit("pack object count exceeds u32".into()))?; + + // Read every object once; delta search needs the raw bytes on hand. + let mut objects: Vec = Vec::with_capacity(oids.len()); + for oid in oids { + let (object_type, payload) = repo.odb().read_raw(oid)?; + objects.push(RawObject { + object_type, + payload, + }); + } + + // Emit in a stable "delta-friendly" order: group by type, then largest + // first so bigger objects become bases for their smaller, similar peers. + let mut order: Vec = (0..objects.len()).collect(); + order.sort_by(|&a, &b| { + type_code(objects[a].object_type) + .cmp(&type_code(objects[b].object_type)) + .then_with(|| objects[b].payload.len().cmp(&objects[a].payload.len())) + .then_with(|| oids[a].cmp(&oids[b])) + }); + + // Decide a delta base (an earlier position in `order`) for each object. + let chosen = select_deltas(&objects, &order, options); + let mut pack: Vec = Vec::new(); pack.extend_from_slice(b"PACK"); pack.extend_from_slice(&2u32.to_be_bytes()); pack.extend_from_slice(&count.to_be_bytes()); - for oid in oids { - let (object_type, payload) = repo.odb().read_raw(oid)?; - pack.extend(encode_object_header(type_code(object_type), payload.len())); - let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default()); - encoder.write_all(&payload)?; - let compressed = encoder - .finish() - .map_err(|e| ForgeError::Decompress(format!("pack compression failed: {e}")))?; - pack.extend(compressed); + // Byte offset (from pack start) of each object, keyed by position in `order`, + // so an OFS_DELTA can encode the distance back to its already-written base. + let mut offsets = vec![0u64; order.len()]; + for position in 0..order.len() { + offsets[position] = pack.len() as u64; + match &chosen[position] { + Some(delta) => { + pack.extend(encode_object_header(OFS_DELTA, delta.instructions.len())); + let distance = offsets[position] + .checked_sub(offsets[delta.base_position]) + .ok_or_else(|| ForgeError::Pack("delta base must precede its object".into()))?; + pack.extend(encode_ofs_delta_offset(distance)); + pack.extend(zlib_compress(&delta.instructions)?); + } + None => { + let object = &objects[order[position]]; + pack.extend(encode_object_header( + type_code(object.object_type), + object.payload.len(), + )); + pack.extend(zlib_compress(&object.payload)?); + } + } } // Trailing SHA-1 over the whole pack (excluding the trailer itself). @@ -255,6 +347,205 @@ pub fn generate_pack(repo: &Repository, oids: &[ObjectId]) -> Result> { Ok(pack) } +/// A chosen delta representation for one object at a position in the emit order. +struct ChosenDelta { + /// Position (in `order`) of the base object, always earlier than this one. + base_position: usize, + /// The uncompressed copy/insert instruction stream. + instructions: Vec, +} + +/// For each object in `order`, pick the smallest delta against one of the +/// `window` preceding same-type objects, if any beats storing it full. +fn select_deltas( + objects: &[RawObject], + order: &[usize], + options: PackOptions, +) -> Vec> { + let mut chosen: Vec> = (0..order.len()).map(|_| None).collect(); + let mut depth = vec![0usize; order.len()]; + if options.window == 0 { + return chosen; + } + + for position in 0..order.len() { + let target = &objects[order[position]]; + // Too small to recover the delta header overhead — always store full. + if target.payload.len() < MIN_DELTA_TARGET { + continue; + } + let window_start = position.saturating_sub(options.window); + let mut best: Option = None; + for candidate in window_start..position { + let base = &objects[order[candidate]]; + if base.object_type != target.object_type { + continue; + } + if depth[candidate] >= options.max_chain_depth { + continue; + } + let instructions = encode_delta(&base.payload, &target.payload); + // Only worth it if the delta is strictly smaller than the object. + if instructions.len() >= target.payload.len() { + continue; + } + let better = best + .as_ref() + .map(|current| instructions.len() < current.instructions.len()) + .unwrap_or(true); + if better { + best = Some(ChosenDelta { + base_position: candidate, + instructions, + }); + } + } + if let Some(delta) = best { + depth[position] = depth[delta.base_position] + 1; + chosen[position] = Some(delta); + } + } + chosen +} + +/// Objects below this size never delta well: two size varints plus at least one +/// instruction already rival the object, so we skip the search. +const MIN_DELTA_TARGET: usize = 32; + +/// Compress `data` with zlib exactly as a pack payload requires. +fn zlib_compress(data: &[u8]) -> Result> { + let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default()); + encoder.write_all(data)?; + encoder + .finish() + .map_err(|e| ForgeError::Decompress(format!("pack compression failed: {e}"))) +} + +/// Encode the negative base offset carried by an `OFS_DELTA` header: the byte +/// distance from the delta object back to its base, in Git's big-endian +/// base-128 form with the `-1` continuation bias. +fn encode_ofs_delta_offset(mut offset: u64) -> Vec { + let mut buf = vec![(offset & 0x7f) as u8]; + offset >>= 7; + while offset != 0 { + offset -= 1; + buf.push(0x80 | (offset & 0x7f) as u8); + offset >>= 7; + } + buf.reverse(); + buf +} + +/// Produce a copy/insert delta that reconstructs `target` from `base`, in Git's +/// delta instruction encoding (LE base-128 sizes, then copy/insert opcodes). +fn encode_delta(base: &[u8], target: &[u8]) -> Vec { + const MIN_MATCH: usize = 4; + // Cap how many base positions share one 4-gram bucket, bounding the search. + const MAX_CHAIN: usize = 64; + // A single copy encodes at most a 3-byte size field. + const MAX_COPY: usize = 0x00ff_ffff; + + let mut out = Vec::new(); + encode_delta_size(&mut out, base.len()); + encode_delta_size(&mut out, target.len()); + + // Index every 4-gram in the base so target windows can find copy sources. + let mut index: HashMap<[u8; 4], Vec> = HashMap::new(); + if base.len() >= MIN_MATCH { + for i in 0..=base.len() - MIN_MATCH { + let key = [base[i], base[i + 1], base[i + 2], base[i + 3]]; + let bucket = index.entry(key).or_default(); + if bucket.len() < MAX_CHAIN { + bucket.push(i); + } + } + } + + let mut pending: Vec = Vec::new(); + let mut i = 0usize; + while i < target.len() { + let mut best_len = 0usize; + let mut best_off = 0usize; + if i + MIN_MATCH <= target.len() { + let key = [target[i], target[i + 1], target[i + 2], target[i + 3]]; + if let Some(bucket) = index.get(&key) { + for &pos in bucket { + let limit = MAX_COPY.min(target.len() - i).min(base.len() - pos); + let mut length = 0usize; + while length < limit && target[i + length] == base[pos + length] { + length += 1; + } + if length > best_len { + best_len = length; + best_off = pos; + } + } + } + } + if best_len >= MIN_MATCH { + flush_insert(&mut out, &mut pending); + emit_copy(&mut out, best_off, best_len); + i += best_len; + } else { + pending.push(target[i]); + i += 1; + if pending.len() == 0x7f { + flush_insert(&mut out, &mut pending); + } + } + } + flush_insert(&mut out, &mut pending); + out +} + +/// Encode an object size in the delta header's little-endian base-128 form. +fn encode_delta_size(out: &mut Vec, mut size: usize) { + loop { + let byte = (size & 0x7f) as u8; + size >>= 7; + if size == 0 { + out.push(byte); + break; + } + out.push(byte | 0x80); + } +} + +/// Emit any buffered literal bytes as one or more insert instructions (each +/// carries at most 127 bytes; the opcode is the length with the high bit clear). +fn flush_insert(out: &mut Vec, pending: &mut Vec) { + for chunk in pending.chunks(0x7f) { + out.push(chunk.len() as u8); + out.extend_from_slice(chunk); + } + pending.clear(); +} + +/// Emit a copy instruction: high bit set, then a presence bitmap selecting which +/// of the four offset bytes and three size bytes follow (omitting zero bytes). +fn emit_copy(out: &mut Vec, offset: usize, size: usize) { + let mut cmd = 0x80u8; + let mut bytes = Vec::new(); + let offset = offset as u32; + for shift in 0..4u32 { + let byte = (offset >> (shift * 8)) as u8; + if byte != 0 { + cmd |= 1 << shift; + bytes.push(byte); + } + } + let size = size as u32; + for shift in 0..3u32 { + let byte = (size >> (shift * 8)) as u8; + if byte != 0 { + cmd |= 1 << (4 + shift); + bytes.push(byte); + } + } + out.push(cmd); + out.extend_from_slice(&bytes); +} + #[cfg(test)] mod tests { use super::*; @@ -264,7 +555,9 @@ mod tests { fn pack_header_and_trailer_are_wellformed() { let dir = tempfile::tempdir().unwrap(); let repo = Repository::init(dir.path(), true, Some("main")).unwrap(); - let a = repo.hash_object(ObjectType::Blob, b"alpha\n", true).unwrap(); + let a = repo + .hash_object(ObjectType::Blob, b"alpha\n", true) + .unwrap(); let b = repo.hash_object(ObjectType::Blob, b"beta\n", true).unwrap(); let pack = generate_pack(&repo, &[a, b]).unwrap(); @@ -291,7 +584,9 @@ mod tests { }], }; tree.canonicalize(); - let tree_oid = repo.hash_object(ObjectType::Tree, &tree.serialize(), true).unwrap(); + let tree_oid = repo + .hash_object(ObjectType::Tree, &tree.serialize(), true) + .unwrap(); let sig = crate::Signature::parse("A 1700000000 +0000", "commit").unwrap(); let commit = repo .commit_tree(tree_oid, Vec::new(), sig.clone(), sig, b"c\n", None) diff --git a/tests/interop.rs b/tests/interop.rs index f8873a4..2b3bab8 100644 --- a/tests/interop.rs +++ b/tests/interop.rs @@ -1373,7 +1373,11 @@ fn rit_generated_pack_is_decoded_by_stock_git() { // Object set reachable from HEAD (commit + trees + blobs), packed by rit. let send = rit::reachable_objects(&repo, &[head], &[]).unwrap(); - assert!(send.len() >= 4, "expected commit+trees+blobs, got {}", send.len()); + assert!( + send.len() >= 4, + "expected commit+trees+blobs, got {}", + send.len() + ); let pack = rit::generate_pack(&repo, &send).unwrap(); assert_eq!(&pack[0..4], b"PACK"); @@ -1398,6 +1402,9 @@ fn rit_generated_pack_is_decoded_by_stock_git() { ); // Every object is now present and valid. - assert_eq!(git(target.path(), &["cat-file", "-t", &head.to_hex()]), "commit"); + assert_eq!( + git(target.path(), &["cat-file", "-t", &head.to_hex()]), + "commit" + ); git(target.path(), &["fsck", "--strict"]); }