GitLabgitlab-org

cli

main
ply6 git calls42 ms99 KiB4 cachedprotocol v2
425 lines15 KiBRaw
1//go:build !integration
3package binarymgr
5import (
6 "bytes"
7 "context"
8 "crypto/sha256"
9 "encoding/hex"
10 "errors"
11 "net/http"
12 "os"
13 "path/filepath"
14 "testing"
15 "time"
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/config"
25 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
28func runnerFor(t *testing.T) (*Runner, config.Config) {
29 t.Helper()
30 t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
31 ios, _, _, _ := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
32 cfg := config.NewBlankConfig()
33 spec := testSpec()
34 return &Runner{
35 IO: ios,
36 Cfg: cfg,
37 Spec: spec,
38 Manager: NewManager(ios, spec),
39 }, cfg
42// These tests use t.Setenv (via runnerFor) to point ConfigFile() at a temp dir and so cannot be parallel
44func TestRunner_saveAutoDownloadPreference(t *testing.T) {
45 t.Run("empty preference is a no-op", func(t *testing.T) {
46 r, cfg := runnerFor(t)
47 r.saveAutoDownloadPreference("")
49 got, _ := cfg.Get("", r.Spec.configKey("auto_download"))
50 assert.Empty(t, got, "no preference should be persisted for empty input")
51 })
53 t.Run("opt-in is persisted", func(t *testing.T) {
54 r, cfg := runnerFor(t)
55 r.saveAutoDownloadPreference("true")
57 got, _ := cfg.Get("", r.Spec.configKey("auto_download"))
58 assert.Equal(t, "true", got)
59 })
62func TestRunner_versionAfterFloor(t *testing.T) {
63 managed := "/managed/bin/test"
64 newRunner := func(t *testing.T, min string) (*Runner, *bytes.Buffer, *bytes.Buffer) {
65 t.Helper()
66 ios, _, stdout, stderr := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
67 spec := testSpec()
68 spec.MinVersion = min
69 return &Runner{IO: ios, Spec: spec}, stdout, stderr
70 }
72 t.Run("below floor is blanked to force download", func(t *testing.T) {
73 r, stdout, stderr := newRunner(t, "0.101.1")
74 assert.Empty(t, r.versionAfterFloor("0.101.0", managed, managed))
75 assert.Empty(t, stdout.String())
76 assert.Contains(t, stderr.String(), "Installed Test CLI version 0.101.0 is older than the required 0.101.1")
77 })
79 t.Run("at or above floor is preserved", func(t *testing.T) {
80 r, _, _ := newRunner(t, "0.101.1")
81 assert.Equal(t, "0.101.1", r.versionAfterFloor("0.101.1", managed, managed))
82 assert.Equal(t, "0.102.0", r.versionAfterFloor("0.102.0", managed, managed))
83 })
85 t.Run("custom binary path is never forced", func(t *testing.T) {
86 r, _, _ := newRunner(t, "0.101.1")
87 assert.Equal(t, "0.101.0", r.versionAfterFloor("0.101.0", "/custom/orbit", managed))
88 })
90 t.Run("no floor is a no-op", func(t *testing.T) {
91 r, _, _ := newRunner(t, "")
92 assert.Equal(t, "0.0.1", r.versionAfterFloor("0.0.1", managed, managed))
93 })
96func TestRunner_saveLastUpdateCheck(t *testing.T) {
97 r, cfg := runnerFor(t)
98 now := time.Date(2026, 5, 12, 10, 0, 0, 0, time.UTC)
99 r.saveLastUpdateCheck(now)
101 got, _ := cfg.Get("", r.Spec.configKey("last_update_check"))
102 require.NotEmpty(t, got)
104 parsed, err := time.Parse(time.RFC3339, got)
105 require.NoError(t, err)
106 assert.True(t, parsed.Equal(now), "expected %s, got %s", now, parsed)
109type failingConfig struct {
110 config.Config
111 failKey string
114func (c failingConfig) Get(hostname, key string) (string, error) {
115 if key == c.failKey {
116 return "", errors.New("keyring locked")
117 }
118 return c.Config.Get(hostname, key)
121func TestInstalledBinary(t *testing.T) {
122 writeExecutable := func(t *testing.T, path string) {
123 t.Helper()
124 require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
125 require.NoError(t, os.WriteFile(path, []byte("#!/bin/sh\n"), 0o755))
126 }
127 managedSetup := func(t *testing.T, version string) (Spec, config.Config, string) {
128 t.Helper()
129 t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
130 spec := testSpec()
131 spec.MinVersion = "0.103.0"
132 managed, err := ManagedBinaryPath(spec)
133 require.NoError(t, err)
134 cfg := config.NewBlankConfig()
135 if version != "" {
136 require.NoError(t, cfg.Set("", spec.configKey("binary_version"), version))
137 }
138 return spec, cfg, managed
139 }
141 customSetup := func(t *testing.T, name string) (config.Config, string) {
142 t.Helper()
143 custom := filepath.Join(t.TempDir(), name)
144 cfg := config.NewBlankConfig()
145 require.NoError(t, cfg.Set("", testSpec().configKey("binary_path"), custom))
146 return cfg, custom
147 }
149 t.Run("custom path that passes validation is installed", func(t *testing.T) {
150 cfg, custom := customSetup(t, "custom")
151 writeExecutable(t, custom)
153 status, err := InstalledBinary(cfg, testSpec())
154 require.NoError(t, err)
155 assert.Equal(t, InstallStatus{Path: custom, Installed: true}, status)
156 })
158 t.Run("custom path that is missing is not installed", func(t *testing.T) {
159 cfg, _ := customSetup(t, "missing")
161 status, err := InstalledBinary(cfg, testSpec())
162 require.NoError(t, err)
163 assert.False(t, status.Installed)
164 })
166 t.Run("managed binary at or above the floor is installed", func(t *testing.T) {
167 spec, cfg, managed := managedSetup(t, "0.103.0")
168 writeExecutable(t, managed)
170 status, err := InstalledBinary(cfg, spec)
171 require.NoError(t, err)
172 assert.Equal(t, InstallStatus{Path: managed, Version: "0.103.0", Installed: true}, status)
173 })
175 t.Run("managed binary below the floor is not installed because Run would download", func(t *testing.T) {
176 spec, cfg, managed := managedSetup(t, "0.100.0")
177 writeExecutable(t, managed)
179 status, err := InstalledBinary(cfg, spec)
180 require.NoError(t, err)
181 assert.Equal(t, InstallStatus{Path: managed, Version: "0.100.0", Installed: false}, status)
182 })
184 t.Run("managed binary without a recorded version is not installed because Run would download", func(t *testing.T) {
185 spec, cfg, managed := managedSetup(t, "")
186 writeExecutable(t, managed)
188 status, err := InstalledBinary(cfg, spec)
189 require.NoError(t, err)
190 assert.False(t, status.Installed)
191 })
193 t.Run("config read error is returned with a best-effort status", func(t *testing.T) {
194 blank, custom := customSetup(t, "custom")
195 writeExecutable(t, custom)
196 spec := testSpec()
197 cfg := failingConfig{Config: blank, failKey: spec.configKey("binary_version")}
199 status, err := InstalledBinary(cfg, spec)
200 require.ErrorContains(t, err, "reading test_cli_binary_version: keyring locked")
201 assert.Equal(t, InstallStatus{Path: custom, Installed: true}, status)
202 })
205func TestRunner_ReportUpdate(t *testing.T) {
206 installManaged := func(t *testing.T, cfg config.Config, spec Spec, version string) {
207 t.Helper()
208 managed, err := ManagedBinaryPath(spec)
209 require.NoError(t, err)
210 require.NoError(t, os.MkdirAll(filepath.Dir(managed), 0o755))
211 require.NoError(t, os.WriteFile(managed, []byte("#!/bin/sh\n"), 0o755))
212 require.NoError(t, cfg.Set("", spec.configKey("binary_version"), version))
213 }
214 runnerWithRegistry := func(t *testing.T, mock func(*gitlabtesting.TestClient)) (*Runner, config.Config, *bytes.Buffer, *bytes.Buffer) {
215 t.Helper()
216 t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
217 ios, _, stdout, stderr := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
218 testClient := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://gitlab.com"))
219 mock(testClient)
220 cfg := config.NewBlankConfig()
221 spec := testSpec()
222 return &Runner{IO: ios, Cfg: cfg, Spec: spec, Manager: &Manager{io: ios, spec: spec, client: testClient.Client}}, cfg, stdout, stderr
223 }
224 runnerWithLatest := func(t *testing.T, latest ...string) (*Runner, config.Config, *bytes.Buffer, *bytes.Buffer) {
225 t.Helper()
226 return runnerWithRegistry(t, func(tc *gitlabtesting.TestClient) {
227 for _, v := range latest {
228 tc.MockPackages.EXPECT().
229 ListProjectPackages(testSpec().ProjectID, gomock.Any(), gomock.Any(), gomock.Any()).
230 Return([]*gitlab.Package{{ID: 1, Version: v}}, noMorePages(), nil)
231 }
232 })
233 }
234 runnerWithRegistryError := func(t *testing.T, err error) (*Runner, config.Config, *bytes.Buffer, *bytes.Buffer) {
235 t.Helper()
236 return runnerWithRegistry(t, func(tc *gitlabtesting.TestClient) {
237 tc.MockPackages.EXPECT().
238 ListProjectPackages(testSpec().ProjectID, gomock.Any(), gomock.Any(), gomock.Any()).
239 Return(nil, nil, err)
240 })
241 }
243 t.Run("installed binary with an update prints the update command", func(t *testing.T) {
244 r, cfg, stdout, stderr := runnerWithLatest(t, "8.1.0")
245 installManaged(t, cfg, r.Spec, "8.0.0")
247 require.NoError(t, r.ReportUpdate(t.Context()))
249 assert.Contains(t, stderr.String(), "New Test CLI version available: 8.0.0 → 8.1.0")
250 assert.Contains(t, stderr.String(), "Run 'glab test cli update' to update to the latest version")
251 assert.Empty(t, stdout.String())
252 })
254 t.Run("installed binary checks even within the 24-hour throttle", func(t *testing.T) {
255 r, cfg, _, stderr := runnerWithLatest(t, "8.1.0")
256 installManaged(t, cfg, r.Spec, "8.0.0")
257 require.NoError(t, cfg.Set("", r.Spec.configKey("last_update_check"), time.Now().Format(time.RFC3339)))
259 require.NoError(t, r.ReportUpdate(t.Context()))
261 assert.Contains(t, stderr.String(), "8.0.0 → 8.1.0")
262 })
264 t.Run("installed binary below the minimum version is still reported", func(t *testing.T) {
265 r, cfg, _, stderr := runnerWithLatest(t, "8.1.0")
266 r.Spec.MinVersion = "8.0.5"
267 installManaged(t, cfg, r.Spec, "8.0.0")
269 require.NoError(t, r.ReportUpdate(t.Context()))
271 assert.Contains(t, stderr.String(), "8.0.0 → 8.1.0")
272 })
274 t.Run("recorded version without a binary on disk prints nothing and makes no request", func(t *testing.T) {
275 r, cfg, stdout, stderr := runnerWithLatest(t)
276 require.NoError(t, cfg.Set("", r.Spec.configKey("binary_version"), "8.0.0"))
278 require.NoError(t, r.ReportUpdate(t.Context()))
280 assert.Empty(t, stdout.String())
281 assert.Empty(t, stderr.String())
282 })
284 t.Run("registry failure is returned with the binary name", func(t *testing.T) {
285 r, cfg, stdout, stderr := runnerWithRegistryError(t, errors.New("connection refused"))
286 installManaged(t, cfg, r.Spec, "8.0.0")
288 err := r.ReportUpdate(t.Context())
290 require.EqualError(t, err, "failed checking for Test CLI updates: failed to fetch packages: connection refused")
291 assert.Empty(t, stdout.String())
292 assert.Empty(t, stderr.String())
293 })
295 t.Run("registry HTTP error reports only the status code", func(t *testing.T) {
296 r, cfg, _, _ := runnerWithRegistryError(t, &gitlab.ErrorResponse{StatusCode: http.StatusServiceUnavailable, Message: "<html>maintenance</html>"})
297 installManaged(t, cfg, r.Spec, "8.0.0")
299 err := r.ReportUpdate(t.Context())
301 require.EqualError(t, err, "failed checking for Test CLI updates: the package registry responded with HTTP 503")
302 })
304 t.Run("installed binary that is current prints nothing", func(t *testing.T) {
305 r, cfg, stdout, stderr := runnerWithLatest(t, "8.0.0")
306 installManaged(t, cfg, r.Spec, "8.0.0")
308 require.NoError(t, r.ReportUpdate(t.Context()))
310 assert.Empty(t, stdout.String())
311 assert.Empty(t, stderr.String())
312 })
314 t.Run("binary that is not installed prints nothing and makes no request", func(t *testing.T) {
315 r, _, stdout, stderr := runnerWithLatest(t)
317 require.NoError(t, r.ReportUpdate(t.Context()))
319 assert.Empty(t, stdout.String())
320 assert.Empty(t, stderr.String())
321 })
323 t.Run("custom binary prints nothing and makes no request", func(t *testing.T) {
324 r, cfg, stdout, stderr := runnerWithLatest(t)
325 custom := filepath.Join(t.TempDir(), "custom")
326 require.NoError(t, os.WriteFile(custom, []byte("#!/bin/sh\n"), 0o755))
327 require.NoError(t, cfg.Set("", r.Spec.configKey("binary_path"), custom))
328 require.NoError(t, cfg.Set("", r.Spec.configKey("binary_version"), "8.0.0"))
330 require.NoError(t, r.ReportUpdate(t.Context()))
332 assert.Empty(t, stdout.String())
333 assert.Empty(t, stderr.String())
334 })
337func TestRunner_HandleInstall_keepsStdoutClean(t *testing.T) {
338 t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
339 ios, _, stdout, stderr := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
340 testClient := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://gitlab.com"))
341 spec := testSpec()
342 platform, err := detectPlatform(spec)
343 require.NoError(t, err)
344 content := []byte("#!/bin/sh\n")
345 checksum := sha256.Sum256(content)
347 testClient.MockPackages.EXPECT().
348 ListProjectPackages(spec.ProjectID, gomock.Any(), gomock.Any(), gomock.Any()).
349 Return([]*gitlab.Package{{ID: 1, Version: "8.0.0"}}, noMorePages(), nil)
350 testClient.MockPackages.EXPECT().
351 ListPackageFiles(spec.ProjectID, int64(1), gomock.Any(), gomock.Any()).
352 Return([]*gitlab.PackageFile{{FileName: assetName(spec, platform), FileSHA256: hex.EncodeToString(checksum[:])}}, nil, nil)
353 testClient.MockGenericPackages.EXPECT().
354 DownloadPackageFile(spec.ProjectID, spec.PackageName, "8.0.0", assetName(spec, platform), gomock.Any()).
355 Return(content, nil, nil)
357 r := &Runner{IO: ios, Cfg: config.NewBlankConfig(), Spec: spec, Yes: true, Manager: &Manager{io: ios, spec: spec, client: testClient.Client}}
359 require.NoError(t, r.HandleInstall(t.Context()))
361 assert.Empty(t, stdout.String())
362 assert.Contains(t, stderr.String(), "Downloading")
363 assert.Contains(t, stderr.String(), "Checksum verified")
364 assert.Contains(t, stderr.String(), "Installed to:")
367func TestRunner_performUpdateCheck_stampsFailedCheck(t *testing.T) {
368 t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
369 ios, _, _, _ := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
370 testClient := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://gitlab.com"))
371 spec := testSpec()
372 testClient.MockPackages.EXPECT().
373 ListProjectPackages(spec.ProjectID, gomock.Any(), gomock.Any(), gomock.Any()).
374 Return(nil, nil, errors.New("i/o timeout")).
375 Times(1)
376 cfg := config.NewBlankConfig()
377 require.NoError(t, cfg.Set("", spec.configKey("binary_version"), "8.0.0"))
378 r := &Runner{IO: ios, Cfg: cfg, Spec: spec, Manager: &Manager{io: ios, spec: spec, client: testClient.Client}}
380 _, err := r.performUpdateCheck(t.Context(), false)
381 require.Error(t, err)
383 stamp, _ := cfg.Get("", spec.configKey("last_update_check"))
384 require.NotEmpty(t, stamp)
386 result, err := r.performUpdateCheck(t.Context(), false)
387 require.NoError(t, err)
388 assert.False(t, result.hasUpdate)
391func TestRunner_Run_freshDownloadSkipsFollowUpUpdateCheck(t *testing.T) {
392 t.Setenv("GLAB_CONFIG_DIR", t.TempDir())
393 ios, _, _, _ := cmdtest.TestIOStreams(cmdtest.WithTestIOStreamsAsTTY(false))
394 testClient := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://gitlab.com"))
395 spec := testSpec()
396 platform, err := detectPlatform(spec)
397 require.NoError(t, err)
398 content := []byte("#!/bin/sh\n")
399 checksum := sha256.Sum256(content)
401 testClient.MockPackages.EXPECT().
402 ListProjectPackages(spec.ProjectID, gomock.Any(), gomock.Any(), gomock.Any()).
403 Return([]*gitlab.Package{{ID: 1, Version: "8.0.0"}}, noMorePages(), nil).
404 Times(1)
405 testClient.MockPackages.EXPECT().
406 ListPackageFiles(spec.ProjectID, int64(1), gomock.Any(), gomock.Any()).
407 Return([]*gitlab.PackageFile{{FileName: assetName(spec, platform), FileSHA256: hex.EncodeToString(checksum[:])}}, nil, nil)
408 testClient.MockGenericPackages.EXPECT().
409 DownloadPackageFile(spec.ProjectID, spec.PackageName, "8.0.0", assetName(spec, platform), gomock.Any()).
410 Return(content, nil, nil)
412 cfg := config.NewBlankConfig()
413 executed := false
414 r := &Runner{
415 IO: ios, Cfg: cfg, Spec: spec, Yes: true,
416 Manager: &Manager{io: ios, spec: spec, client: testClient.Client},
417 Executor: func(context.Context, string, []string) error { executed = true; return nil },
418 }
420 require.NoError(t, r.Run(t.Context()))
422 assert.True(t, executed)
423 stamp, _ := cfg.Get("", spec.configKey("last_update_check"))
424 assert.NotEmpty(t, stamp)
Diagnostics6 git calls · 42 ms
CallStatusSizeTime042 ms
discover200185 B5 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 KiB3 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=UPDATING
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 · hit2 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=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=44
Open 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=4
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:0200528 B · hit4 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=30
git.response.bytes=528
git.response.cache=HIT
git.response.duration_ms=4
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.3 KiB · hit30 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=3386
git.response.cache=HIT
git.response.duration_ms=30
git.fetch.wants=5806c1677d59e7e931dd0edb34a95c43edaeb3fc
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=3386
git.pkt.payload.max=3359
git.sideband.band1.bytes=3359
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
a5e133543ab2a9fe
Request
ffd00c38…
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