GitLabgitlab-org
cli
main
1//go:build !integration
3package proxy
5import (
6 "crypto/tls"
7 "crypto/x509"
8 "encoding/base64"
9 "errors"
10 "fmt"
11 "io"
12 "log"
13 "net"
14 "net/http"
15 "net/http/httptest"
16 "net/url"
17 "sync"
18 "testing"
20 "github.com/stretchr/testify/assert"
21 "github.com/stretchr/testify/require"
23 "gitlab.com/gitlab-org/cli/internal/dependencyfirewall/policy"
24)
26// corporateProxy is a CONNECT-only forward proxy that requires basic auth, like
27// the outbound proxy in a network with no direct route to public registries.
28type corporateProxy struct {
29 server *httptest.Server
30 baseURL string
31 auth string
33 mu sync.Mutex
34 tunnels []string
35}
37func newCorporateProxy(user, password string) *corporateProxy {
38 cp := &corporateProxy{auth: "Basic " + base64.StdEncoding.EncodeToString([]byte(user+":"+password))}
39 cp.server = httptest.NewUnstartedServer(http.HandlerFunc(cp.handle))
40 return cp
41}
43func startCorporateProxy(t *testing.T, user, password string) *corporateProxy {
44 t.Helper()
45 cp := newCorporateProxy(user, password)
46 cp.server.Start()
47 t.Cleanup(cp.server.Close)
48 cp.baseURL = cp.server.URL
49 return cp
50}
52// startTLSCorporateProxy serves the proxy over TLS with a certificate from its
53// own CA, which it returns. httptest's built-in certificate is shared with the
54// upstream, so trusting the upstream would silently trust the proxy too. A
55// non-nil clientCAs makes the proxy require a client certificate they issued.
56func startTLSCorporateProxy(t *testing.T, user, password string, clientCAs *x509.CertPool) (*corporateProxy, *x509.Certificate) {
57 t.Helper()
58 ca, err := newCertAuthority()
59 require.NoError(t, err)
60 leaf, err := ca.leafFor("localhost")
61 require.NoError(t, err)
63 cp := newCorporateProxy(user, password)
64 cp.server.TLS = &tls.Config{Certificates: []tls.Certificate{*leaf}}
65 if clientCAs != nil {
66 cp.server.TLS.ClientAuth = tls.RequireAndVerifyClientCert
67 cp.server.TLS.ClientCAs = clientCAs
68 }
69 cp.server.Config.ErrorLog = log.New(io.Discard, "", 0)
70 cp.server.StartTLS()
71 t.Cleanup(cp.server.Close)
72 _, port, err := net.SplitHostPort(cp.server.Listener.Addr().String())
73 require.NoError(t, err)
74 cp.baseURL = "https://" + net.JoinHostPort("localhost", port)
75 return cp, ca.cert
76}
78func (cp *corporateProxy) handle(w http.ResponseWriter, r *http.Request) {
79 if r.Method != http.MethodConnect {
80 http.Error(w, "CONNECT only", http.StatusMethodNotAllowed)
81 return
82 }
83 if r.Header.Get("Proxy-Authorization") != cp.auth {
84 w.Header().Set("Proxy-Authenticate", `Basic realm="corporate"`)
85 w.WriteHeader(http.StatusProxyAuthRequired)
86 return
87 }
88 cp.mu.Lock()
89 cp.tunnels = append(cp.tunnels, r.Host)
90 cp.mu.Unlock()
92 hijacker, ok := w.(http.Hijacker)
93 if !ok {
94 http.Error(w, "hijack unsupported", http.StatusInternalServerError)
95 return
96 }
97 upstream, err := net.Dial("tcp", r.Host)
98 if err != nil {
99 http.Error(w, err.Error(), http.StatusBadGateway)
100 return
101 }
102 defer upstream.Close()
103 client, _, err := hijacker.Hijack()
104 if err != nil {
105 return
106 }
107 defer client.Close()
108 _, _ = client.Write([]byte("HTTP/1.1 200 Connection Established\r\n\r\n"))
110 done := make(chan struct{}, 2)
111 go func() { _, _ = io.Copy(upstream, client); done <- struct{}{} }()
112 go func() { _, _ = io.Copy(client, upstream); done <- struct{}{} }()
113 <-done
114}
116func (cp *corporateProxy) Tunnels() []string {
117 cp.mu.Lock()
118 defer cp.mu.Unlock()
119 return append([]string(nil), cp.tunnels...)
120}
122func (cp *corporateProxy) URL(t *testing.T, user, password string) *url.URL {
123 t.Helper()
124 u, err := url.Parse(cp.baseURL)
125 require.NoError(t, err)
126 u.User = url.UserPassword(user, password)
127 return u
128}
130func startProxyThrough(t *testing.T, upstream *httptest.Server, outbound *url.URL, extraRoots ...*x509.Certificate) *Proxy {
131 t.Helper()
132 return startProxyTrusting(t, append([]*x509.Certificate{upstream.Certificate()}, extraRoots...),
133 WithUpstreamProxy(http.ProxyURL(outbound)))
134}
136func startProxyTrusting(t *testing.T, roots []*x509.Certificate, opts ...Option) *Proxy {
137 t.Helper()
138 pool := x509.NewCertPool()
139 for _, c := range roots {
140 pool.AddCert(c)
141 }
142 p, err := New(stubMatcher{}, stubChecker{}, "group/proj", append([]Option{WithUpstreamRootCAs(pool)}, opts...)...)
143 require.NoError(t, err)
144 require.NoError(t, p.Start())
145 t.Cleanup(p.Stop)
146 return p
147}
149func TestProxyReachesUpstreamThroughOutboundProxy(t *testing.T) {
150 t.Parallel()
151 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
152 _, _ = io.WriteString(w, "TARBALL")
153 }))
154 defer upstream.Close()
155 corporate := startCorporateProxy(t, "corp", "secret")
157 p := startProxyThrough(t, upstream, corporate.URL(t, "corp", "secret"))
158 resp, err := newClient(t, p).Get(upstream.URL + "/left-pad/-/left-pad-1.3.0.tgz")
159 require.NoError(t, err)
160 defer resp.Body.Close()
161 body, err := io.ReadAll(resp.Body)
162 require.NoError(t, err)
164 assert.Equal(t, http.StatusOK, resp.StatusCode)
165 assert.Equal(t, "TARBALL", string(body))
166 assert.Equal(t, []string{upstream.Listener.Addr().String()}, corporate.Tunnels())
167}
169func TestProxyDoesNotFallBackToDirectWhenOutboundProxyRefuses(t *testing.T) {
170 t.Parallel()
171 var upstreamHits int
172 var mu sync.Mutex
173 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
174 mu.Lock()
175 upstreamHits++
176 mu.Unlock()
177 _, _ = io.WriteString(w, "TARBALL")
178 }))
179 defer upstream.Close()
180 corporate := startCorporateProxy(t, "corp", "secret")
182 p := startProxyThrough(t, upstream, corporate.URL(t, "corp", "wrong"))
183 resp, err := newClient(t, p).Get(upstream.URL + "/left-pad/-/left-pad-1.3.0.tgz")
184 if err == nil {
185 resp.Body.Close()
186 t.Fatalf("expected the request to fail when the outbound proxy refuses it, got status %d", resp.StatusCode)
187 }
189 mu.Lock()
190 defer mu.Unlock()
191 assert.Zero(t, upstreamHits)
192 assert.Empty(t, corporate.Tunnels())
193}
195func TestProxyReachesUpstreamThroughTrustedTLSOutboundProxy(t *testing.T) {
196 t.Parallel()
197 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
198 _, _ = io.WriteString(w, "TARBALL")
199 }))
200 defer upstream.Close()
201 corporate, corporateCA := startTLSCorporateProxy(t, "corp", "secret", nil)
203 p := startProxyThrough(t, upstream, corporate.URL(t, "corp", "secret"), corporateCA)
204 resp, err := newClient(t, p).Get(upstream.URL + "/left-pad/-/left-pad-1.3.0.tgz")
205 require.NoError(t, err)
206 defer resp.Body.Close()
207 body, err := io.ReadAll(resp.Body)
208 require.NoError(t, err)
210 assert.Equal(t, http.StatusOK, resp.StatusCode)
211 assert.Equal(t, "TARBALL", string(body))
212 assert.Equal(t, []string{upstream.Listener.Addr().String()}, corporate.Tunnels())
213}
215func TestProxyFailsWhenTLSOutboundProxyIsUntrusted(t *testing.T) {
216 t.Parallel()
217 var upstreamHits int
218 var mu sync.Mutex
219 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
220 mu.Lock()
221 upstreamHits++
222 mu.Unlock()
223 _, _ = io.WriteString(w, "TARBALL")
224 }))
225 defer upstream.Close()
226 corporate, _ := startTLSCorporateProxy(t, "corp", "secret", nil)
228 p := startProxyThrough(t, upstream, corporate.URL(t, "corp", "secret"))
229 resp, err := newClient(t, p).Get(upstream.URL + "/left-pad/-/left-pad-1.3.0.tgz")
230 if err == nil {
231 resp.Body.Close()
232 t.Fatalf("expected the request to fail when the outbound proxy's certificate is untrusted, got status %d", resp.StatusCode)
233 }
235 mu.Lock()
236 defer mu.Unlock()
237 assert.Zero(t, upstreamHits)
238 assert.Empty(t, corporate.Tunnels())
239}
241func TestProxyUsesEnvironmentOutboundProxyByDefault(t *testing.T) {
242 for _, k := range []string{"HTTPS_PROXY", "https_proxy"} {
243 t.Setenv(k, "http://egress.example:3128")
244 }
245 for _, k := range []string{"HTTP_PROXY", "http_proxy", "NO_PROXY", "no_proxy"} {
246 t.Setenv(k, "")
247 }
248 p, err := New(stubMatcher{}, stubChecker{}, "group/proj")
249 require.NoError(t, err)
251 for _, target := range []string{"https://registry.example/pkg", "http://registry.example/pkg"} {
252 got, err := p.upstream.Proxy(httptest.NewRequest(http.MethodGet, target, http.NoBody))
253 require.NoError(t, err)
254 require.NotNil(t, got, target)
255 assert.Equal(t, "http://egress.example:3128", got.String(), target)
256 }
257}
259type warningRecorder struct {
260 mu sync.Mutex
261 lines []string
262}
264func (w *warningRecorder) Logf(format string, a ...any) {
265 w.mu.Lock()
266 defer w.mu.Unlock()
267 w.lines = append(w.lines, fmt.Sprintf(format, a...))
268}
270func (w *warningRecorder) Lines() []string {
271 w.mu.Lock()
272 defer w.mu.Unlock()
273 return append([]string(nil), w.lines...)
274}
276func startWarningProxy(t *testing.T, outbound *url.URL, warn policy.Logf, upstreams ...*httptest.Server) *Proxy {
277 t.Helper()
278 pool := x509.NewCertPool()
279 for _, u := range upstreams {
280 pool.AddCert(u.Certificate())
281 }
282 p, err := New(stubMatcher{}, stubChecker{}, "group/proj",
283 WithUpstreamRootCAs(pool), WithUpstreamProxy(http.ProxyURL(outbound)), WithUpstreamFailureWarning(warn))
284 require.NoError(t, err)
285 require.NoError(t, p.Start())
286 t.Cleanup(p.Stop)
287 return p
288}
290func getExpectingFailure(t *testing.T, client *http.Client, rawURL string) {
291 t.Helper()
292 resp, err := client.Get(rawURL)
293 if err == nil {
294 resp.Body.Close()
295 t.Fatalf("expected the request to %s to fail, got status %d", rawURL, resp.StatusCode)
296 }
297}
299func TestProxyWarnsOncePerRegistryWhenUpstreamFails(t *testing.T) {
300 t.Parallel()
301 upstream := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
302 _, _ = io.WriteString(w, "TARBALL")
303 }))
304 defer upstream.Close()
305 corporate := startCorporateProxy(t, "corp-user", "right-password")
306 warnings := &warningRecorder{}
308 p := startWarningProxy(t, corporate.URL(t, "corp-user", "wrong-password"), warnings.Logf, upstream)
309 client := newClient(t, p)
310 getExpectingFailure(t, client, upstream.URL+"/left-pad/-/left-pad-1.3.0.tgz")
311 getExpectingFailure(t, client, upstream.URL+"/is-odd/-/is-odd-3.0.1.tgz")
313 lines := warnings.Lines()
314 require.Len(t, lines, 1, "repeated failures to one registry must warn once")
315 assert.Contains(t, lines[0], upstream.Listener.Addr().String())
316 assert.Contains(t, lines[0], "Proxy Authentication Required")
317 assert.NotContains(t, lines[0], "corp-user")
318 assert.NotContains(t, lines[0], "password")
319}
321func TestProxyWarnsForEachFailingRegistry(t *testing.T) {
322 t.Parallel()
323 handler := http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
324 _, _ = io.WriteString(w, "TARBALL")
325 })
326 first := httptest.NewTLSServer(handler)
327 defer first.Close()
328 second := httptest.NewTLSServer(handler)
329 defer second.Close()
330 corporate := startCorporateProxy(t, "corp-user", "right-password")
331 warnings := &warningRecorder{}
333 p := startWarningProxy(t, corporate.URL(t, "corp-user", "wrong-password"), warnings.Logf, first, second)
334 client := newClient(t, p)
335 getExpectingFailure(t, client, first.URL+"/left-pad/-/left-pad-1.3.0.tgz")
336 getExpectingFailure(t, client, second.URL+"/left-pad/-/left-pad-1.3.0.tgz")
337 getExpectingFailure(t, client, first.URL+"/is-odd/-/is-odd-3.0.1.tgz")
339 lines := warnings.Lines()
340 require.Len(t, lines, 2, "each failing registry must warn once")
341 assert.Contains(t, lines[0], first.Listener.Addr().String())
342 assert.Contains(t, lines[1], second.Listener.Addr().String())
343}
345func TestProxyDoesNotWarnWhenClientAbortsUpload(t *testing.T) {
346 t.Parallel()
347 arrived := make(chan struct{}, 1)
348 upstream := httptest.NewTLSServer(http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) {
349 arrived <- struct{}{}
350 _, _ = io.Copy(io.Discard, r.Body)
351 }))
352 defer upstream.Close()
353 corporate := startCorporateProxy(t, "corp-user", "right-password")
354 warnings := &warningRecorder{}
355 p := startWarningProxy(t, corporate.URL(t, "corp-user", "right-password"), warnings.Logf, upstream)
357 body, bodyWriter := io.Pipe()
358 req, err := http.NewRequestWithContext(t.Context(), http.MethodPut, upstream.URL+"/left-pad", body)
359 require.NoError(t, err)
360 req.ContentLength = 1 << 20
361 done := make(chan error, 1)
362 go func() {
363 resp, err := newClient(t, p).Do(req)
364 if err == nil {
365 resp.Body.Close()
366 }
367 done <- err
368 }()
369 _, err = bodyWriter.Write([]byte("partial upload"))
370 require.NoError(t, err)
371 <-arrived
372 bodyWriter.CloseWithError(errors.New("package manager aborted the upload"))
373 require.Error(t, <-done)
374 p.Stop()
376 assert.Empty(t, warnings.Lines(), "a request the package manager aborted is not a registry failure")
377}
379func TestProxyKeepsPlainHTTPDirectInCGI(t *testing.T) {
380 t.Setenv("REQUEST_METHOD", "GET")
381 for _, k := range []string{"HTTPS_PROXY", "https_proxy"} {
382 t.Setenv(k, "http://egress.example:3128")
383 }
384 for _, k := range []string{"HTTP_PROXY", "http_proxy", "NO_PROXY", "no_proxy"} {
385 t.Setenv(k, "")
386 }
387 p, err := New(stubMatcher{}, stubChecker{}, "group/proj")
388 require.NoError(t, err)
390 got, err := p.upstream.Proxy(httptest.NewRequest(http.MethodGet, "http://registry.example/pkg", http.NoBody))
392 require.NoError(t, err, "httpproxy refuses an HTTP_PROXY value in a CGI environment, so the fallback must not set one")
393 assert.Nil(t, got)
394}
396func TestProxyReadsUppercaseProxyVariablesFirst(t *testing.T) {
397 proxyFor := func(t *testing.T, p *Proxy, target string) string {
398 t.Helper()
399 got, err := p.upstream.Proxy(httptest.NewRequest(http.MethodGet, target, http.NoBody))
400 require.NoError(t, err)
401 if got == nil {
402 return ""
403 }
404 return got.String()
405 }
406 t.Setenv("REQUEST_METHOD", "")
407 t.Setenv("HTTPS_PROXY", "http://upper.example:3128")
408 t.Setenv("https_proxy", "http://lower.example:3128")
409 t.Setenv("NO_PROXY", "direct.example")
410 t.Setenv("no_proxy", "other.example")
412 t.Run("when HTTP_PROXY is unset", func(t *testing.T) {
413 t.Setenv("HTTP_PROXY", "")
414 t.Setenv("http_proxy", "")
415 p, err := New(stubMatcher{}, stubChecker{}, "group/proj")
416 require.NoError(t, err)
418 assert.Equal(t, "http://upper.example:3128", proxyFor(t, p, "https://registry.example/pkg"))
419 assert.Equal(t, "http://upper.example:3128", proxyFor(t, p, "http://registry.example/pkg"))
420 assert.Empty(t, proxyFor(t, p, "https://direct.example/pkg"), "NO_PROXY wins over no_proxy")
421 assert.Equal(t, "http://upper.example:3128", proxyFor(t, p, "https://other.example/pkg"), "no_proxy applies only when NO_PROXY is unset")
422 })
424 t.Run("when both spellings of HTTP_PROXY are set", func(t *testing.T) {
425 t.Setenv("HTTP_PROXY", "http://upper-http.example:3128")
426 t.Setenv("http_proxy", "http://lower-http.example:3128")
427 p, err := New(stubMatcher{}, stubChecker{}, "group/proj")
428 require.NoError(t, err)
430 assert.Equal(t, "http://upper-http.example:3128", proxyFor(t, p, "http://registry.example/pkg"))
431 })
432}
434func TestWithUpstreamProxyForOverridesOnlyItsScheme(t *testing.T) {
435 t.Parallel()
436 fixed := func(raw string) func(*http.Request) (*url.URL, error) {
437 return func(*http.Request) (*url.URL, error) { return url.Parse(raw) }
438 }
439 p, err := New(stubMatcher{}, stubChecker{}, "group/proj",
440 WithUpstreamProxy(fixed("http://default.example:3128")),
441 WithUpstreamProxyFor("http", fixed("http://plain.example:3128")),
442 )
443 require.NoError(t, err)
445 plain, err := p.upstream.Proxy(httptest.NewRequest(http.MethodGet, "http://registry.example/pkg", http.NoBody))
446 require.NoError(t, err)
447 assert.Equal(t, "http://plain.example:3128", plain.String())
449 secure, err := p.upstream.Proxy(httptest.NewRequest(http.MethodGet, "https://registry.example/pkg", http.NoBody))
450 require.NoError(t, err)
451 assert.Equal(t, "http://default.example:3128", secure.String())
452}
Diagnostics7 git calls · 37 ms
CallStatusSizeTime037 ms
discover200185 B2 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs 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 · hit2 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=2 git.response.bytes=59849 git.response.cache=HIT git.response.duration_ms=2 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 · hit2 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=2 git.response.bytes=32926 git.response.cache=HIT git.response.duration_ms=2 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=44Open pack map
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · 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=4273 git.response.cache=HIT git.response.duration_ms=3 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 · hit2 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=2 git.response.bytes=361 git.response.cache=HIT git.response.duration_ms=2 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=26d32585a3a474717e00a318584ccd16918c9d32Open 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=3 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=7503ef36a75d3595b473035c69e639fd0ce41598Open pack map
fetch2003.7 KiB · hit27 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=27 git.response.bytes=3775 git.response.cache=HIT git.response.duration_ms=27 git.fetch.wants=0a8f9c370ce943d8b3264d47ca619685aab4b7f6 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=3775 git.pkt.payload.max=3748 git.sideband.band1.bytes=3748 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
- a5e22c386d952a83
- Request
- 1330a699…
- 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