feat: add gix-serve crate wiring together upload-pack serving

JamesPatrickGill · JamesPatrickGill · commit eaec1bc4266a · 2026-03-27T22:11:33.000Z
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -268,6 +268,7 @@ members = [
     "gix-transport",
     "gix-credentials",
     "gix-protocol",
+    "gix-serve",
     "gix-pack",
     "gix-odb",
     "gix-tempfile",
diff --git a/gix-serve/Cargo.toml b/gix-serve/Cargo.toml
@@ -0,0 +1,50 @@
+lints.workspace = true
+
+[package]
+name = "gix-serve"
+version = "0.1.0"
+repository = "https://github.com/GitoxideLabs/gitoxide"
+license = "MIT OR Apache-2.0"
+description = "A crate of the gitoxide project for serving git repositories"
+authors = ["Sebastian Thiel <sebastian.thiel@icloud.com>"]
+edition = "2021"
+include = ["src/**/*", "LICENSE-*"]
+rust-version = "1.82"
+
+[lib]
+doctest = false
+
+[features]
+## Enable support for SHA-1 hashes.
+sha1 = ["gix-hash/sha1"]
+## Blocking server support.
+blocking-server = [
+  "gix-protocol/blocking-server",
+  "gix-transport/blocking-server",
+]
+
+[dependencies]
+gix-ref = { version = "^0.61.0", path = "../gix-ref" }
+gix-hash = { version = "^0.23.0", path = "../gix-hash" }
+gix-pack = { version = "^0.68.0", path = "../gix-pack", features = [
+  "generate",
+] }
+gix-features = { version = "^0.46.2", path = "../gix-features" }
+gix-protocol = { version = "^0.59.0", path = "../gix-protocol", optional = true }
+gix-transport = { version = "^0.55.1", path = "../gix-transport", optional = true }
+bstr = { version = "1.12.0", default-features = false, features = ["std"] }
+thiserror = "2.0.18"
+
+[dev-dependencies]
+gix-testtools = { path = "../tests/tools" }
+gix-odb = { version = "^0.78.0", path = "../gix-odb" }
+gix-packetline = { version = "^0.21.2", path = "../gix-packetline", features = [
+  "blocking-io",
+] }
+gix-transport = { version = "^0.55.1", path = "../gix-transport", features = [
+  "blocking-server",
+] }
+gix-serve = { path = ".", features = ["blocking-server"] }
+
+[package.metadata.docs.rs]
+all-features = true
diff --git a/gix-serve/LICENSE-APACHE b/gix-serve/LICENSE-APACHE
@@ -0,0 +1 @@
+../LICENSE-APACHE
diff --git a/gix-serve/LICENSE-MIT b/gix-serve/LICENSE-MIT
@@ -0,0 +1 @@
+../LICENSE-MIT
diff --git a/gix-serve/fixtures/make_repo_empty.sh b/gix-serve/fixtures/make_repo_empty.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -eu -o pipefail
+
+git init -q
diff --git a/gix-serve/fixtures/make_repo_multi_branch.sh b/gix-serve/fixtures/make_repo_multi_branch.sh
@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -eu -o pipefail
+
+git init -q
+git checkout -q -b main
+git commit -q --allow-empty -m 'first commit'
+git branch feature
+git checkout -q -b dev
+git commit -q --allow-empty -m 'dev commit'
+git checkout -q main
diff --git a/gix-serve/fixtures/make_repo_simple.sh b/gix-serve/fixtures/make_repo_simple.sh
@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -eu -o pipefail
+
+git init -q
+git checkout -q -b main
+git commit -q --allow-empty -m 'initial commit'
+git branch feature
diff --git a/gix-serve/fixtures/make_repo_with_tags.sh b/gix-serve/fixtures/make_repo_with_tags.sh
@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -eu -o pipefail
+
+git init -q
+git checkout -q -b main
+git commit -q --allow-empty -m 'initial commit'
+git tag lightweight-tag
+git tag -a v1.0 -m 'version 1.0'
+git pack-refs --all
diff --git a/gix-serve/src/lib.rs b/gix-serve/src/lib.rs
@@ -0,0 +1,39 @@
+//! Server-side git protocol support for serving repositories.
+#![deny(missing_docs, rust_2018_idioms, unsafe_code)]
+
+///
+pub mod pack;
+///
+pub mod refs;
+///
+#[cfg(feature = "blocking-server")]
+pub mod serve;
+
+use bstr::BString;
+use gix_hash::ObjectId;
+
+/// A reference ready for advertisement to clients.
+pub struct AdvertisableRef {
+    /// The ref name, e.g. `refs/heads/main`.
+    pub name: BString,
+    /// The object ID the ref points to.
+    pub object_id: ObjectId,
+    /// The peeled object ID, if this is an annotated tag.
+    pub peeled: Option<ObjectId>,
+    /// The symref target, e.g. `refs/heads/main` for `HEAD`.
+    pub symref_target: Option<BString>,
+}
+
+/// Errors from collecting refs.
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum Error {
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+    #[error(transparent)]
+    RefIter(#[from] gix_ref::packed::buffer::open::Error),
+    #[error(transparent)]
+    RefIterEntry(#[from] gix_ref::file::iter::loose_then_packed::Error),
+    #[error(transparent)]
+    RefFind(#[from] gix_ref::file::find::Error),
+}
diff --git a/gix-serve/src/pack.rs b/gix-serve/src/pack.rs
@@ -0,0 +1,68 @@
+use std::{io::Write, sync::atomic::AtomicBool};
+
+use gix_features::{parallel::InOrderIter, progress::Discard};
+use gix_hash::ObjectId;
+use gix_pack::{
+    data::{
+        output::{
+            bytes::FromEntriesIter,
+            count::{objects::ObjectExpansion, objects_unthreaded},
+            entry::iter_from_counts,
+        },
+        Version,
+    },
+    Find,
+};
+
+/// Generate a packfile containing objects reachable from `wants` but not from `haves`.
+pub fn generate_pack<F: Find + Send + Clone + 'static>(
+    db: F,
+    wants: &[ObjectId],
+    _haves: &[ObjectId],
+    out: &mut dyn Write,
+) -> Result<(), Error> {
+    let (counts, _outcome) = objects_unthreaded(
+        &db,
+        &mut wants.iter().copied().map(Ok),
+        &Discard,
+        &AtomicBool::new(false),
+        ObjectExpansion::TreeContents,
+    )?;
+
+    let mut entries_iter = iter_from_counts(counts, db, Box::new(Discard), Default::default());
+
+    let entries: Vec<_> = InOrderIter::from(entries_iter.by_ref())
+        .collect::<Result<Vec<_>, _>>()?
+        .into_iter()
+        .flatten()
+        .collect();
+
+    let num_entries = entries.len() as u32;
+    let pack_writer = FromEntriesIter::new(
+        std::iter::once(Ok::<_, iter_from_counts::Error>(entries)),
+        out,
+        num_entries,
+        Version::V2,
+        gix_hash::Kind::Sha1,
+    );
+
+    for result in pack_writer {
+        result?;
+    }
+
+    Ok(())
+}
+
+/// Errors from pack generation.
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum Error {
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+    #[error(transparent)]
+    Count(#[from] gix_pack::data::output::count::objects::Error),
+    #[error(transparent)]
+    Entry(#[from] iter_from_counts::Error),
+    #[error(transparent)]
+    PackWrite(#[from] gix_pack::data::output::bytes::Error<iter_from_counts::Error>),
+}
diff --git a/gix-serve/src/refs.rs b/gix-serve/src/refs.rs
@@ -0,0 +1,36 @@
+use gix_ref::file::Store;
+
+use crate::{AdvertisableRef, Error};
+
+/// Collect all refs from a ref store for advertisement to clients.
+pub fn collect_refs(store: &Store) -> Result<Vec<AdvertisableRef>, Error> {
+    let mut ref_adverts = Vec::new();
+    let platform = store.iter()?;
+
+    for ref_res in platform.pseudo()?.chain(platform.all()?) {
+        let reference = ref_res?;
+        match reference.target {
+            gix_ref::Target::Object(object_id) => {
+                ref_adverts.push(AdvertisableRef {
+                    name: reference.name.as_bstr().to_owned(),
+                    object_id,
+                    peeled: reference.peeled,
+                    symref_target: None,
+                });
+            }
+            gix_ref::Target::Symbolic(target_name) => {
+                if let Some(resolved) = store.try_find(target_name.as_bstr())? {
+                    if let Some(oid) = resolved.target.try_id() {
+                        ref_adverts.push(AdvertisableRef {
+                            name: reference.name.as_bstr().to_owned(),
+                            object_id: oid.to_owned(),
+                            peeled: reference.peeled,
+                            symref_target: Some(target_name.as_bstr().to_owned()),
+                        });
+                    }
+                }
+            }
+        }
+    }
+    Ok(ref_adverts)
+}
diff --git a/gix-serve/src/serve.rs b/gix-serve/src/serve.rs
@@ -0,0 +1,70 @@
+use std::io::{self, Read, Write};
+
+use gix_hash::{oid, ObjectId};
+use gix_pack::Find;
+use gix_protocol::serve::{
+    upload_pack::{self, serve_upload_pack_v1, serve_upload_pack_v2},
+    RefAdvertisement,
+};
+use gix_ref::file::Store;
+use gix_transport::{server::blocking_io::connection::Connection, Protocol};
+
+use crate::{pack::generate_pack, refs::collect_refs, AdvertisableRef};
+
+impl AdvertisableRef {
+    /// Borrow as a `RefAdvertisement` for the protocol layer.
+    pub fn as_advertisement(&self) -> RefAdvertisement<'_> {
+        RefAdvertisement {
+            name: &self.name,
+            object_id: &self.object_id,
+            peeled: self.peeled.as_deref(),
+            symref_target: self.symref_target.as_ref().map(AsRef::as_ref),
+        }
+    }
+}
+
+/// Errors from serving upload-pack.
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum Error {
+    #[error(transparent)]
+    Refs(#[from] crate::Error),
+    #[error(transparent)]
+    Protocol(#[from] upload_pack::Error),
+    #[error(transparent)]
+    Pack(#[from] crate::pack::Error),
+}
+
+/// Serve an upload-pack session over a connection.
+pub fn serve_upload_pack<R: Read, W: Write, F: Find + Send + Clone + 'static>(
+    ref_store: &Store,
+    db: F,
+    connection: &mut Connection<R, W>,
+    protocol: Protocol,
+) -> Result<(), Error> {
+    let owned_refs = collect_refs(ref_store)?;
+    let refs: Vec<_> = owned_refs.iter().map(AdvertisableRef::as_advertisement).collect();
+
+    let has_object = |oid: &oid| db.contains(oid);
+
+    let generate_pack = |wants: &[ObjectId], haves: &[ObjectId], out: &mut dyn Write| {
+        generate_pack(db.clone(), wants, haves, out).map_err(io::Error::other)
+    };
+
+    match protocol {
+        Protocol::V1 | Protocol::V0 => {
+            serve_upload_pack_v1(connection, &refs, has_object, generate_pack, &[])?;
+        }
+        Protocol::V2 => {
+            serve_upload_pack_v2(
+                connection,
+                &refs,
+                has_object,
+                generate_pack,
+                &[("fetch", None), ("ls-refs", None)],
+            )?;
+        }
+    }
+
+    Ok(())
+}
diff --git a/gix-serve/tests/pack.rs b/gix-serve/tests/pack.rs
diff --git a/gix-serve/tests/refs.rs b/gix-serve/tests/refs.rs
diff --git a/gix-serve/tests/upload_pack.rs b/gix-serve/tests/upload_pack.rs
