GitLabgitlab-org
cli
main
1//go:build !integration
3package upload
5import (
6 "bytes"
7 "context"
8 "errors"
9 "fmt"
10 "io"
11 "sync"
12 "sync/atomic"
13 "testing"
14 "time"
16 "github.com/stretchr/testify/assert"
17 "github.com/stretchr/testify/require"
18 "go.uber.org/mock/gomock"
20 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
21 gitlabtesting "gitlab.com/gitlab-org/api/client-go/v3/testing"
23 "gitlab.com/gitlab-org/cli/internal/glinstance"
24 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
25)
27func TestReleaseUtilsUpload_AliasFilePathToAssetDirectPath(t *testing.T) {
28 tests := []struct {
29 name string
30 givenReleaseAsset *ReleaseAsset
31 expectedReleaseAsset *ReleaseAsset
32 expectedAliased bool
33 }{
34 {
35 name: "no filepath, no direct_asset_path",
36 givenReleaseAsset: &ReleaseAsset{Name: new("any-name")},
37 expectedReleaseAsset: &ReleaseAsset{Name: new("any-name")},
38 expectedAliased: false,
39 },
40 {
41 name: "no filepath, but direct_asset_path",
42 givenReleaseAsset: &ReleaseAsset{Name: new("any-name"), DirectAssetPath: new("/any-path")},
43 expectedReleaseAsset: &ReleaseAsset{Name: new("any-name"), DirectAssetPath: new("/any-path")},
44 expectedAliased: false,
45 },
46 {
47 name: "filepath, but not direct_asset_path",
48 givenReleaseAsset: &ReleaseAsset{Name: new("any-name"), FilePath: new("/any-path")},
49 expectedReleaseAsset: &ReleaseAsset{Name: new("any-name"), DirectAssetPath: new("/any-path")},
50 expectedAliased: true,
51 },
52 }
54 for _, tt := range tests {
55 t.Run(tt.name, func(t *testing.T) {
56 aliased, err := aliasFilePathToDirectAssetPath(tt.givenReleaseAsset)
58 require.NoError(t, err)
59 assert.Equal(t, tt.expectedAliased, aliased)
60 assert.Equal(t, tt.expectedReleaseAsset, tt.givenReleaseAsset)
61 })
62 }
63}
65func TestReleaseUtilsUpload_AliasFilePathToAssetDirectPath_Conflict(t *testing.T) {
66 asset := &ReleaseAsset{
67 FilePath: new("/any-path"),
68 DirectAssetPath: new("/any-path"),
69 }
71 aliased, err := aliasFilePathToDirectAssetPath(asset)
73 target := &ConflictDirectAssetPathError{}
74 require.ErrorAs(t, err, &target)
75 assert.False(t, aliased)
76}
78func TestReleaseUtilsUpload_UploadFiles_ProjectMarkdownFiles(t *testing.T) {
79 t.Parallel()
81 // GIVEN
82 ios, _, _, _ := cmdtest.TestIOStreams()
83 tc := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://"+glinstance.DefaultHostname))
84 testReleaseFile := bytes.NewBufferString("Hello World")
85 uploadCtx := &Context{
86 Client: tc.Client,
87 IO: ios,
88 AssetFiles: []*ReleaseFile{
89 {
90 Open: func() (io.ReadCloser, error) {
91 return io.NopCloser(testReleaseFile), nil
92 },
93 Name: "test-release-file.txt",
94 Path: "./foobar/test-release-file.txt",
95 Type: new(gitlab.OtherLinkType),
96 },
97 },
98 AssetsLinks: []*ReleaseAsset{},
99 }
101 // setup mock exceptions
102 gomock.InOrder(
103 tc.MockProjectMarkdownUploads.EXPECT().
104 UploadProjectMarkdown("any-project", gomock.Any(), "test-release-file.txt", gomock.Any()).
105 Return(&gitlab.ProjectMarkdownUploadedFile{FullPath: "test-release-file.txt"}, nil, nil),
106 tc.MockReleaseLinks.EXPECT().CreateReleaseLink("any-project", "42.0.0", gomock.Any(), gomock.Any()),
107 )
109 // WHEN
110 err := uploadCtx.UploadFiles(t.Context(), "any-project", "42.0.0", DefaultReleasePackageName, false)
112 // THEN
113 require.NoError(t, err)
114}
116func TestReleaseUtilsUpload_UploadFiles_GenericPackageRegistry(t *testing.T) {
117 t.Parallel()
119 // GIVEN
120 ios, _, _, _ := cmdtest.TestIOStreams()
121 tc := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://"+glinstance.DefaultHostname))
122 testReleaseFile := bytes.NewBufferString("Hello World")
123 uploadCtx := &Context{
124 Client: tc.Client,
125 IO: ios,
126 AssetFiles: []*ReleaseFile{
127 {
128 Open: func() (io.ReadCloser, error) {
129 return io.NopCloser(testReleaseFile), nil
130 },
131 Name: "test-release-file.txt",
132 Path: "./foobar/test-release-file.txt",
133 Type: new(gitlab.OtherLinkType),
134 },
135 },
136 AssetsLinks: []*ReleaseAsset{},
137 }
139 // setup mock exceptions
140 gomock.InOrder(
141 tc.MockGenericPackages.EXPECT().
142 PublishPackageFile("any-project", DefaultReleasePackageName, "42.0.0", "test-release-file.txt", gomock.Any(), nil, gomock.Any()),
143 tc.MockGenericPackages.EXPECT().
144 FormatPackageURL("any-project", DefaultReleasePackageName, "42.0.0", "test-release-file.txt"),
145 tc.MockReleaseLinks.EXPECT().CreateReleaseLink("any-project", "42.0.0", gomock.Any(), gomock.Any()),
146 )
148 // WHEN
149 err := uploadCtx.UploadFiles(t.Context(), "any-project", "42.0.0", DefaultReleasePackageName, true)
151 // THEN
152 require.NoError(t, err)
153}
155func newTestReleaseFiles(count int) []*ReleaseFile {
156 files := make([]*ReleaseFile, count)
157 for i := range files {
158 name := fmt.Sprintf("file-%d.txt", i)
159 files[i] = &ReleaseFile{
160 Open: func() (io.ReadCloser, error) {
161 return io.NopCloser(bytes.NewBufferString(name)), nil
162 },
163 Name: name,
164 Label: name,
165 Path: "./" + name,
166 }
167 }
168 return files
169}
171func TestReleaseUtilsUpload_UploadFiles_LinksFollowInputOrder(t *testing.T) {
172 t.Parallel()
174 ios, _, _, _ := cmdtest.TestIOStreams()
175 tc := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://"+glinstance.DefaultHostname))
176 files := newTestReleaseFiles(uploadConcurrency)
177 uploadCtx := &Context{Client: tc.Client, IO: ios, AssetFiles: files}
179 done := make([]chan struct{}, len(files))
180 for i := range done {
181 done[i] = make(chan struct{})
182 }
183 for i, file := range files {
184 tc.MockProjectMarkdownUploads.EXPECT().
185 UploadProjectMarkdown("any-project", gomock.Any(), file.Name, gomock.Any()).
186 DoAndReturn(func(_ any, _ io.Reader, name string, _ ...gitlab.RequestOptionFunc) (*gitlab.ProjectMarkdownUploadedFile, *gitlab.Response, error) {
187 if i+1 < len(done) {
188 select {
189 case <-done[i+1]:
190 case <-time.After(5 * time.Second):
191 return nil, nil, errors.New("uploads did not run concurrently")
192 }
193 }
194 close(done[i])
195 return &gitlab.ProjectMarkdownUploadedFile{FullPath: "/uploads/" + name}, nil, nil
196 })
197 }
198 var linkCalls []any
199 for _, file := range files {
200 linkCalls = append(linkCalls, tc.MockReleaseLinks.EXPECT().
201 CreateReleaseLink("any-project", "42.0.0", gomock.Cond(func(opt *gitlab.CreateReleaseLinkOptions) bool {
202 return *opt.Name == file.Label
203 }), gomock.Any()))
204 }
205 gomock.InOrder(linkCalls...)
207 err := uploadCtx.UploadFiles(t.Context(), "any-project", "42.0.0", DefaultReleasePackageName, false)
209 require.NoError(t, err)
210 assert.Nil(t, uploadCtx.AssetFiles)
211}
213func TestReleaseUtilsUpload_UploadFiles_LimitsConcurrency(t *testing.T) {
214 t.Parallel()
216 ios, _, _, _ := cmdtest.TestIOStreams()
217 tc := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://"+glinstance.DefaultHostname))
218 files := newTestReleaseFiles(uploadConcurrency + 2)
219 uploadCtx := &Context{Client: tc.Client, IO: ios, AssetFiles: files}
221 var active, maxActive atomic.Int32
222 var started sync.WaitGroup
223 started.Add(uploadConcurrency)
224 allSlotsBusy := make(chan struct{})
225 go func() {
226 started.Wait()
227 close(allSlotsBusy)
228 }()
229 var startedCount atomic.Int32
231 tc.MockGenericPackages.EXPECT().
232 PublishPackageFile("any-project", DefaultReleasePackageName, "42.0.0", gomock.Any(), gomock.Any(), nil, gomock.Any()).
233 DoAndReturn(func(_ any, _, _, _ string, _ io.Reader, _ *gitlab.PublishPackageFileOptions, _ ...gitlab.RequestOptionFunc) (*gitlab.GenericPackagesFile, *gitlab.Response, error) {
234 current := active.Add(1)
235 defer active.Add(-1)
236 for {
237 peak := maxActive.Load()
238 if current <= peak || maxActive.CompareAndSwap(peak, current) {
239 break
240 }
241 }
242 if startedCount.Add(1) <= uploadConcurrency {
243 started.Done()
244 }
245 select {
246 case <-allSlotsBusy:
247 case <-time.After(5 * time.Second):
248 return nil, nil, errors.New("uploads did not run concurrently")
249 }
250 return &gitlab.GenericPackagesFile{}, nil, nil
251 }).
252 Times(len(files))
253 tc.MockGenericPackages.EXPECT().
254 FormatPackageURL("any-project", DefaultReleasePackageName, "42.0.0", gomock.Any()).
255 Return("/packages/file", nil).
256 Times(len(files))
257 tc.MockReleaseLinks.EXPECT().
258 CreateReleaseLink("any-project", "42.0.0", gomock.Any(), gomock.Any()).
259 Times(len(files))
261 err := uploadCtx.UploadFiles(t.Context(), "any-project", "42.0.0", DefaultReleasePackageName, true)
263 require.NoError(t, err)
264 assert.Equal(t, int32(uploadConcurrency), maxActive.Load())
265}
267func TestReleaseUtilsUpload_UploadFiles_UploadErrorCreatesNoLinks(t *testing.T) {
268 t.Parallel()
270 ios, _, _, _ := cmdtest.TestIOStreams()
271 tc := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://"+glinstance.DefaultHostname))
272 files := newTestReleaseFiles(2)
273 uploadCtx := &Context{Client: tc.Client, IO: ios, AssetFiles: files}
274 uploadErr := errors.New("upload failed")
276 tc.MockProjectMarkdownUploads.EXPECT().
277 UploadProjectMarkdown("any-project", gomock.Any(), files[0].Name, gomock.Any()).
278 Return(&gitlab.ProjectMarkdownUploadedFile{FullPath: "/uploads/" + files[0].Name}, nil, nil).
279 MaxTimes(1)
280 tc.MockProjectMarkdownUploads.EXPECT().
281 UploadProjectMarkdown("any-project", gomock.Any(), files[1].Name, gomock.Any()).
282 Return(nil, nil, uploadErr)
283 tc.MockReleaseLinks.EXPECT().CreateReleaseLink(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
285 err := uploadCtx.UploadFiles(t.Context(), "any-project", "42.0.0", DefaultReleasePackageName, false)
287 require.ErrorIs(t, err, uploadErr)
288 assert.ErrorContains(t, err, files[1].Path)
289}
291func TestReleaseUtilsUpload_UploadFiles_CancelledContextUploadsNothing(t *testing.T) {
292 t.Parallel()
294 ios, _, _, _ := cmdtest.TestIOStreams()
295 tc := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://"+glinstance.DefaultHostname))
296 uploadCtx := &Context{Client: tc.Client, IO: ios, AssetFiles: newTestReleaseFiles(3)}
297 ctx, cancel := context.WithCancel(t.Context())
298 cancel()
300 tc.MockProjectMarkdownUploads.EXPECT().UploadProjectMarkdown(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
301 tc.MockReleaseLinks.EXPECT().CreateReleaseLink(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(0)
303 err := uploadCtx.UploadFiles(ctx, "any-project", "42.0.0", DefaultReleasePackageName, false)
305 require.ErrorIs(t, err, context.Canceled)
306}
308func TestReleaseUtilsUpload_UploadFiles_PrintsOneLinePerFile(t *testing.T) {
309 t.Parallel()
311 ios, _, stdout, _ := cmdtest.TestIOStreams()
312 tc := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://"+glinstance.DefaultHostname))
313 files := newTestReleaseFiles(3)
314 uploadCtx := &Context{Client: tc.Client, IO: ios, AssetFiles: files}
316 tc.MockProjectMarkdownUploads.EXPECT().
317 UploadProjectMarkdown("any-project", gomock.Any(), gomock.Any(), gomock.Any()).
318 Return(&gitlab.ProjectMarkdownUploadedFile{FullPath: "/uploads/file"}, nil, nil).
319 Times(len(files))
320 tc.MockReleaseLinks.EXPECT().CreateReleaseLink("any-project", "42.0.0", gomock.Any(), gomock.Any()).Times(len(files))
322 err := uploadCtx.UploadFiles(t.Context(), "any-project", "42.0.0", DefaultReleasePackageName, false)
324 require.NoError(t, err)
325 assert.Equal(t, "• Uploading to release\tfile=./file-0.txt name=file-0.txt\n"+
326 "• Uploading to release\tfile=./file-1.txt name=file-1.txt\n"+
327 "• Uploading to release\tfile=./file-2.txt name=file-2.txt\n", stdout.String())
328}
330func TestReleaseUtilsUpload_UploadAssetFiles(t *testing.T) {
331 t.Parallel()
333 ios, _, _, _ := cmdtest.TestIOStreams()
334 tc := gitlabtesting.NewTestClient(t, gitlab.WithBaseURL("https://"+glinstance.DefaultHostname))
335 uploadCtx := &Context{
336 Client: tc.Client,
337 IO: ios,
338 AssetFiles: []*ReleaseFile{
339 {
340 Open: func() (io.ReadCloser, error) {
341 return io.NopCloser(bytes.NewBufferString("Hello World")), nil
342 },
343 Name: "test-release-file.txt",
344 Label: "test-release-file",
345 Path: "./foobar/test-release-file.txt",
346 Type: new(gitlab.PackageLinkType),
347 },
348 },
349 }
351 // No CreateReleaseLink expectation: the release may not exist yet.
352 tc.MockProjectMarkdownUploads.EXPECT().
353 UploadProjectMarkdown("any-project", gomock.Any(), "test-release-file.txt", gomock.Any()).
354 Return(&gitlab.ProjectMarkdownUploadedFile{FullPath: "/-/project/1/uploads/abc/test-release-file.txt"}, nil, nil)
356 releaseAssets, err := uploadCtx.UploadAssetFiles(t.Context(), "any-project", "42.0.0", DefaultReleasePackageName, false)
358 require.NoError(t, err)
359 require.Len(t, releaseAssets, 1)
360 assert.Equal(t, "test-release-file", *releaseAssets[0].Name)
361 assert.Equal(t, "https://gitlab.com/-/project/1/uploads/abc/test-release-file.txt", *releaseAssets[0].URL)
362 assert.Equal(t, "/test-release-file.txt", *releaseAssets[0].DirectAssetPath)
363 assert.Equal(t, gitlab.PackageLinkType, *releaseAssets[0].LinkType)
364}
366func TestReleaseUtilsUpload_AliasFilePaths(t *testing.T) {
367 t.Parallel()
369 t.Run("aliases filepath", func(t *testing.T) {
370 t.Parallel()
372 assets := []*ReleaseAsset{
373 {Name: new("with-direct-path"), DirectAssetPath: new("/a")},
374 {Name: new("with-filepath"), FilePath: new("/b")},
375 }
377 aliased, err := AliasFilePaths(assets)
379 require.NoError(t, err)
380 assert.Equal(t, []string{"with-filepath"}, aliased)
381 assert.Equal(t, "/b", *assets[1].DirectAssetPath)
382 assert.Nil(t, assets[1].FilePath)
383 })
385 t.Run("conflicting filepath and direct_asset_path", func(t *testing.T) {
386 t.Parallel()
388 assets := []*ReleaseAsset{{
389 Name: new("conflict"),
390 FilePath: new("/c"),
391 DirectAssetPath: new("/c"),
392 }}
394 _, err := AliasFilePaths(assets)
396 var conflictErr *ConflictDirectAssetPathError
397 require.ErrorAs(t, err, &conflictErr)
398 })
399}
401func TestReleaseUtilsUpload_ToReleaseAssetsOptions(t *testing.T) {
402 t.Parallel()
404 t.Run("no assets", func(t *testing.T) {
405 t.Parallel()
407 assert.Nil(t, ToReleaseAssetsOptions(nil))
408 })
410 t.Run("converts links", func(t *testing.T) {
411 t.Parallel()
413 linkType := gitlab.PackageLinkType
414 assets := []*ReleaseAsset{
415 {
416 Name: new("with-link-type"),
417 URL: new("https://example.com/a"),
418 DirectAssetPath: new("/a"),
419 LinkType: &linkType,
420 },
421 {
422 Name: new("without-link-type"),
423 URL: new("https://example.com/b"),
424 },
425 }
427 opts := ToReleaseAssetsOptions(assets)
429 require.NotNil(t, opts)
430 require.Len(t, opts.Links, 2)
431 assert.Equal(t, "with-link-type", *opts.Links[0].Name)
432 assert.Equal(t, "https://example.com/a", *opts.Links[0].URL)
433 assert.Equal(t, "/a", *opts.Links[0].DirectAssetPath)
434 assert.Equal(t, gitlab.PackageLinkType, *opts.Links[0].LinkType)
435 assert.Equal(t, "without-link-type", *opts.Links[1].Name)
436 assert.Nil(t, opts.Links[1].DirectAssetPath)
437 assert.Nil(t, opts.Links[1].LinkType)
438 })
439}
Diagnostics9 git calls · 43 ms
CallStatusSizeTime043 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 · hit9 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=9 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=3 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=44Open pack map
fetchtree:02001.8 KiB · hit1 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=1 git.response.bytes=1857 git.response.cache=HIT git.response.duration_ms=1 git.fetch.filter=tree:0 git.fetch.wants=dce174ff8c632a19d17eea99c8a9b7c37fb2b592 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=1857 git.pkt.payload.max=1830 git.sideband.band1.bytes=1830 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=1830 git.pack.trailer=fb03183b7909876778f740d196d7516811003517Open pack map
fetchtree:0200350 B · 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=350 git.response.cache=HIT git.response.duration_ms=4 git.fetch.filter=tree:0 git.fetch.wants=b2a837e646ba305993f35203fafafb109e57a7ca 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=350 git.pkt.payload.max=323 git.sideband.band1.bytes=323 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=323 git.pack.trailer=1232131042f2ba4c9c4dbd99382667a1f0849e15Open pack map
fetchtree:0200145 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=145 git.response.cache=HIT git.response.duration_ms=2 git.fetch.filter=tree:0 git.fetch.wants=fd939ecfee6b4c8fd9edfe7831322b170467757f 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=145 git.pkt.payload.max=118 git.sideband.band1.bytes=118 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=118 git.pack.trailer=659e45f50374d89b1e4735a4852bfdc2e0e55abcOpen pack map
fetchtree:0200139 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=139 git.response.cache=HIT git.response.duration_ms=3 git.fetch.filter=tree:0 git.fetch.wants=6e44dc08508d39aa42540b4afc6fdc5734da04c4 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=139 git.pkt.payload.max=112 git.sideband.band1.bytes=112 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=112 git.pack.trailer=f3003d1df2e47d08c612d559da907518ff6abe94Open pack map
fetch2002.9 KiB · hit22 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=22 git.response.bytes=2956 git.response.cache=HIT git.response.duration_ms=22 git.fetch.wants=a7d338bdf3c9fc8375e36ab8feab131a9edac6c3 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=2956 git.pkt.payload.max=2929 git.sideband.band1.bytes=2929 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
- a5e2e7b99c86ecfa
- Request
- 46676f88…
- 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