GitLabgitlab-org

cli

main
ply6 git calls227 ms99 KiB3 cachedprotocol v2
573 lines18 KiBRaw
1//go:build !integration
3package binarymgr
5import (
6 "context"
7 "crypto/sha256"
8 "encoding/hex"
9 "net/http"
10 "os"
11 "path/filepath"
12 "strings"
13 "testing"
14 "time"
16 "github.com/hashicorp/go-retryablehttp"
17 "github.com/stretchr/testify/assert"
18 "github.com/stretchr/testify/require"
19 "go.uber.org/mock/gomock"
21 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
22 gitlabtesting "gitlab.com/gitlab-org/api/client-go/v3/testing"
24 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
27// noMorePages returns a response that signals gitlab.ScanAndCollect to stop.
28func noMorePages() *gitlab.Response {
29 return &gitlab.Response{NextPage: 0}
32// testSpec is a minimal Spec used by manager-level tests. The binaries
33// package covers the full specs.
34func testSpec() Spec {
35 return Spec{
36 DisplayName: "Test CLI",
37 ProjectID: "12345",
38 PackageName: "test-cli",
39 Command: "test cli",
40 ConfigPrefix: "test_cli",
41 EnvVarPrefix: "GLAB_TEST_CLI",
42 MaxCompatibleMajor: 8,
43 SupportedOS: []string{"darwin", "linux", "windows"},
44 NormalizeArch: func(goos, goarch string) (string, error) {
45 if goarch == "amd64" {
46 return "x64", nil
47 }
48 return goarch, nil
49 },
50 AssetName: func(os, arch string) string { return "test-" + os + "-" + arch },
51 InstalledName: func(os string) string { return "test" },
52 }
55func TestTestSpec_NormalizeArch(t *testing.T) {
56 t.Parallel()
58 for arch, want := range map[string]string{
59 "amd64": "x64",
60 "arm64": "arm64",
61 "s390x": "s390x",
62 "ppc64le": "ppc64le",
63 "riscv64": "riscv64",
64 } {
65 t.Run(arch, func(t *testing.T) {
66 t.Parallel()
67 got, err := testSpec().NormalizeArch("linux", arch)
68 require.NoError(t, err)
69 assert.Equal(t, want, got)
70 })
71 }
74func TestManager_isBinaryValid(t *testing.T) {
75 t.Parallel()
77 tests := []struct {
78 name string
79 setupFile func(t *testing.T) string
80 want bool
81 }{
82 {
83 name: "valid executable file",
84 setupFile: func(t *testing.T) string {
85 t.Helper()
86 p := filepath.Join(t.TempDir(), "bin")
87 require.NoError(t, os.WriteFile(p, []byte("fake binary"), 0o755))
88 return p
89 },
90 want: true,
91 },
92 {
93 name: "non-executable file",
94 setupFile: func(t *testing.T) string {
95 t.Helper()
96 p := filepath.Join(t.TempDir(), "bin")
97 require.NoError(t, os.WriteFile(p, []byte("fake binary"), 0o644))
98 return p
99 },
100 want: false,
101 },
102 {
103 name: "non-existent file",
104 setupFile: func(t *testing.T) string {
105 t.Helper()
106 return "/nonexistent/bin"
107 },
108 want: false,
109 },
110 }
112 for _, tc := range tests {
113 t.Run(tc.name, func(t *testing.T) {
114 t.Parallel()
116 assert.Equal(t, tc.want, isBinaryValid(tc.setupFile(t)))
117 })
118 }
121func TestManager_verifyChecksum(t *testing.T) {
122 t.Parallel()
124 tmpDir := t.TempDir()
125 testFile := filepath.Join(tmpDir, "test.bin")
126 testContent := []byte("test content for checksum")
127 require.NoError(t, os.WriteFile(testFile, testContent, 0o644))
129 hash := sha256.New()
130 hash.Write(testContent)
131 expected := hex.EncodeToString(hash.Sum(nil))
133 tests := []struct {
134 name string
135 filePath string
136 expectedChecksum string
137 wantsErr bool
138 wantsStderr string
139 }{
140 {"valid checksum", testFile, expected, false, "Checksum verified"},
141 {"invalid checksum", testFile, "invalid_checksum", true, ""},
142 {"empty checksum (skipped)", testFile, "", false, "No checksum available, skipping verification"},
143 {"non-existent file", "/nonexistent/file", expected, true, ""},
144 }
146 for _, tc := range tests {
147 t.Run(tc.name, func(t *testing.T) {
148 t.Parallel()
150 ios, _, stdout, stderr := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
151 m := NewManager(ios, testSpec())
152 err := m.verifyChecksum(tc.filePath, tc.expectedChecksum)
153 assert.Empty(t, stdout.String())
154 if tc.wantsStderr != "" {
155 assert.Contains(t, stderr.String(), tc.wantsStderr)
156 } else {
157 assert.Empty(t, stderr.String())
158 }
159 if tc.wantsErr {
160 require.Error(t, err)
161 } else {
162 require.NoError(t, err)
163 }
164 })
165 }
168func TestManager_verifyChecksum_RequireChecksum(t *testing.T) {
169 t.Parallel()
171 tmpDir := t.TempDir()
172 testFile := filepath.Join(tmpDir, "test.bin")
173 testContent := []byte("test content for checksum")
174 require.NoError(t, os.WriteFile(testFile, testContent, 0o644))
176 hash := sha256.New()
177 hash.Write(testContent)
178 expected := hex.EncodeToString(hash.Sum(nil))
180 tests := []struct {
181 name string
182 expectedChecksum string
183 wantsErr bool
184 errContains string
185 }{
186 {"empty checksum is fatal when required", "", true, "no checksum available"},
187 {"valid checksum still passes when required", expected, false, ""},
188 {"mismatched checksum still fails when required", "deadbeef", true, "checksum verification failed"},
189 }
191 for _, tc := range tests {
192 t.Run(tc.name, func(t *testing.T) {
193 t.Parallel()
195 spec := testSpec()
196 spec.RequireChecksum = true
197 ios, _, _, _ := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
198 m := NewManager(ios, spec)
199 err := m.verifyChecksum(testFile, tc.expectedChecksum)
200 if tc.wantsErr {
201 require.Error(t, err)
202 assert.ErrorContains(t, err, tc.errContains)
203 } else {
204 require.NoError(t, err)
205 }
206 })
207 }
210func TestManager_CheckForUpdate(t *testing.T) {
211 t.Parallel()
213 tests := []struct {
214 name string
215 latestVersion string
216 currentVersion string
217 spec Spec
218 wantHasUpdate bool
219 wantLatestVersion string
220 wantNewMajorVersion string
221 }{
222 {
223 name: "compatible major, newer version available",
224 latestVersion: "8.5.0",
225 currentVersion: "8.0.0",
226 spec: testSpec(),
227 wantHasUpdate: true,
228 wantLatestVersion: "8.5.0",
229 },
230 {
231 name: "compatible major, already up to date",
232 latestVersion: "8.5.0",
233 currentVersion: "8.5.0",
234 spec: testSpec(),
235 wantHasUpdate: false,
236 wantLatestVersion: "8.5.0",
237 },
238 {
239 name: "incompatible major, update blocked",
240 latestVersion: "9.0.0",
241 currentVersion: "8.5.0",
242 spec: testSpec(),
243 wantHasUpdate: false,
244 wantNewMajorVersion: "9.0.0",
245 },
246 {
247 name: "no major cap, newer major still treated as available",
248 latestVersion: "9.0.0",
249 currentVersion: "8.5.0",
250 spec: func() Spec {
251 s := testSpec()
252 s.MaxCompatibleMajor = 0
253 return s
254 }(),
255 wantHasUpdate: true,
256 wantLatestVersion: "9.0.0",
257 },
258 }
260 for _, tc := range tests {
261 t.Run(tc.name, func(t *testing.T) {
262 t.Parallel()
264 testClient := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://gitlab.com"))
265 testClient.MockPackages.EXPECT().
266 ListProjectPackages(tc.spec.ProjectID, gomock.Any(), gomock.Any(), gomock.Any()).
267 Return([]*gitlab.Package{{ID: 1, Version: tc.latestVersion}}, noMorePages(), nil)
269 ios, _, _, _ := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
270 m := &Manager{io: ios, spec: tc.spec, client: testClient.Client}
272 check, err := m.CheckForUpdate(t.Context(), tc.currentVersion, time.Time{}, true)
273 require.NoError(t, err)
274 assert.Equal(t, tc.wantHasUpdate, check.HasUpdate)
275 assert.Equal(t, tc.wantLatestVersion, check.LatestVersion)
276 assert.Equal(t, tc.wantNewMajorVersion, check.NewMajorVersion)
277 })
278 }
281func TestManager_fetchLatestPackage(t *testing.T) {
282 t.Parallel()
284 tests := []struct {
285 name string
286 packages []*gitlab.Package
287 wantVersion string
288 wantErr string
289 }{
290 {
291 name: "picks highest semver, not lexicographic (created_at order)",
292 // Order the API returns with OrderBy=created_at,Sort=desc: most
293 // recent first. 8.100.0 is the newest release and the highest
294 // semver — lexicographically it sorts below 8.99.0.
295 packages: []*gitlab.Package{
296 {ID: 1, Version: "8.100.0"},
297 {ID: 2, Version: "8.99.0"},
298 {ID: 3, Version: "8.98.0"},
299 },
300 wantVersion: "8.100.0",
301 },
302 {
303 name: "picks highest semver regardless of position",
304 // Simulates a hotfix released after a higher minor: 8.99.1 is
305 // most recent (position 0) but 8.100.0 is the higher semver.
306 packages: []*gitlab.Package{
307 {ID: 1, Version: "8.99.1"},
308 {ID: 2, Version: "8.100.0"},
309 {ID: 3, Version: "8.99.0"},
310 },
311 wantVersion: "8.100.0",
312 },
313 {
314 name: "skips unparseable versions",
315 packages: []*gitlab.Package{
316 {ID: 1, Version: "latest"},
317 {ID: 2, Version: "8.100.0"},
318 {ID: 3, Version: "not-a-version"},
319 },
320 wantVersion: "8.100.0",
321 },
322 {
323 name: "errors when registry is empty",
324 packages: []*gitlab.Package{},
325 wantErr: "no packages found",
326 },
327 {
328 name: "errors when no version parses",
329 packages: []*gitlab.Package{
330 {ID: 1, Version: "latest"},
331 {ID: 2, Version: "snapshot"},
332 },
333 wantErr: "no packages with parseable versions found",
334 },
335 }
337 for _, tc := range tests {
338 t.Run(tc.name, func(t *testing.T) {
339 t.Parallel()
341 spec := testSpec()
342 testClient := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://gitlab.com"))
343 testClient.MockPackages.EXPECT().
344 ListProjectPackages(spec.ProjectID, gomock.Any(), gomock.Any(), gomock.Any()).
345 Return(tc.packages, noMorePages(), nil)
347 ios, _, _, _ := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
348 m := &Manager{io: ios, spec: spec, client: testClient.Client}
350 pkg, err := m.fetchLatestPackage(t.Context())
351 if tc.wantErr != "" {
352 require.Error(t, err)
353 assert.Contains(t, err.Error(), tc.wantErr)
354 return
355 }
356 require.NoError(t, err)
357 assert.Equal(t, tc.wantVersion, pkg.Version)
358 })
359 }
362func TestManager_fetchLatestPackage_paginates(t *testing.T) {
363 t.Parallel()
365 // Verify gitlab.ScanAndCollect walks pages: the highest semver lives on
366 // page 2, so a single-page scan would miss it and return the wrong value.
367 spec := testSpec()
368 testClient := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://gitlab.com"))
370 page1 := []*gitlab.Package{
371 {ID: 1, Version: "8.99.1"},
372 {ID: 2, Version: "8.99.0"},
373 }
374 page2 := []*gitlab.Package{
375 {ID: 3, Version: "8.100.0"},
376 {ID: 4, Version: "8.98.0"},
377 }
379 gomock.InOrder(
380 testClient.MockPackages.EXPECT().
381 ListProjectPackages(spec.ProjectID, gomock.Any(), gomock.Any(), gomock.Any()).
382 Return(page1, &gitlab.Response{NextPage: 2}, nil),
383 testClient.MockPackages.EXPECT().
384 ListProjectPackages(spec.ProjectID, gomock.Any(), gomock.Any(), gomock.Any()).
385 Return(page2, noMorePages(), nil),
386 )
388 ios, _, _, _ := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
389 m := &Manager{io: ios, spec: spec, client: testClient.Client}
391 pkg, err := m.fetchLatestPackage(t.Context())
392 require.NoError(t, err)
393 assert.Equal(t, "8.100.0", pkg.Version)
396func TestManager_fetchPackageAsset_majorVersionBlocked(t *testing.T) {
397 t.Parallel()
399 spec := testSpec()
400 testClient := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://gitlab.com"))
401 testClient.MockPackages.EXPECT().
402 ListProjectPackages(spec.ProjectID, gomock.Any(), gomock.Any(), gomock.Any()).
403 Return([]*gitlab.Package{{ID: 1, Version: "9.0.0"}}, noMorePages(), nil)
405 ios, _, _, _ := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
406 m := &Manager{io: ios, spec: spec, client: testClient.Client}
408 _, err := m.fetchPackageAsset(t.Context(), Platform{OS: "linux", Arch: "x64"})
409 require.Error(t, err)
410 assert.Contains(t, err.Error(), "requires a newer glab")
413func TestManager_validateBinaryPath(t *testing.T) {
414 t.Parallel()
416 spec := testSpec()
418 t.Run("non-existent path", func(t *testing.T) {
419 t.Parallel()
420 err := validateBinaryPath("/nonexistent/path", spec)
421 require.Error(t, err)
422 // Error must name both configuration sources and start with a
423 // lowercase word so fang's leading-token title-casing does not
424 // mangle the env-var name.
425 assert.Contains(t, err.Error(), "GLAB_TEST_CLI_BINARY_PATH")
426 assert.Contains(t, err.Error(), "test_cli_binary_path")
427 assert.Contains(t, err.Error(), "was not found")
428 assert.Truef(t, strings.HasPrefix(err.Error(), "custom"), "error should start with lowercase to survive fang title-casing, got %q", err.Error())
429 })
431 t.Run("directory rejected", func(t *testing.T) {
432 t.Parallel()
433 err := validateBinaryPath(t.TempDir(), spec)
434 require.Error(t, err)
435 assert.Contains(t, err.Error(), "is a directory")
436 })
438 t.Run("non-executable file rejected (unix)", func(t *testing.T) {
439 t.Parallel()
440 f := filepath.Join(t.TempDir(), "bin")
441 require.NoError(t, os.WriteFile(f, []byte("#!/bin/sh\n"), 0o644))
442 err := validateBinaryPath(f, spec)
443 require.Error(t, err)
444 assert.Contains(t, err.Error(), "not executable")
445 assert.Contains(t, err.Error(), "chmod +x")
446 })
448 t.Run("executable file accepted", func(t *testing.T) {
449 t.Parallel()
450 f := filepath.Join(t.TempDir(), "bin")
451 require.NoError(t, os.WriteFile(f, []byte("#!/bin/sh\n"), 0o755))
452 require.NoError(t, validateBinaryPath(f, spec))
453 })
456func requestDeadline(t *testing.T, options []gitlab.RequestOptionFunc) (time.Time, bool) {
457 t.Helper()
458 req, err := retryablehttp.NewRequest(http.MethodGet, "https://gitlab.com", nil)
459 require.NoError(t, err)
460 for _, option := range options {
461 if option == nil {
462 continue
463 }
464 require.NoError(t, option(req))
465 }
466 return req.Context().Deadline()
469func TestManager_registryLookups_haveDeadline(t *testing.T) {
470 t.Parallel()
472 assertDeadline := func(t *testing.T, options []gitlab.RequestOptionFunc) {
473 t.Helper()
474 deadline, ok := requestDeadline(t, options)
475 require.True(t, ok, "registry lookup must carry a deadline")
476 assert.WithinDuration(t, time.Now().Add(registryLookupTimeout), deadline, 2*time.Second)
477 }
479 t.Run("CheckForUpdate", func(t *testing.T) {
480 t.Parallel()
481 spec := testSpec()
482 testClient := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://gitlab.com"))
483 testClient.MockPackages.EXPECT().
484 ListProjectPackages(spec.ProjectID, gomock.Any(), gomock.Any(), gomock.Any()).
485 DoAndReturn(func(_ any, _ *gitlab.ListProjectPackagesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Package, *gitlab.Response, error) {
486 assertDeadline(t, options)
487 return []*gitlab.Package{{ID: 1, Version: "8.0.0"}}, noMorePages(), nil
488 })
489 ios, _, _, _ := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
490 m := &Manager{io: ios, spec: spec, client: testClient.Client}
492 _, err := m.CheckForUpdate(t.Context(), "8.0.0", time.Time{}, true)
493 require.NoError(t, err)
494 })
496 t.Run("fetchPackageAsset", func(t *testing.T) {
497 t.Parallel()
498 spec := testSpec()
499 platform, err := detectPlatform(spec)
500 require.NoError(t, err)
501 testClient := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://gitlab.com"))
502 testClient.MockPackages.EXPECT().
503 ListProjectPackages(spec.ProjectID, gomock.Any(), gomock.Any(), gomock.Any()).
504 DoAndReturn(func(_ any, _ *gitlab.ListProjectPackagesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Package, *gitlab.Response, error) {
505 assertDeadline(t, options)
506 return []*gitlab.Package{{ID: 1, Version: "8.0.0"}}, noMorePages(), nil
507 })
508 testClient.MockPackages.EXPECT().
509 ListPackageFiles(spec.ProjectID, int64(1), gomock.Any(), gomock.Any()).
510 DoAndReturn(func(_ any, _ int64, _ *gitlab.ListPackageFilesOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.PackageFile, *gitlab.Response, error) {
511 assertDeadline(t, options)
512 return []*gitlab.PackageFile{{FileName: assetName(spec, platform), FileSHA256: "abc"}}, nil, nil
513 })
514 ios, _, _, _ := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
515 m := &Manager{io: ios, spec: spec, client: testClient.Client}
517 _, err = m.fetchPackageAsset(t.Context(), platform)
518 require.NoError(t, err)
519 })
522func TestManager_fetchLatestPackage_timeoutError(t *testing.T) {
523 t.Parallel()
525 spec := testSpec()
526 testClient := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://gitlab.com"))
527 testClient.MockPackages.EXPECT().
528 ListProjectPackages(spec.ProjectID, gomock.Any(), gomock.Any(), gomock.Any()).
529 Return(nil, nil, context.DeadlineExceeded)
530 ios, _, _, _ := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
531 m := &Manager{io: ios, spec: spec, client: testClient.Client}
533 _, err := m.fetchLatestPackage(t.Context())
534 require.ErrorIs(t, err, context.DeadlineExceeded)
535 assert.ErrorContains(t, err, "package registry did not respond within 15s")
538func TestManager_fetchPackageAsset_filesTimeoutError(t *testing.T) {
539 t.Parallel()
541 spec := testSpec()
542 testClient := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://gitlab.com"))
543 testClient.MockPackages.EXPECT().
544 ListProjectPackages(spec.ProjectID, gomock.Any(), gomock.Any(), gomock.Any()).
545 Return([]*gitlab.Package{{ID: 1, Version: "8.0.0"}}, noMorePages(), nil)
546 testClient.MockPackages.EXPECT().
547 ListPackageFiles(spec.ProjectID, int64(1), gomock.Any(), gomock.Any()).
548 Return(nil, nil, context.DeadlineExceeded)
549 ios, _, _, _ := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
550 m := &Manager{io: ios, spec: spec, client: testClient.Client}
552 _, err := m.fetchPackageAsset(t.Context(), Platform{OS: "linux", Arch: "x64"})
553 require.ErrorIs(t, err, context.DeadlineExceeded)
554 assert.ErrorContains(t, err, "package registry did not respond within 15s")
557func TestManager_fetchLatestPackage_requestsLargePages(t *testing.T) {
558 t.Parallel()
560 spec := testSpec()
561 testClient := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://gitlab.com"))
562 testClient.MockPackages.EXPECT().
563 ListProjectPackages(spec.ProjectID, gomock.Any(), gomock.Any(), gomock.Any()).
564 DoAndReturn(func(_ any, opts *gitlab.ListProjectPackagesOptions, _ ...gitlab.RequestOptionFunc) ([]*gitlab.Package, *gitlab.Response, error) {
565 assert.Equal(t, int64(100), opts.PerPage)
566 return []*gitlab.Package{{ID: 1, Version: "8.0.0"}}, noMorePages(), nil
567 })
568 ios, _, _, _ := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
569 m := &Manager{io: ios, spec: spec, client: testClient.Client}
571 _, err := m.fetchLatestPackage(t.Context())
572 require.NoError(t, err)
Diagnostics6 git calls · 227 ms
CallStatusSizeTime0227 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=3
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 KiB2 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=UPDATING
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
fetchcombine:blob:none+tree:2 · deepen 12004.2 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=4273
git.response.cache=HIT
git.response.duration_ms=2
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:0 · deepen 1020032 KiB · hit3 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=3
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:0200528 B · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=220
git.response.bytes=528
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=6f25b436c20690dd9e61e310cecb2c93d3671017
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=528
git.pkt.payload.max=501
git.sideband.band1.bytes=501
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=501
git.pack.trailer=3f78362ab585c40c9cff18b66b4df6f87bfba2d8
Open pack map
fetch2003.8 KiB220 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=3899
git.response.cache=MISS
git.response.duration_ms=220
git.fetch.wants=9ac8f54dc574540fb30f578b8de31355219c145c
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=3899
git.pkt.payload.max=3872
git.sideband.band1.bytes=3872
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
a5e152c6aba70acb
Request
ad661d70…
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