GitLabgitlab-org

cli

main
ply8 git calls364 ms102 KiB6 cachedprotocol v2
626 lines22 KiBRaw
1//go:build !integration
3package proxy
5import (
6 "bytes"
7 "compress/gzip"
8 "context"
9 "crypto/tls"
10 "crypto/x509"
11 "errors"
12 "io"
13 "net/http"
14 "net/http/httptest"
15 "net/url"
16 "strings"
17 "testing"
18 "time"
20 "github.com/stretchr/testify/assert"
21 "github.com/stretchr/testify/require"
23 "gitlab.com/gitlab-org/cli/internal/dependencyfirewall/policy"
24 "gitlab.com/gitlab-org/cli/internal/dependencyfirewall/verdict"
27type stubChecker struct {
28 result policy.Result
29 err error
32func (s stubChecker) Check(context.Context, policy.Request) (policy.Result, error) {
33 return s.result, s.err
36type stubMatcher struct{}
38func (stubMatcher) Match(req *http.Request) Match {
39 if req.Method == http.MethodGet && len(req.URL.Path) > 4 && req.URL.Path[len(req.URL.Path)-4:] == ".tgz" {
40 return Match{
41 Matched: true, Pass: true, Operation: policy.Download,
42 Coordinate: policy.Coordinate{Ecosystem: "npm", Name: "left-pad", Version: "1.3.0"},
43 }
44 }
45 return Match{}
48// uploadMatcher matches a PUT as an npm upload and reads+restores the body,
49// exercising the peek-and-restore path end to end.
50type uploadMatcher struct{}
52func (uploadMatcher) Match(req *http.Request) Match {
53 if req.Method != http.MethodPut {
54 return Match{}
55 }
56 original := req.Body
57 peek, _ := io.ReadAll(io.LimitReader(original, 1<<20))
58 req.Body = bodyWithPrefix(peek, original)
59 return Match{
60 Matched: true, Pass: true, Operation: policy.Upload,
61 Coordinate: policy.Coordinate{Ecosystem: "npm", Name: "left-pad", Version: "9.9.9"},
62 }
65func newClient(t *testing.T, p *Proxy) *http.Client {
66 t.Helper()
67 pool := x509.NewCertPool()
68 pool.AddCert(p.CACertificate())
69 proxyURL, _ := url.Parse("http://" + p.Addr())
70 return &http.Client{Transport: &http.Transport{
71 Proxy: http.ProxyURL(proxyURL),
72 // The proxy mints a MITM leaf for the 127.0.0.1 authority whose SAN is
73 // a DNS name, not an IP, so IP-literal verification against the CA pool
74 // cannot succeed. Trust the CA but skip hostname verification for the
75 // client -> proxy leg; upstream verification is still enforced via
76 // WithUpstreamRootCAs.
77 TLSClientConfig: &tls.Config{RootCAs: pool, MinVersion: tls.VersionTLS12, InsecureSkipVerify: true}, //nolint:gosec // test client trusts proxy's MITM leaf certs
78 }}
81func startProxy(t *testing.T, upstream *httptest.Server, checker policy.Checker) *Proxy {
82 t.Helper()
83 return startProxyWithMatcher(t, upstream, stubMatcher{}, checker)
86func startProxyWithMatcher(t *testing.T, upstream *httptest.Server, matcher Matcher, checker policy.Checker) *Proxy {
87 t.Helper()
88 pool := x509.NewCertPool()
89 pool.AddCert(upstream.Certificate())
90 p, err := New(matcher, checker, "group/proj", WithUpstreamRootCAs(pool))
91 require.NoError(t, err)
92 require.NoError(t, p.Start())
93 t.Cleanup(p.Stop)
94 return p
97func TestProxyAllowInjectsAllowedHeaderAndProxies(t *testing.T) {
98 t.Parallel()
99 var gotHeader string
100 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
101 gotHeader = r.Header.Get("X-Gitlab-Dependency-Firewall")
102 _, _ = io.WriteString(w, "TARBALL")
103 }))
104 defer upstream.Close()
106 p := startProxy(t, upstream, stubChecker{})
107 client := newClient(t, p)
109 resp, err := client.Get(upstream.URL + "/left-pad/-/left-pad-1.3.0.tgz")
110 require.NoError(t, err)
111 defer resp.Body.Close()
112 body, _ := io.ReadAll(resp.Body)
113 assert.Equal(t, "TARBALL", string(body))
114 assert.Equal(t, "allowed", gotHeader)
117func TestProxyPassThroughInjectsAllowed(t *testing.T) {
118 t.Parallel()
119 var gotHeader string
120 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
121 gotHeader = r.Header.Get("X-Gitlab-Dependency-Firewall")
122 _, _ = io.WriteString(w, "META")
123 }))
124 defer upstream.Close()
126 p := startProxy(t, upstream, stubChecker{})
127 client := newClient(t, p)
129 resp, err := client.Get(upstream.URL + "/left-pad")
130 require.NoError(t, err)
131 defer resp.Body.Close()
132 assert.Equal(t, "allowed", gotHeader)
135func TestProxyBlockReturns403AndSkipsUpstream(t *testing.T) {
136 t.Parallel()
137 upstreamHit := false
138 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
139 upstreamHit = true
140 }))
141 defer upstream.Close()
143 p := startProxy(t, upstream, stubChecker{result: policy.Result{Verdict: verdict.Blocked, Reason: "nope"}})
144 client := newClient(t, p)
146 resp, err := client.Get(upstream.URL + "/left-pad/-/left-pad-1.3.0.tgz")
147 require.NoError(t, err)
148 defer resp.Body.Close()
149 assert.Equal(t, http.StatusForbidden, resp.StatusCode)
150 assert.Equal(t, "blocked", resp.Header.Get("X-Gitlab-Dependency-Firewall"))
151 assert.False(t, upstreamHit, "upstream must not be contacted on block")
153 verdicts := p.Verdicts()
154 require.Len(t, verdicts, 1)
155 assert.Equal(t, verdict.Blocked, verdicts[0].Verdict)
158func TestProxyFailsClosedOnCheckerError(t *testing.T) {
159 t.Parallel()
160 upstreamHit := false
161 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
162 upstreamHit = true
163 }))
164 defer upstream.Close()
166 p := startProxy(t, upstream, stubChecker{err: errors.New("api down")})
167 client := newClient(t, p)
169 resp, err := client.Get(upstream.URL + "/left-pad/-/left-pad-1.3.0.tgz")
170 require.NoError(t, err)
171 defer resp.Body.Close()
172 assert.Equal(t, http.StatusForbidden, resp.StatusCode, "checker error must fail closed")
173 assert.Equal(t, "blocked", resp.Header.Get("X-Gitlab-Dependency-Firewall"))
174 assert.False(t, upstreamHit, "upstream must not be contacted when the checker errors")
176 verdicts := p.Verdicts()
177 require.Len(t, verdicts, 1)
178 assert.Equal(t, verdict.Blocked, verdicts[0].Verdict)
179 assert.Contains(t, verdicts[0].Reason, "policy check failed")
182func TestProxyWarningRecordsAndPassesThrough(t *testing.T) {
183 t.Parallel()
184 var gotHeader string
185 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
186 gotHeader = r.Header.Get("X-Gitlab-Dependency-Firewall")
187 _, _ = io.WriteString(w, "TARBALL")
188 }))
189 defer upstream.Close()
191 p := startProxy(t, upstream, stubChecker{result: policy.Result{Verdict: verdict.Warning, Reason: "risky"}})
192 client := newClient(t, p)
194 resp, err := client.Get(upstream.URL + "/left-pad/-/left-pad-1.3.0.tgz")
195 require.NoError(t, err)
196 defer resp.Body.Close()
197 body, _ := io.ReadAll(resp.Body)
198 assert.Equal(t, "TARBALL", string(body), "a warning still proxies the artifact")
199 assert.Equal(t, "allowed", gotHeader)
201 verdicts := p.Verdicts()
202 require.Len(t, verdicts, 1)
203 assert.Equal(t, verdict.Warning, verdicts[0].Verdict)
204 assert.Zero(t, verdicts[0].Status, "a warning's status is unknown before the upstream round trip and must be left unset")
207// TestProxyBlockedUploadWithLargeBodyReadsResponse proves the client still
208// reads the synthesized 403 when it is streaming a sizable request body: the
209// proxy drains the unread body after writing the block so the client's write
210// completes and its response read does not hit a connection reset.
211func TestProxyBlockedUploadWithLargeBodyReadsResponse(t *testing.T) {
212 t.Parallel()
213 upstreamHit := false
214 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
215 upstreamHit = true
216 }))
217 defer upstream.Close()
219 p := startProxyWithMatcher(t, upstream, blockMatcher{}, stubChecker{err: errors.New("must not be called")})
220 client := newClient(t, p)
222 body := strings.Repeat("a", 512<<10) // 512 KiB, within blockDrainLimit
223 req, err := http.NewRequest(http.MethodPut, upstream.URL+"/left-pad", strings.NewReader(body))
224 require.NoError(t, err)
225 resp, err := client.Do(req)
226 require.NoError(t, err)
227 defer resp.Body.Close()
229 assert.Equal(t, http.StatusForbidden, resp.StatusCode)
230 respBody, err := io.ReadAll(resp.Body)
231 require.NoError(t, err, "client must be able to read the block body")
232 assert.NotEmpty(t, respBody)
233 assert.False(t, upstreamHit, "upstream must not be contacted on a fail-closed block")
236func TestProxyUploadBodyReachesUpstreamIntact(t *testing.T) {
237 t.Parallel()
238 const payload = `{"name":"left-pad","versions":{"9.9.9":{}}}`
239 var gotBody, gotHeader string
240 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
241 gotHeader = r.Header.Get("X-Gitlab-Dependency-Firewall")
242 b, _ := io.ReadAll(r.Body)
243 gotBody = string(b)
244 w.WriteHeader(http.StatusCreated)
245 }))
246 defer upstream.Close()
248 p := startProxyWithMatcher(t, upstream, uploadMatcher{}, stubChecker{})
249 client := newClient(t, p)
251 req, err := http.NewRequest(http.MethodPut, upstream.URL+"/left-pad", strings.NewReader(payload))
252 require.NoError(t, err)
253 resp, err := client.Do(req)
254 require.NoError(t, err)
255 defer resp.Body.Close()
257 assert.Equal(t, http.StatusCreated, resp.StatusCode)
258 assert.JSONEq(t, payload, gotBody, "the peeked upload body must reach upstream intact")
259 assert.Equal(t, "allowed", gotHeader)
262// TestProxyForwardsGzippedBody verifies the proxy transparently forwards a
263// gzip-encoded response body to the client. Restored baseline coverage
264// (previously TestProxyForwardsGzippedBody) adapted to the tunnel model.
265func TestProxyForwardsGzippedBody(t *testing.T) {
266 t.Parallel()
267 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
268 var buf bytes.Buffer
269 gz := gzip.NewWriter(&buf)
270 _, _ = gz.Write([]byte(`{"warning":"license review required"}`))
271 assert.NoError(t, gz.Close())
272 w.Header().Set("Content-Encoding", "gzip")
273 w.Header().Set("Content-Type", "application/json")
274 w.WriteHeader(http.StatusOK)
275 _, _ = w.Write(buf.Bytes())
276 }))
277 defer upstream.Close()
279 p := startProxy(t, upstream, stubChecker{})
280 client := newClient(t, p)
282 resp, err := client.Get(upstream.URL + "/left-pad")
283 require.NoError(t, err)
284 defer resp.Body.Close()
285 assert.Equal(t, http.StatusOK, resp.StatusCode)
286 body, err := io.ReadAll(resp.Body)
287 require.NoError(t, err)
288 assert.Contains(t, string(body), "license review required")
291// TestProxyPreservesUndecompressedContentEncoding guards against the proxy
292// stripping Content-Encoding for a payload the client transport did not
293// transparently decode. Restored baseline coverage.
294func TestProxyPreservesUndecompressedContentEncoding(t *testing.T) {
295 t.Parallel()
296 payload := []byte("opaque-non-gzip-bytes")
297 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
298 w.Header().Set("Content-Encoding", "br") // brotli — Transport does not auto-decompress
299 w.Header().Set("Content-Type", "application/json")
300 w.WriteHeader(http.StatusOK)
301 _, _ = w.Write(payload)
302 }))
303 defer upstream.Close()
305 p := startProxy(t, upstream, stubChecker{})
306 client := newClient(t, p)
307 tr, ok := client.Transport.(*http.Transport)
308 require.True(t, ok)
309 tr.DisableCompression = true
311 resp, err := client.Get(upstream.URL + "/left-pad")
312 require.NoError(t, err)
313 defer resp.Body.Close()
314 body, err := io.ReadAll(resp.Body)
315 require.NoError(t, err)
317 assert.Equal(t, "br", resp.Header.Get("Content-Encoding"),
318 "proxy must not strip Content-Encoding when it did not decompress the body")
319 assert.Equal(t, payload, body, "body must reach the client unchanged (still encoded)")
322// TestProxyStreamsTarballByteIdentical verifies a large binary download is
323// forwarded byte-identical through the tunnel. Restored baseline coverage.
324func TestProxyStreamsTarballByteIdentical(t *testing.T) {
325 t.Parallel()
326 payload := bytes.Repeat([]byte("x"), 3<<20) // 3 MiB tarball
327 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
328 w.Header().Set("Content-Type", "application/octet-stream")
329 w.WriteHeader(http.StatusOK)
330 _, _ = w.Write(payload)
331 }))
332 defer upstream.Close()
334 p := startProxy(t, upstream, stubChecker{})
335 client := newClient(t, p)
337 resp, err := client.Get(upstream.URL + "/left-pad/-/left-pad-1.3.0.tgz")
338 require.NoError(t, err)
339 defer resp.Body.Close()
340 assert.Equal(t, http.StatusOK, resp.StatusCode)
341 body, err := io.ReadAll(resp.Body)
342 require.NoError(t, err)
343 assert.Equal(t, payload, body, "tarball must be forwarded byte-identical")
346// TestProxyRejectsUntrustedUpstreamByDefault ensures the proxy verifies the
347// upstream registry's certificate. Without WithUpstreamRootCAs, an
348// httptest.Server's self-signed cert must not be accepted: this is the
349// regression guard against InsecureSkipVerify sneaking back into the
350// upstream leg. Restored baseline coverage.
351func TestProxyRejectsUntrustedUpstreamByDefault(t *testing.T) {
352 t.Parallel()
353 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
354 w.WriteHeader(http.StatusOK)
355 }))
356 defer upstream.Close()
358 p, err := New(stubMatcher{}, stubChecker{}, "group/proj")
359 require.NoError(t, err)
360 require.NoError(t, p.Start())
361 t.Cleanup(p.Stop)
363 client := newClient(t, p)
364 resp, err := client.Get(upstream.URL + "/left-pad/-/left-pad-1.3.0.tgz")
365 if err == nil {
366 resp.Body.Close()
367 t.Fatalf("expected request to fail because upstream cert is untrusted, got status %d", resp.StatusCode)
368 }
371// blockMatcher simulates a matcher that recognized an in-scope upload it
372// could not inspect (e.g. an over-limit body) and must fail closed.
373type blockMatcher struct{}
375func (blockMatcher) Match(*http.Request) Match {
376 return Match{
377 Matched: true,
378 Operation: policy.Upload,
379 Coordinate: policy.Coordinate{Ecosystem: "npm"},
380 Reason: "upload body too large to inspect for dependency firewall policy",
381 }
384// TestProxyBlockMatchFailsClosedWithoutChecker verifies a matched request
385// that leaves Pass false is rejected with 403 without contacting upstream or
386// the policy checker.
387func TestProxyBlockMatchFailsClosedWithoutChecker(t *testing.T) {
388 t.Parallel()
389 upstreamHit := false
390 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
391 upstreamHit = true
392 }))
393 defer upstream.Close()
395 // A checker that would panic if consulted, proving a non-Pass match
396 // short-circuits it.
397 p := startProxyWithMatcher(t, upstream, blockMatcher{}, stubChecker{err: errors.New("must not be called")})
398 client := newClient(t, p)
400 req, err := http.NewRequest(http.MethodPut, upstream.URL+"/left-pad", strings.NewReader("payload"))
401 require.NoError(t, err)
402 resp, err := client.Do(req)
403 require.NoError(t, err)
404 defer resp.Body.Close()
406 assert.Equal(t, http.StatusForbidden, resp.StatusCode)
407 assert.False(t, upstreamHit, "upstream must not be contacted on a fail-closed block")
409 verdicts := p.Verdicts()
410 require.Len(t, verdicts, 1)
411 assert.Equal(t, verdict.Blocked, verdicts[0].Verdict)
414func startNoticeProxy(t *testing.T, checker policy.Checker) (*http.Client, *warningRecorder, string) {
415 t.Helper()
416 upstream := httptest.NewTLSServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}))
417 t.Cleanup(upstream.Close)
418 pool := x509.NewCertPool()
419 pool.AddCert(upstream.Certificate())
420 notices := &warningRecorder{}
421 p, err := New(stubMatcher{}, checker, "group/proj", WithUpstreamRootCAs(pool), WithBlockNotice(notices.Logf))
422 require.NoError(t, err)
423 require.NoError(t, p.Start())
424 t.Cleanup(p.Stop)
425 return newClient(t, p), notices, upstream.URL + "/left-pad/-/left-pad-1.3.0.tgz"
428func TestProxyBlockNoticeNamesPackageOncePerBlock(t *testing.T) {
429 t.Parallel()
430 reason := "Package 'left-pad' violates 'No pads' policy"
431 client, notices, target := startNoticeProxy(t, stubChecker{result: policy.Result{Verdict: verdict.Blocked, Reason: reason}})
433 for range 2 {
434 resp, err := client.Get(target)
435 require.NoError(t, err)
436 resp.Body.Close()
437 assert.Equal(t, "403 Blocked by GitLab Dependency Firewall: "+reason, resp.Status)
438 }
440 lines := notices.Lines()
441 require.Len(t, lines, 1, "a package blocked twice is reported once")
442 assert.Equal(t, "dependency firewall blocked left-pad 1.3.0: "+reason+
443 ". The summary at the end of this command lists every blocked package.\n", lines[0])
446func TestProxyBlockNoticeWithoutReason(t *testing.T) {
447 t.Parallel()
448 client, notices, target := startNoticeProxy(t, stubChecker{result: policy.Result{Verdict: verdict.Blocked}})
450 resp, err := client.Get(target)
451 require.NoError(t, err)
452 resp.Body.Close()
454 lines := notices.Lines()
455 require.Len(t, lines, 1)
456 assert.Equal(t, "dependency firewall blocked left-pad 1.3.0. "+
457 "The summary at the end of this command lists every blocked package.\n", lines[0])
460func TestProxyBlockNoticeStaysOnOneLine(t *testing.T) {
461 t.Parallel()
462 reason := "nope\r\nfake: line\x1b[31m red."
463 client, notices, target := startNoticeProxy(t, stubChecker{result: policy.Result{Verdict: verdict.Blocked, Reason: reason}})
465 resp, err := client.Get(target)
466 require.NoError(t, err)
467 resp.Body.Close()
469 lines := notices.Lines()
470 require.Len(t, lines, 1)
471 assert.Equal(t, "dependency firewall blocked left-pad 1.3.0: nope fake: line red. "+
472 "The summary at the end of this command lists every blocked package.\n", lines[0])
475func TestProxyFailedCheckKeepsErrorOutOfResponseAndNotice(t *testing.T) {
476 t.Parallel()
477 const apiErr = "GET https://gitlab.example/api/v4/projects/9/x: 500 {host=10.0.0.5}"
478 tests := []struct {
479 name string
480 checker stubChecker
481 }{
482 {"cached check failure", stubChecker{result: policy.Result{Verdict: verdict.Blocked, Reason: "policy check failed: " + apiErr, CheckFailed: true}}},
483 {"checker error", stubChecker{err: errors.New(apiErr)}},
484 }
485 for _, tc := range tests {
486 t.Run(tc.name, func(t *testing.T) {
487 t.Parallel()
488 client, notices, target := startNoticeProxy(t, tc.checker)
490 resp, err := client.Get(target)
491 require.NoError(t, err)
492 body, err := io.ReadAll(resp.Body)
493 require.NoError(t, err)
494 resp.Body.Close()
496 assert.Equal(t, http.StatusForbidden, resp.StatusCode)
497 assert.Equal(t, "403 Dependency Firewall could not evaluate this package", resp.Status)
498 assert.Contains(t, string(body), "Dependency Firewall could not evaluate this package")
499 assert.NotContains(t, string(body), "gitlab.example")
500 assert.Empty(t, notices.Lines(), "a failed check prints no notice")
501 })
502 }
505func TestProxyNoBlockNoticeForWarning(t *testing.T) {
506 t.Parallel()
507 client, notices, target := startNoticeProxy(t, stubChecker{result: policy.Result{Verdict: verdict.Warning, Reason: "old"}})
509 resp, err := client.Get(target)
510 require.NoError(t, err)
511 resp.Body.Close()
513 assert.Empty(t, notices.Lines())
516func TestProxyBlockNoticeForUninspectableRequest(t *testing.T) {
517 t.Parallel()
518 upstream := httptest.NewTLSServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}))
519 t.Cleanup(upstream.Close)
520 pool := x509.NewCertPool()
521 pool.AddCert(upstream.Certificate())
522 notices := &warningRecorder{}
523 p, err := New(blockMatcher{}, stubChecker{err: errors.New("must not be called")}, "group/proj",
524 WithUpstreamRootCAs(pool), WithBlockNotice(notices.Logf))
525 require.NoError(t, err)
526 require.NoError(t, p.Start())
527 t.Cleanup(p.Stop)
529 req, err := http.NewRequest(http.MethodPut, upstream.URL+"/left-pad", strings.NewReader("payload"))
530 require.NoError(t, err)
531 resp, err := newClient(t, p).Do(req)
532 require.NoError(t, err)
533 resp.Body.Close()
535 assert.Equal(t, "403 Blocked by GitLab Dependency Firewall: upload body too large to inspect for dependency firewall policy", resp.Status)
536 assert.Equal(t, []string{"dependency firewall blocked: upload body too large to inspect for dependency firewall policy. " +
537 "The summary at the end of this command lists every blocked package.\n"}, notices.Lines())
540// deadlineChecker records whether Check received a context with a deadline.
541type deadlineChecker struct{ sawDeadline chan bool }
543func (d deadlineChecker) Check(ctx context.Context, _ policy.Request) (policy.Result, error) {
544 _, ok := ctx.Deadline()
545 select {
546 case d.sawDeadline <- ok:
547 default:
548 }
549 return policy.Result{}, nil
552// TestProxyPolicyCheckHasDeadline verifies the proxy bounds each policy check
553// with a context deadline, so a hung backend can't block the tunnel forever.
554func TestProxyPolicyCheckHasDeadline(t *testing.T) {
555 t.Parallel()
556 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
557 _, _ = io.WriteString(w, "TARBALL")
558 }))
559 defer upstream.Close()
561 checker := deadlineChecker{sawDeadline: make(chan bool, 1)}
562 p := startProxy(t, upstream, checker)
563 client := newClient(t, p)
565 resp, err := client.Get(upstream.URL + "/left-pad/-/left-pad-1.3.0.tgz")
566 require.NoError(t, err)
567 resp.Body.Close()
569 select {
570 case ok := <-checker.sawDeadline:
571 assert.True(t, ok, "proxy must pass a context with a deadline to the policy checker")
572 default:
573 t.Fatal("policy checker was not invoked")
574 }
577// slowChecker signals when a check starts, then delays before returning its
578// result, modeling a policy decision still in flight when the child exits.
579type slowChecker struct {
580 started chan struct{}
581 delay time.Duration
582 result policy.Result
585func (s *slowChecker) Check(context.Context, policy.Request) (policy.Result, error) {
586 close(s.started)
587 time.Sleep(s.delay)
588 return s.result, nil
591// TestProxyStopDrainsInflightTunnelBeforeVerdicts verifies Stop waits for an
592// in-flight MITM tunnel to finish recording before returning, so a verdict
593// produced after the child exits is not lost. http.Server.Shutdown does not
594// wait for hijacked connections, so without the tunnel drain the Verdicts()
595// snapshot taken right after Stop would miss a late Block.
596func TestProxyStopDrainsInflightTunnelBeforeVerdicts(t *testing.T) {
597 t.Parallel()
598 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
599 _, _ = io.WriteString(w, "TARBALL")
600 }))
601 defer upstream.Close()
603 checker := &slowChecker{
604 started: make(chan struct{}),
605 delay: 150 * time.Millisecond,
606 result: policy.Result{Verdict: verdict.Blocked, Reason: "late block"},
607 }
608 p := startProxy(t, upstream, checker)
609 client := newClient(t, p)
611 go func() {
612 resp, err := client.Get(upstream.URL + "/left-pad/-/left-pad-1.3.0.tgz")
613 if err == nil {
614 resp.Body.Close()
615 }
616 }()
618 // Wait until the check is in flight, then stop the proxy. Stop must block
619 // until the tunnel finishes recording the verdict.
620 <-checker.started
621 p.Stop()
623 verdicts := p.Verdicts()
624 require.Len(t, verdicts, 1, "Stop must drain the in-flight tunnel so its verdict is not lost")
625 assert.Equal(t, verdict.Blocked, verdicts[0].Verdict)
Diagnostics8 git calls · 364 ms
CallStatusSizeTime0364 ms
discover200185 B3 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=185
git.server.agent=git/2.56.g1891de4-Linux
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch server-option object-format
git.server.fetch=shallow wait-for-done filter
git.protocol.version=2
git.pkt.frames=9
git.pkt.data=7
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=185
git.pkt.payload.max=35
ls-refs20058 KiB · hit3 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=3
git.response.bytes=59849
git.response.cache=HIT
git.response.duration_ms=3
git.protocol.version=2
git.pkt.frames=731
git.pkt.data=730
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=59849
git.pkt.payload.max=143
git.ls_refs.count=730
git.ls_refs.head=refs/heads/main
fetchtree:0 · deepen 1020032 KiB · hit4 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=4
git.response.bytes=32926
git.response.cache=HIT
git.response.duration_ms=4
git.fetch.filter=tree:0
git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9
git.fetch.haves.count=0
git.fetch.deepen=10
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=22
git.pkt.data=20
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=32926
git.pkt.payload.max=32046
git.sideband.band1.bytes=32046
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=80
git.pack.bytes=32046
git.pack.ofs_delta=36
git.pack.ref_delta=0
git.pack.chain.max=2
git.pack.trailer=cb0bad5d7ffc514895d8b21c4dd470327f90bc91
git.pack.full=44
Open pack map
fetchtree:0 · deepen 1200706 B · hit23 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=4
git.response.bytes=706
git.response.cache=HIT
git.response.duration_ms=23
git.fetch.filter=tree:0
git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9
git.fetch.haves.count=0
git.fetch.deepen=1
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=7
git.pkt.data=5
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=706
git.pkt.payload.max=606
git.sideband.band1.bytes=606
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=606
git.pack.trailer=5b8940d8a309b9f86f08953120610ba63124325e
Open pack map
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · hit24 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=4273
git.response.cache=HIT
git.response.duration_ms=24
git.fetch.filter=combine:blob:none+tree:2
git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9
git.fetch.haves.count=0
git.fetch.deepen=1
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=7
git.pkt.data=5
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=4273
git.pkt.payload.max=4173
git.sideband.band1.bytes=4173
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=11
git.pack.bytes=4173
git.fetch.wide.objects=11
git.fetch.wide.extra_bytes=3930
git.fetch.wide.blobs=0
fetchtree:0200361 B · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=361
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=506cba622ceda1473ee3cde63969809c144b7247
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=361
git.pkt.payload.max=334
git.sideband.band1.bytes=334
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=334
git.pack.trailer=26d32585a3a474717e00a318584ccd16918c9d32
Open pack map
fetchtree:02001.0 KiB · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=331
git.response.bytes=1051
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=7a2a90605315ba5b37f63c08726e6b2caa26e48d
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=1051
git.pkt.payload.max=1024
git.sideband.band1.bytes=1024
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=1024
git.pack.trailer=7503ef36a75d3595b473035c69e639fd0ce41598
Open pack map
fetch2005.0 KiB331 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=5143
git.response.cache=MISS
git.response.duration_ms=331
git.fetch.wants=e5a5a5123c3c501c658b3a580ecc445efa87e98d
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=5143
git.pkt.payload.max=5116
git.sideband.band1.bytes=5116
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0

Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.

Remote
https://gitlab.com/gitlab-org/cli
Ref
refs/heads/main
Commit
0dd7574dce9e385c5c30540e6c15657adc6bdce9
cf-ray
a5ea3bebf932b87b
Request
68e165a4…
Protocol
v2 · sha1
Agent
git/2.56.g1891de4-Linux
Filter
advertised
Fetch
shallow wait-for-done filter
Capabilities
agent ls-refs fetch server-option object-format