BlueGit

timfa bluegit

Merge branch 'cursor/gzip-smart-http-674d' into 'master'

timfa

Authored 2026-10-23 · 3 weeks ago

Hash
02f57a92e33a23c0c0c2ba32ab377891e8ff628a
Pipeline
Warning
3 files changed +229 −0
internal/gitrepo/http.go +27 −0
@@ -32,6 +32,15 @@ func ServeSmartHTTP(w http.ResponseWriter, r *http.Request, gitBin, projectRoot,
32 32 if r.ContentLength >= 0 {
33 33 cmd.Env = append(cmd.Env, "CONTENT_LENGTH="+strconv.FormatInt(r.ContentLength, 10))
34 34 }
35 // Git comprimeert een smart-HTTP-POST met gzip zodra die groter is dan
36 // 1024 bytes en zet dan Content-Encoding: gzip. http-backend pakt de
37 // body alleen uit als de CGI-variabele HTTP_CONTENT_ENCODING gezet is.
38 // Zonder die variabele leest hij de gzip-bytes als pkt-lines en komt er
39 // een lege 200 terug. CONTENT_LENGTH blijft de gecomprimeerde lengte:
40 // daar leest inflate_request precies zoveel bytes van.
41 if enc := gzipContentEncoding(r.Header.Get("Content-Encoding")); enc != "" {
42 cmd.Env = append(cmd.Env, "HTTP_CONTENT_ENCODING="+enc)
43 }
35 44 cmd.Env = append(cmd.Env, extraEnv...)
36 45 cmd.Stdin = r.Body
37 46 stdout, err := cmd.StdoutPipe()
@@ -75,6 +84,24 @@ func ServeSmartHTTP(w http.ResponseWriter, r *http.Request, gitBin, projectRoot,
75 84 return nil
76 85 }
77 86
87 // gzipContentEncoding is de waarde voor HTTP_CONTENT_ENCODING.
88 // git http-backend herkent alleen "gzip" en "x-gzip", hoofdlettergevoelig.
89 func gzipContentEncoding(v string) string {
90 v = strings.TrimSpace(v)
91 if v == "" {
92 return ""
93 }
94 if i := strings.IndexByte(v, ','); i >= 0 {
95 v = strings.TrimSpace(v[:i])
96 }
97 switch strings.ToLower(v) {
98 case "gzip", "x-gzip":
99 return strings.ToLower(v)
100 default:
101 return ""
102 }
103 }
104
78 105 // ProjectRoot is de map waarin owner/naam.git staat.
79 106 func ProjectRoot(storage string) string {
80 107 return storage + "/repos"
@@ -32,6 +32,15 @@ func ServeSmartHTTP(w http.ResponseWriter, r *http.Request, gitBin, projectRoot,
32 if r.ContentLength >= 0 {
32 if r.ContentLength >= 0 {
33 cmd.Env = append(cmd.Env, "CONTENT_LENGTH="+strconv.FormatInt(r.ContentLength, 10))
33 cmd.Env = append(cmd.Env, "CONTENT_LENGTH="+strconv.FormatInt(r.ContentLength, 10))
34 }
34 }
35 // Git comprimeert een smart-HTTP-POST met gzip zodra die groter is dan
36 // 1024 bytes en zet dan Content-Encoding: gzip. http-backend pakt de
37 // body alleen uit als de CGI-variabele HTTP_CONTENT_ENCODING gezet is.
38 // Zonder die variabele leest hij de gzip-bytes als pkt-lines en komt er
39 // een lege 200 terug. CONTENT_LENGTH blijft de gecomprimeerde lengte:
40 // daar leest inflate_request precies zoveel bytes van.
41 if enc := gzipContentEncoding(r.Header.Get("Content-Encoding")); enc != "" {
42 cmd.Env = append(cmd.Env, "HTTP_CONTENT_ENCODING="+enc)
43 }
35 cmd.Env = append(cmd.Env, extraEnv...)
44 cmd.Env = append(cmd.Env, extraEnv...)
36 cmd.Stdin = r.Body
45 cmd.Stdin = r.Body
37 stdout, err := cmd.StdoutPipe()
46 stdout, err := cmd.StdoutPipe()
@@ -75,6 +84,24 @@ func ServeSmartHTTP(w http.ResponseWriter, r *http.Request, gitBin, projectRoot,
75 return nil
84 return nil
76}
85}
77
86
87// gzipContentEncoding is de waarde voor HTTP_CONTENT_ENCODING.
88// git http-backend herkent alleen "gzip" en "x-gzip", hoofdlettergevoelig.
89func gzipContentEncoding(v string) string {
90 v = strings.TrimSpace(v)
91 if v == "" {
92 return ""
93 }
94 if i := strings.IndexByte(v, ','); i >= 0 {
95 v = strings.TrimSpace(v[:i])
96 }
97 switch strings.ToLower(v) {
98 case "gzip", "x-gzip":
99 return strings.ToLower(v)
100 default:
101 return ""
102 }
103}
104
78// ProjectRoot is de map waarin owner/naam.git staat.
105// ProjectRoot is de map waarin owner/naam.git staat.
79func ProjectRoot(storage string) string {
106func ProjectRoot(storage string) string {
80 return storage + "/repos"
107 return storage + "/repos"
internal/gitrepo/http_test.go added +21 −0
@@ -0,0 +1,21 @@
1 package gitrepo
2
3 import "testing"
4
5 func TestGzipContentEncoding(t *testing.T) {
6 cases := []struct{ in, want string }{
7 {"", ""},
8 {"identity", ""},
9 {"deflate", ""},
10 {"gzip", "gzip"},
11 {"GZIP", "gzip"},
12 {"x-gzip", "x-gzip"},
13 {"gzip, deflate", "gzip"},
14 {" gzip ", "gzip"},
15 }
16 for _, tc := range cases {
17 if got := gzipContentEncoding(tc.in); got != tc.want {
18 t.Errorf("%q: %q, verwacht %q", tc.in, got, tc.want)
19 }
20 }
21 }
@@ -0,0 +1,21 @@
1package gitrepo
2
3import "testing"
4
5func TestGzipContentEncoding(t *testing.T) {
6 cases := []struct{ in, want string }{
7 {"", ""},
8 {"identity", ""},
9 {"deflate", ""},
10 {"gzip", "gzip"},
11 {"GZIP", "gzip"},
12 {"x-gzip", "x-gzip"},
13 {"gzip, deflate", "gzip"},
14 {" gzip ", "gzip"},
15 }
16 for _, tc := range cases {
17 if got := gzipContentEncoding(tc.in); got != tc.want {
18 t.Errorf("%q: %q, verwacht %q", tc.in, got, tc.want)
19 }
20 }
21}
internal/server/git_http_test.go added +181 −0
@@ -0,0 +1,181 @@
1 package server
2
3 import (
4 "bytes"
5 "compress/gzip"
6 "crypto/rand"
7 "encoding/base64"
8 "fmt"
9 "io"
10 "net/http"
11 "net/http/cookiejar"
12 "net/http/httptest"
13 "net/url"
14 "os"
15 "os/exec"
16 "path/filepath"
17 "strings"
18 "testing"
19
20 "gitlab.com/Timfa/bluegit/internal/auth"
21 "gitlab.com/Timfa/bluegit/internal/config"
22 "gitlab.com/Timfa/bluegit/internal/gitrepo"
23 "gitlab.com/Timfa/bluegit/internal/store"
24 )
25
26 func TestGzipSmartHTTP(t *testing.T) {
27 if why := gitHTTPGap(); why != "" {
28 t.Skip(why)
29 }
30 storage := t.TempDir()
31 st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
32 if err != nil {
33 t.Fatal(err)
34 }
35 t.Cleanup(func() { _ = st.Close() })
36 cfg := config.Config{
37 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
38 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
39 Git: config.Git{Binary: "git", DefaultBranch: "master"},
40 }
41 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
42 ts := httptest.NewServer(srv.Handler())
43 t.Cleanup(ts.Close)
44
45 jar, _ := cookiejar.New(nil)
46 client := &http.Client{Jar: jar}
47 res, err := client.Get(ts.URL + "/login")
48 if err != nil {
49 t.Fatal(err)
50 }
51 page := read(t, res)
52 res, err = client.PostForm(ts.URL+"/new/repo", url.Values{
53 "csrf": {csrfOf(t, page)}, "name": {"pakket"}, "visibility": {"public"},
54 })
55 if err != nil {
56 t.Fatal(err)
57 }
58 page = read(t, res)
59 res, err = client.PostForm(ts.URL+"/settings/tokens", url.Values{
60 "csrf": {csrfOf(t, page)}, "name": {"laptop"},
61 })
62 if err != nil {
63 t.Fatal(err)
64 }
65 token := between(read(t, res), `<p class="code">`, "</p>")
66 if !strings.HasPrefix(token, "bg_") {
67 t.Fatal("geen token")
68 }
69
70 bare := gitrepo.Dir(storage, "tim", "pakket")
71 work := t.TempDir()
72 gitPrep(t, work)
73 writeFile(t, filepath.Join(work, "leesmij.txt"), "hallo\n")
74 git(t, work, "add", "leesmij.txt")
75 git(t, work, "commit", "-m", "leesmij")
76 git(t, work, "remote", "add", "origin", bare)
77 git(t, work, "push", "origin", "master")
78 sha := revHEAD(t, work)
79
80 raw := uploadPackRequest(sha)
81 var compressed bytes.Buffer
82 zw := gzip.NewWriter(&compressed)
83 if _, err := zw.Write(raw); err != nil {
84 t.Fatal(err)
85 }
86 if err := zw.Close(); err != nil {
87 t.Fatal(err)
88 }
89 req, err := http.NewRequest(http.MethodPost, ts.URL+"/tim/pakket.git/git-upload-pack", bytes.NewReader(compressed.Bytes()))
90 if err != nil {
91 t.Fatal(err)
92 }
93 req.Header.Set("Content-Type", "application/x-git-upload-pack-request")
94 req.Header.Set("Accept", "application/x-git-upload-pack-result")
95 req.Header.Set("Content-Encoding", "gzip")
96 res, err = http.DefaultClient.Do(req)
97 if err != nil {
98 t.Fatal(err)
99 }
100 body, err := io.ReadAll(res.Body)
101 res.Body.Close()
102 if err != nil {
103 t.Fatal(err)
104 }
105 if res.StatusCode != http.StatusOK || len(body) == 0 || (!bytes.Contains(body, []byte("NAK")) && !bytes.Contains(body, []byte("PACK"))) {
106 t.Fatalf("gzip-POST: status %d, %d bytes, begin %q", res.StatusCode, len(body), body[:min(80, len(body))])
107 }
108
109 blob := make([]byte, 4096)
110 if _, err := rand.Read(blob); err != nil {
111 t.Fatal(err)
112 }
113 if err := os.WriteFile(filepath.Join(work, "groot.bin"), blob, 0o644); err != nil {
114 t.Fatal(err)
115 }
116 git(t, work, "add", "groot.bin")
117 git(t, work, "commit", "-m", "groot bestand")
118 remote := ts.URL + "/tim/pakket.git"
119 git(t, work, "remote", "set-url", "origin", remote)
120 auth := "Authorization: Basic " + base64.StdEncoding.EncodeToString([]byte("git:"+token))
121 // git push over protocol v1 zet zelf geen Content-Encoding. De aanroep
122 // laat http.postBuffer op de standaard staan: een grote body mag niet
123 // blijven hangen.
124 gitTrace(t, work, auth, "push", "origin", "master")
125
126 for i := 0; i < 40; i++ {
127 git(t, work, "branch", fmt.Sprintf("tak-%02d", i))
128 }
129 gitTrace(t, work, auth, "push", "origin", "--all")
130
131 // Clone vraagt elke branch. Dat verzoek is groter dan 1024 bytes, dus
132 // git stuurt Content-Encoding: gzip. Zonder uitpakken is de clone leeg.
133 clone := t.TempDir()
134 fetchTrace := gitTrace(t, clone, auth, "clone", remote, "kopie")
135 if !strings.Contains(fetchTrace, "Content-Encoding: gzip") {
136 t.Fatalf("git fetch/clone stuurde geen gzip:\n%s", redactTrace(fetchTrace))
137 }
138 if _, err := os.Stat(filepath.Join(clone, "kopie", "groot.bin")); err != nil {
139 t.Fatal(err)
140 }
141 }
142
143 func uploadPackRequest(sha string) []byte {
144 want := fmt.Sprintf("want %s multi_ack_detailed no-done side-band-64k ofs-delta\n", sha)
145 done := "done\n"
146 pkt := func(s string) []byte {
147 return []byte(fmt.Sprintf("%04x%s", len(s)+4, s))
148 }
149 var raw []byte
150 raw = append(raw, pkt(want)...)
151 raw = append(raw, []byte("0000")...)
152 raw = append(raw, pkt(done)...)
153 return raw
154 }
155
156 func gitTrace(t *testing.T, dir, auth string, args ...string) string {
157 t.Helper()
158 if why := gitHTTPGap(); why != "" {
159 t.Skip(why)
160 }
161 cmd := exec.Command("git", append([]string{"-c", "http.extraHeader=" + auth}, args...)...)
162 cmd.Dir = dir
163 cmd.Env = append(os.Environ(), "GIT_CURL_VERBOSE=1", "GIT_TERMINAL_PROMPT=0")
164 out, err := cmd.CombinedOutput()
165 if err != nil {
166 t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, redactTrace(string(out)))
167 }
168 return string(out)
169 }
170
171 func redactTrace(s string) string {
172 var b strings.Builder
173 for _, line := range strings.Split(s, "\n") {
174 if strings.Contains(line, "Authorization:") || strings.Contains(line, "bg_") {
175 continue
176 }
177 b.WriteString(line)
178 b.WriteByte('\n')
179 }
180 return b.String()
181 }
@@ -0,0 +1,181 @@
1package server
2
3import (
4 "bytes"
5 "compress/gzip"
6 "crypto/rand"
7 "encoding/base64"
8 "fmt"
9 "io"
10 "net/http"
11 "net/http/cookiejar"
12 "net/http/httptest"
13 "net/url"
14 "os"
15 "os/exec"
16 "path/filepath"
17 "strings"
18 "testing"
19
20 "gitlab.com/Timfa/bluegit/internal/auth"
21 "gitlab.com/Timfa/bluegit/internal/config"
22 "gitlab.com/Timfa/bluegit/internal/gitrepo"
23 "gitlab.com/Timfa/bluegit/internal/store"
24)
25
26func TestGzipSmartHTTP(t *testing.T) {
27 if why := gitHTTPGap(); why != "" {
28 t.Skip(why)
29 }
30 storage := t.TempDir()
31 st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
32 if err != nil {
33 t.Fatal(err)
34 }
35 t.Cleanup(func() { _ = st.Close() })
36 cfg := config.Config{
37 BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
38 Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
39 Git: config.Git{Binary: "git", DefaultBranch: "master"},
40 }
41 srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
42 ts := httptest.NewServer(srv.Handler())
43 t.Cleanup(ts.Close)
44
45 jar, _ := cookiejar.New(nil)
46 client := &http.Client{Jar: jar}
47 res, err := client.Get(ts.URL + "/login")
48 if err != nil {
49 t.Fatal(err)
50 }
51 page := read(t, res)
52 res, err = client.PostForm(ts.URL+"/new/repo", url.Values{
53 "csrf": {csrfOf(t, page)}, "name": {"pakket"}, "visibility": {"public"},
54 })
55 if err != nil {
56 t.Fatal(err)
57 }
58 page = read(t, res)
59 res, err = client.PostForm(ts.URL+"/settings/tokens", url.Values{
60 "csrf": {csrfOf(t, page)}, "name": {"laptop"},
61 })
62 if err != nil {
63 t.Fatal(err)
64 }
65 token := between(read(t, res), `<p class="code">`, "</p>")
66 if !strings.HasPrefix(token, "bg_") {
67 t.Fatal("geen token")
68 }
69
70 bare := gitrepo.Dir(storage, "tim", "pakket")
71 work := t.TempDir()
72 gitPrep(t, work)
73 writeFile(t, filepath.Join(work, "leesmij.txt"), "hallo\n")
74 git(t, work, "add", "leesmij.txt")
75 git(t, work, "commit", "-m", "leesmij")
76 git(t, work, "remote", "add", "origin", bare)
77 git(t, work, "push", "origin", "master")
78 sha := revHEAD(t, work)
79
80 raw := uploadPackRequest(sha)
81 var compressed bytes.Buffer
82 zw := gzip.NewWriter(&compressed)
83 if _, err := zw.Write(raw); err != nil {
84 t.Fatal(err)
85 }
86 if err := zw.Close(); err != nil {
87 t.Fatal(err)
88 }
89 req, err := http.NewRequest(http.MethodPost, ts.URL+"/tim/pakket.git/git-upload-pack", bytes.NewReader(compressed.Bytes()))
90 if err != nil {
91 t.Fatal(err)
92 }
93 req.Header.Set("Content-Type", "application/x-git-upload-pack-request")
94 req.Header.Set("Accept", "application/x-git-upload-pack-result")
95 req.Header.Set("Content-Encoding", "gzip")
96 res, err = http.DefaultClient.Do(req)
97 if err != nil {
98 t.Fatal(err)
99 }
100 body, err := io.ReadAll(res.Body)
101 res.Body.Close()
102 if err != nil {
103 t.Fatal(err)
104 }
105 if res.StatusCode != http.StatusOK || len(body) == 0 || (!bytes.Contains(body, []byte("NAK")) && !bytes.Contains(body, []byte("PACK"))) {
106 t.Fatalf("gzip-POST: status %d, %d bytes, begin %q", res.StatusCode, len(body), body[:min(80, len(body))])
107 }
108
109 blob := make([]byte, 4096)
110 if _, err := rand.Read(blob); err != nil {
111 t.Fatal(err)
112 }
113 if err := os.WriteFile(filepath.Join(work, "groot.bin"), blob, 0o644); err != nil {
114 t.Fatal(err)
115 }
116 git(t, work, "add", "groot.bin")
117 git(t, work, "commit", "-m", "groot bestand")
118 remote := ts.URL + "/tim/pakket.git"
119 git(t, work, "remote", "set-url", "origin", remote)
120 auth := "Authorization: Basic " + base64.StdEncoding.EncodeToString([]byte("git:"+token))
121 // git push over protocol v1 zet zelf geen Content-Encoding. De aanroep
122 // laat http.postBuffer op de standaard staan: een grote body mag niet
123 // blijven hangen.
124 gitTrace(t, work, auth, "push", "origin", "master")
125
126 for i := 0; i < 40; i++ {
127 git(t, work, "branch", fmt.Sprintf("tak-%02d", i))
128 }
129 gitTrace(t, work, auth, "push", "origin", "--all")
130
131 // Clone vraagt elke branch. Dat verzoek is groter dan 1024 bytes, dus
132 // git stuurt Content-Encoding: gzip. Zonder uitpakken is de clone leeg.
133 clone := t.TempDir()
134 fetchTrace := gitTrace(t, clone, auth, "clone", remote, "kopie")
135 if !strings.Contains(fetchTrace, "Content-Encoding: gzip") {
136 t.Fatalf("git fetch/clone stuurde geen gzip:\n%s", redactTrace(fetchTrace))
137 }
138 if _, err := os.Stat(filepath.Join(clone, "kopie", "groot.bin")); err != nil {
139 t.Fatal(err)
140 }
141}
142
143func uploadPackRequest(sha string) []byte {
144 want := fmt.Sprintf("want %s multi_ack_detailed no-done side-band-64k ofs-delta\n", sha)
145 done := "done\n"
146 pkt := func(s string) []byte {
147 return []byte(fmt.Sprintf("%04x%s", len(s)+4, s))
148 }
149 var raw []byte
150 raw = append(raw, pkt(want)...)
151 raw = append(raw, []byte("0000")...)
152 raw = append(raw, pkt(done)...)
153 return raw
154}
155
156func gitTrace(t *testing.T, dir, auth string, args ...string) string {
157 t.Helper()
158 if why := gitHTTPGap(); why != "" {
159 t.Skip(why)
160 }
161 cmd := exec.Command("git", append([]string{"-c", "http.extraHeader=" + auth}, args...)...)
162 cmd.Dir = dir
163 cmd.Env = append(os.Environ(), "GIT_CURL_VERBOSE=1", "GIT_TERMINAL_PROMPT=0")
164 out, err := cmd.CombinedOutput()
165 if err != nil {
166 t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, redactTrace(string(out)))
167 }
168 return string(out)
169}
170
171func redactTrace(s string) string {
172 var b strings.Builder
173 for _, line := range strings.Split(s, "\n") {
174 if strings.Contains(line, "Authorization:") || strings.Contains(line, "bg_") {
175 continue
176 }
177 b.WriteString(line)
178 b.WriteByte('\n')
179 }
180 return b.String()
181}