Sign in

Search issue titles and bodies, change requests and comments. Private repositories you cannot read are not included.

vole
Clone

Read only, no credentials:

https://rodent.software/git/vole.git

Write over SSH with a registered key:

git clone ssh://git@0.0.0.0:2222/vole.git

A free and open-source forge that lives in your Git repo.

Apply a push's index delta as the push lands, and check the ref by reading it

dced06da1bfc4a8e542e5d86d67888362077ed39 · Keenan Nemetz · 9d ago · parent 26c9be33

Apply a push's index delta as the push lands, and check the ref by reading it

A push's metadata delta used to be applied by the next reader, so the
first page after a big push paid for the whole push. And search checked
every visible repository before querying: a `symbolic-ref` to open it and
a `rev-parse` to see whether the metadata branch moved, so N repositories
cost 2N git processes per search.

- Post-receive now opens the index (the SSH server hands it `VOLE_INDEX_DB`
  and the repository id) and runs Ensure after the refs have moved, which
  is also after a followed request's head has moved. A failure is reported
  and ignored: the refs have landed, and the next read still repairs it.
- `git.Repo.RefCommit` resolves a branch ref by reading the loose ref file
  git writes for every branch update, and falls back to `rev-parse` for a
  packed ref, a symbolic ref, or a missing one. The index's Ensure and the
  web's metadata-head read use it.
- `repo.Store.Meta` builds a repository handle without a HEAD lookup, and
  search uses it: the refresh needs the directory and the ACL, not the
  default branch. The per-repository check is now two file reads instead
  of two processes.

Load harness, `search-find` at concurrency 4 over three repositories:
510.2 req/s and p50 7 ms before, 814.8 req/s and p50 4 ms after. A push
that changes the `vole` branch leaves the rows current before the push
returns; a test queries them with no Ensure in between.

core/git/refs_test.go +63

@@ -0,0 +1,63 @@
1 package git
2
3 // RefCommit exists to make the index's once-per-page check cheap, so its two
4 // answers matter equally: a loose ref must not start a process, and a ref the
5 // fast path cannot read must still get git's answer.
6
7 import (
8 "os"
9 "os/exec"
10 "path/filepath"
11 "strings"
12 "testing"
13 )
14
15 func TestRefCommitReadsALooseRefWithoutRunningGit(t *testing.T) {
16 dir := tagRepo(t)
17 r := open(t, dir)
18 trace := filepath.Join(t.TempDir(), "git.trace")
19 t.Setenv("GIT_TRACE", trace)
20
21 sha, err := r.RefCommit("refs/heads/main")
22 if err != nil || sha == "" {
23 t.Fatalf("RefCommit(loose) = %q, %v", sha, err)
24 }
25 if data, err := os.ReadFile(trace); err == nil && strings.Contains(string(data), "rev-parse") {
26 t.Fatalf("a loose ref started git:\n%s", data)
27 }
28
29 // After packing, the loose file is gone; the fallback must still answer the
30 // same commit, and this time it does run git.
31 cmd := exec.Command("git", "-C", dir, "pack-refs", "--all")
32 cmd.Env = append(os.Environ(), "GIT_CONFIG_GLOBAL=/dev/null", "GIT_CONFIG_SYSTEM=/dev/null")
33 if out, err := cmd.CombinedOutput(); err != nil {
34 t.Fatalf("pack-refs: %v: %s", err, out)
35 }
36 if _, err := os.Stat(filepath.Join(dir, ".git", "refs", "heads", "main")); !os.IsNotExist(err) {
37 t.Fatalf("pack-refs left the loose ref behind: %v", err)
38 }
39 packed, err := r.RefCommit("refs/heads/main")
40 if err != nil || packed != sha {
41 t.Fatalf("RefCommit(packed) = %q, %v; want %q", packed, err, sha)
42 }
43 data, err := os.ReadFile(trace)
44 if err != nil || !strings.Contains(string(data), "rev-parse") {
45 t.Fatalf("a packed ref did not fall back to git: %v\n%s", err, data)
46 }
47 }
48
49 func TestRefCommitFallsBackForARevisionItDoesNotRead(t *testing.T) {
50 r := open(t, tagRepo(t))
51 head, err := r.RefCommit("refs/heads/main")
52 if err != nil || head == "" {
53 t.Fatal(err)
54 }
55 // A branch that does not exist resolves to "", exactly like RevParse.
56 if sha, err := r.RefCommit("refs/heads/nope"); err != nil || sha != "" {
57 t.Fatalf("missing ref = %q, %v", sha, err)
58 }
59 // A revision that is not a branch name is git's business, not the file's.
60 if sha, err := r.RefCommit("main"); err != nil || sha != head {
61 t.Fatalf("RefCommit(main) = %q, %v; want %q", sha, err, head)
62 }
63 }