GitLabgitlab-org
cli
main
1package reorder
3import (
4 "context"
5 "errors"
6 "fmt"
7 "maps"
8 "os"
9 "reflect"
10 "slices"
11 "strings"
13 "github.com/MakeNowJust/heredoc/v2"
14 "github.com/spf13/cobra"
16 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
18 "gitlab.com/gitlab-org/cli/internal/api"
19 "gitlab.com/gitlab-org/cli/internal/auth"
20 "gitlab.com/gitlab-org/cli/internal/cmdutils"
21 "gitlab.com/gitlab-org/cli/internal/commands/mr/mrutils"
22 "gitlab.com/gitlab-org/cli/internal/commands/stack/stackutils"
23 "gitlab.com/gitlab-org/cli/internal/git"
24 "gitlab.com/gitlab-org/cli/internal/iostreams"
25 "gitlab.com/gitlab-org/cli/internal/mcpannotations"
26 "gitlab.com/gitlab-org/cli/internal/text"
27)
29type options struct {
30 io *iostreams.IOStreams
31 gr git.GitRunner
33 continueReorder bool
34 abortReorder bool
35}
37func NewCmdReorderStack(f cmdutils.Factory, gr git.GitRunner, getText cmdutils.GetTextUsingEditor) *cobra.Command {
38 opts := &options{
39 io: f.IO(),
40 gr: gr,
41 }
43 stackReorderCmd := &cobra.Command{
44 Use: "reorder [<branch>...]",
45 Short: "Reorder a stack of diffs. (EXPERIMENTAL)",
46 Long: heredoc.Docf(`
47 Opens an editor with one diff per line, so you can rearrange them.
48 Or pass the branch names in order to reorder non-interactively without an editor.
50 When you save and close the file (or pass the branch names as arguments), each diff's branch is rebased onto the branch of the diff now before it, and each moved diff's merge request is retargeted to match. The rebased branches are not pushed automatically, so run %[1]sglab stack sync%[1]s to force-push them and replace the old commits on GitLab.
52 If a rebase hits a conflict, resolve it, run %[1]sgit rebase --continue%[1]s, and then run %[1]sglab stack reorder --continue%[1]s. To restore the original order instead, run %[1]sglab stack reorder --abort%[1]s.
53 `, "`") + text.ExperimentalString,
54 Example: heredoc.Doc(`
55 # Reorder the stack by choosing a new branch order in your editor
56 glab stack reorder
58 # Reorder the stack non-interactively by specifying branch names in order
59 glab stack reorder branch1 branch2 branch3
61 # Continue a reorder after resolving a conflict
62 glab stack reorder --continue
64 # Abort a reorder and restore the original branch order
65 glab stack reorder --abort`),
66 Annotations: map[string]string{
67 mcpannotations.Destructive: "true",
68 },
69 RunE: func(cmd *cobra.Command, args []string) error {
70 return opts.run(cmd.Context(), f, getText, args)
71 },
72 }
74 stackReorderCmd.Flags().BoolVar(&opts.continueReorder, "continue", false,
75 "Continue a reorder after resolving conflicts.")
76 stackReorderCmd.Flags().BoolVar(&opts.abortReorder, "abort", false,
77 "Abort a reorder and restore original branch state.")
78 stackReorderCmd.MarkFlagsMutuallyExclusive("continue", "abort")
80 return stackReorderCmd
81}
83func (o *options) run(ctx context.Context, f cmdutils.Factory, getText cmdutils.GetTextUsingEditor, args []string) error {
84 if len(args) > 0 && (o.continueReorder || o.abortReorder) {
85 return errors.New("cannot specify branch order with --continue or --abort")
86 }
88 switch {
89 case o.continueReorder:
90 return o.runContinue(ctx, f)
91 case o.abortReorder:
92 return o.runAbort()
93 default:
94 return o.runReorder(ctx, f, getText, args)
95 }
96}
98func (o *options) runReorder(ctx context.Context, f cmdutils.Factory, getText cmdutils.GetTextUsingEditor, args []string) error {
99 title, err := git.GetCurrentStackTitle()
100 if err != nil {
101 return fmt.Errorf("error retrieving current stack title: %w", err)
102 }
104 if err := stackutils.CheckNoRebaseInProgress(); err != nil {
105 return err
106 }
108 if err := checkCleanWorktree(o.gr); err != nil {
109 return err
110 }
112 o.io.StartSpinner("Reordering\n")
113 defer o.io.StopSpinner("")
115 ref, err := git.CurrentStackRefFromCurrentBranch(title)
116 if err != nil {
117 return fmt.Errorf("error checking for stack: %w", err)
118 }
120 stack, err := git.GatherStackRefs(title)
121 if err != nil {
122 return fmt.Errorf("error getting refs from file system: %w", err)
123 }
125 o.io.StopSpinner("")
126 // pausing the spinner in case it's a terminal based editor
128 var branches []string
129 if len(args) > 0 {
130 branches = args
131 } else {
132 if !f.IO().IsOutputTTY() {
133 return errors.New("no TTY available: specify the branch order as arguments (glab stack reorder <branch>...)")
134 }
136 var err error
137 branches, err = promptForOrder(ctx, f, getText, stack, ref.Branch)
138 if err != nil {
139 return fmt.Errorf("error getting new branch order: %w", err)
140 }
141 }
143 // resuming spinner
144 o.io.StartSpinner("Reordering\n")
146 updatedStack, err := matchBranchesToStack(stack, branches)
147 if err != nil {
148 return fmt.Errorf("error matching branches to stack: %w", err)
149 }
151 if reflect.DeepEqual(stack, updatedStack) {
152 return fmt.Errorf("no updates needed")
153 }
155 state, err := rebaseInNewOrder(o.gr, stack, updatedStack)
156 if err != nil {
157 return err
158 }
160 if err := finishReorder(ctx, f, stack.Title, state); err != nil {
161 return err
162 }
164 o.io.StopSpinner("%s Reorder complete. Branches were rebased locally and merge requests retargeted. Run `glab stack sync` to push the rebased branches\n", f.IO().Color().GreenCheck())
166 return nil
167}
169func (o *options) runContinue(ctx context.Context, f cmdutils.Factory) error {
170 o.io.StartSpinner("Continuing reorder\n")
171 defer o.io.StopSpinner("")
173 title, err := git.GetCurrentStackTitle()
174 if err != nil {
175 return fmt.Errorf("error retrieving current stack title: %w", err)
176 }
178 state, err := git.ReadReorderState(title)
179 if err != nil {
180 if errors.Is(err, os.ErrNotExist) {
181 return fmt.Errorf("no reorder in progress for stack %q", title)
182 }
183 return fmt.Errorf("error reading reorder state: %w", err)
184 }
186 if state.NextIndex < 0 || state.NextIndex > len(state.NewOrder) {
187 return fmt.Errorf(
188 "reorder state for stack %q is invalid: index %d is out of range for %d branch(es)",
189 title, state.NextIndex, len(state.NewOrder))
190 }
192 // NextIndex == len(NewOrder) means every rebase finished and only
193 // finishReorder is left to retry.
194 if state.NextIndex < len(state.NewOrder) {
195 if err := o.resumeRebases(title, &state); err != nil {
196 return err
197 }
198 }
200 if err := finishReorder(ctx, f, title, state); err != nil {
201 return err
202 }
204 o.io.StopSpinner("%s Reorder complete. Branches were rebased locally and merge requests retargeted. Run `glab stack sync` to push the rebased branches\n", f.IO().Color().GreenCheck())
205 return nil
206}
208// resumeRebases confirms the branch at NextIndex landed on its new parent,
209// then rebases the rest of the stack.
210func (o *options) resumeRebases(title string, state *git.ReorderState) error {
211 resumeBranch := state.NewOrder[state.NextIndex]
212 newParentRef := state.BaseBranch
213 if state.NextIndex > 0 {
214 newParentRef = state.NewOrder[state.NextIndex-1]
215 }
217 if git.RebaseInProgress() {
218 return fmt.Errorf(
219 "a git rebase of %q is still in progress.\n"+
220 "Resolve any conflicts, mark them resolved with `git add/rm <files>`,\n"+
221 "finish it with `git rebase --continue`, then run `glab stack reorder --continue`.\n"+
222 "Or abort the reorder with `glab stack reorder --abort`",
223 resumeBranch)
224 }
226 if err := checkCleanWorktree(o.gr); err != nil {
227 return err
228 }
230 rebased, err := branchRebasedOnto(o.gr, resumeBranch, newParentRef, state.OldTips[resumeBranch])
231 if err != nil {
232 return err
233 }
234 if !rebased {
235 return fmt.Errorf(
236 "branch %q is not rebased onto %q; its git rebase was aborted or never finished.\n"+
237 "If you were resolving a conflict, mark the files resolved with `git add/rm <files>`,\n"+
238 "finish it with `git rebase --continue`, then run `glab stack reorder --continue`.\n"+
239 "Otherwise abort the reorder with `glab stack reorder --abort`",
240 resumeBranch, newParentRef)
241 }
243 state.NextIndex++
244 if err := git.WriteReorderState(title, *state); err != nil {
245 return fmt.Errorf("could not update reorder state: %w", err)
246 }
248 return executeRebases(o.gr, title, state)
249}
251func (o *options) runAbort() error {
252 o.io.StartSpinner("Aborting reorder\n")
253 defer o.io.StopSpinner("")
255 title, err := git.GetCurrentStackTitle()
256 if err != nil {
257 return fmt.Errorf("error retrieving current stack title: %w", err)
258 }
260 state, err := git.ReadReorderState(title)
261 if err != nil {
262 if errors.Is(err, os.ErrNotExist) {
263 return fmt.Errorf("no reorder in progress for stack %q", title)
264 }
265 return fmt.Errorf("error reading reorder state: %w", err)
266 }
268 if state.NextIndex >= len(state.NewOrder) {
269 return fmt.Errorf(
270 "cannot abort: every branch in stack %q is already rebased, and some merge requests\n"+
271 "may already be retargeted on GitLab, which abort cannot undo.\n"+
272 "Run `glab stack reorder --continue` to finish updating the merge requests",
273 title)
274 }
276 _, _ = o.gr.Git("rebase", "--abort")
278 // Exits non-zero on a detached HEAD, where no branch is checked out.
279 current, _ := o.gr.Git("symbolic-ref", "--quiet", "--short", "HEAD")
280 current = strings.TrimSpace(current)
282 // git refuses `branch -f` on the checked-out branch, so reset it first:
283 // if --keep refuses over uncommitted changes, no other branch has moved yet.
284 if oldTip, ok := state.OldTips[current]; ok && current != state.BaseBranch {
285 if _, err := o.gr.Git("reset", "--keep", oldTip); err != nil {
286 return fmt.Errorf(
287 "could not reset %s to %s without losing uncommitted changes: %w\n"+
288 "Commit or stash them, then run `glab stack reorder --abort` again",
289 current, oldTip, err)
290 }
291 }
293 for _, branch := range slices.Sorted(maps.Keys(state.OldTips)) {
294 if branch == state.BaseBranch || branch == current {
295 continue
296 }
297 oldTip := state.OldTips[branch]
298 if _, err := o.gr.Git("branch", "-f", branch, oldTip); err != nil {
299 return fmt.Errorf("could not reset %s to %s: %w", branch, oldTip, err)
300 }
301 }
303 if _, err := o.gr.Git("checkout", state.OriginalBranch); err != nil {
304 return fmt.Errorf("could not restore branch %s: %w", state.OriginalBranch, err)
305 }
307 if err := git.DeleteReorderState(title); err != nil {
308 return fmt.Errorf("could not delete reorder state: %w", err)
309 }
311 o.io.StopSpinner("%s Reorder aborted\n", o.io.Color().GreenCheck())
312 return nil
313}
315// branchRebasedOnto reports whether branch moved off oldTip and now sits on
316// parent. The ancestor check alone is not enough: parent is often already an
317// ancestor in the old order (always, for the base branch), so a branch whose
318// rebase was aborted would pass it.
319func branchRebasedOnto(gr git.GitRunner, branch, parent, oldTip string) (bool, error) {
320 tip, err := gr.Git("rev-parse", branch)
321 if err != nil {
322 return false, fmt.Errorf("could not get tip of %s: %w", branch, err)
323 }
324 if strings.TrimSpace(tip) == oldTip {
325 return false, nil
326 }
328 // Exits non-zero when parent is not an ancestor of branch.
329 _, err = gr.Git("merge-base", "--is-ancestor", parent, branch)
330 return err == nil, nil
331}
333func prepareReorderState(gr git.GitRunner, oldStack, newStack git.Stack) (git.ReorderState, error) {
334 currentBranch, err := git.CurrentBranch()
335 if err != nil {
336 return git.ReorderState{}, fmt.Errorf("could not determine current branch: %w", err)
337 }
339 baseBranch, err := oldStack.BaseBranch(gr)
340 if err != nil {
341 return git.ReorderState{}, fmt.Errorf("could not determine base branch: %w", err)
342 }
344 oldTips := map[string]string{}
345 oldParent := map[string]string{}
346 for ref := range oldStack.Iter() {
347 tip, err := gr.Git("rev-parse", ref.Branch)
348 if err != nil {
349 return git.ReorderState{}, fmt.Errorf("could not get tip of %s: %w", ref.Branch, err)
350 }
351 oldTips[ref.Branch] = strings.TrimSpace(tip)
353 if ref.Prev == "" {
354 oldParent[ref.Branch] = baseBranch
355 } else {
356 oldParent[ref.Branch] = oldStack.Refs[ref.Prev].Branch
357 }
358 }
359 baseTip, err := gr.Git("rev-parse", baseBranch)
360 if err != nil {
361 return git.ReorderState{}, fmt.Errorf("could not get tip of base branch %s: %w", baseBranch, err)
362 }
363 oldTips[baseBranch] = strings.TrimSpace(baseTip)
365 state := git.ReorderState{
366 NewOrder: newStack.Branches(),
367 NextIndex: 0,
368 OldTips: oldTips,
369 OldParent: oldParent,
370 BaseBranch: baseBranch,
371 OriginalBranch: currentBranch,
372 OldRefs: oldStack.Refs,
373 NewRefs: newStack.Refs,
374 }
376 if err := git.WriteReorderState(oldStack.Title, state); err != nil {
377 return git.ReorderState{}, fmt.Errorf("could not write reorder state: %w", err)
378 }
380 return state, nil
381}
383func executeRebases(gr git.GitRunner, title string, state *git.ReorderState) error {
384 for i := state.NextIndex; i < len(state.NewOrder); i++ {
385 branch := state.NewOrder[i]
387 var newParentRef string
388 if i == 0 {
389 newParentRef = state.BaseBranch
390 } else {
391 newParentRef = state.NewOrder[i-1]
392 }
394 oldParentTip := state.OldTips[state.OldParent[branch]]
396 if _, err := gr.Git("checkout", branch); err != nil {
397 return fmt.Errorf("could not checkout %s: %w", branch, err)
398 }
400 if _, err := gr.Git("rebase", "--onto", newParentRef, oldParentTip); err != nil {
401 // A conflict leaves the rebase stopped partway; any other failure
402 // means git refused to start it.
403 stopErr := fmt.Errorf(
404 "could not rebase %s onto %s: %w\n"+
405 "Run `glab stack reorder --abort` to restore the original branches",
406 branch, newParentRef, err)
407 if git.RebaseInProgress() {
408 stopErr = fmt.Errorf(
409 "rebase conflict on %s onto %s.\n\n"+
410 "To continue:\n"+
411 " 1. Edit the conflicted files to resolve the conflicts\n"+
412 " (`git status` shows which files)\n"+
413 " 2. Mark them resolved: git add/rm <files>\n"+
414 " 3. Finish the git rebase: git rebase --continue\n"+
415 " 4. Resume the reorder: glab stack reorder --continue\n\n"+
416 "Or abort the reorder with:\n"+
417 " glab stack reorder --abort",
418 branch, newParentRef)
419 }
421 // Persist progress so --continue or --abort can pick up from this branch.
422 state.NextIndex = i
423 if werr := git.WriteReorderState(title, *state); werr != nil {
424 return errors.Join(stopErr, fmt.Errorf(
425 "additionally, the reorder state could not be saved, so "+
426 "`glab stack reorder --continue` may not resume correctly; "+
427 "consider `glab stack reorder --abort`: %w", werr))
428 }
429 return stopErr
430 }
432 state.NextIndex = i + 1
433 if err := git.WriteReorderState(title, *state); err != nil {
434 return fmt.Errorf("could not update reorder state: %w", err)
435 }
436 }
438 if _, err := gr.Git("checkout", state.OriginalBranch); err != nil {
439 return fmt.Errorf("could not restore branch %s: %w", state.OriginalBranch, err)
440 }
442 return nil
443}
445func rebaseInNewOrder(gr git.GitRunner, oldStack, newStack git.Stack) (git.ReorderState, error) {
446 state, err := prepareReorderState(gr, oldStack, newStack)
447 if err != nil {
448 return git.ReorderState{}, err
449 }
451 if err := executeRebases(gr, oldStack.Title, &state); err != nil {
452 return git.ReorderState{}, err
453 }
455 return state, nil
456}
458// finishReorder runs after every branch is rebased. REORDER_STATE is deleted
459// only once it succeeds, so any failure here can be retried with --continue.
460func finishReorder(ctx context.Context, f cmdutils.Factory, title string, state git.ReorderState) error {
461 for _, ref := range state.NewRefs {
462 if err := git.UpdateStackRefFile(title, ref); err != nil {
463 return fmt.Errorf(
464 "rebasing is done, but the stack ref file for %s could not be updated: %w\n"+
465 "Run `glab stack reorder --continue` to retry",
466 ref.Branch, err)
467 }
468 }
470 oldStack := git.Stack{Title: title, Refs: state.OldRefs}
471 newStack := git.Stack{Title: title, Refs: state.NewRefs}
472 if err := updateMRsForReorder(ctx, f, state.BaseBranch, newStack, oldStack); err != nil {
473 return fmt.Errorf(
474 "rebasing is done, but updating merge requests failed: %w\n"+
475 "Run `glab stack reorder --continue` to retry the merge request update",
476 err)
477 }
479 return clearReorderState(title)
480}
482// checkCleanWorktree ignores untracked files: git rebases over them unless one
483// would be overwritten, and executeRebases reports that failure itself.
484func checkCleanWorktree(gr git.GitRunner) error {
485 status, err := gr.Git("status", "--porcelain", "--untracked-files=no")
486 if err != nil {
487 return fmt.Errorf("could not check for uncommitted changes: %w", err)
488 }
489 if strings.TrimSpace(status) != "" {
490 return errors.New("you have uncommitted changes. Commit or stash them, then run the command again")
491 }
492 return nil
493}
495func clearReorderState(title string) error {
496 if err := git.DeleteReorderState(title); err != nil {
497 return fmt.Errorf(
498 "reorder finished but its state file could not be removed: %w\n"+
499 "Run `glab stack reorder --continue` to retry, otherwise other stack commands will report a reorder in progress",
500 err)
501 }
502 return nil
503}
505// updateMRsForReorder authenticates, then retargets each reordered merge
506// request onto the branch that now precedes it.
507func updateMRsForReorder(ctx context.Context, f cmdutils.Factory, baseBranch string, newStack, oldStack git.Stack) error {
508 client, err := auth.GetAuthenticatedClient(f.Config(), f.GitLabClient, f.IO())
509 if err != nil {
510 return fmt.Errorf("error authorizing with GitLab: %w", err)
511 }
513 return updateMRs(ctx, f, client, baseBranch, newStack, oldStack)
514}
516func matchBranchesToStack(stack git.Stack, branches []string) (git.Stack, error) {
517 seen := make(map[string]struct{}, len(branches))
518 for _, b := range branches {
519 if _, ok := seen[b]; ok {
520 return git.Stack{}, fmt.Errorf("duplicate branch %q in reordered list", b)
521 }
522 seen[b] = struct{}{}
523 }
525 stackBranches := stack.Branches()
527 // need to clone the refs here so we don't modify the original stack
528 newStack := git.Stack{Title: stack.Title, Refs: make(map[string]git.StackRef)}
530 for index, branch := range branches {
531 // let's find a ref from the branch
532 ref, err := stack.RefFromBranch(branch)
533 if err != nil {
534 return git.Stack{}, fmt.Errorf("could not match branch to stack ref: %w", err)
535 }
537 var next string
538 var prev string
540 if index == 0 {
541 // first branch in the stack
542 prev = ""
543 } else {
544 // otherwise, get the previous ref
545 prevRef, err := stack.RefFromBranch(branches[index-1])
546 if err != nil {
547 return git.Stack{}, err
548 }
550 prev = prevRef.SHA
551 }
553 if index == len(branches)-1 {
554 // last branch in the stack
555 next = ""
556 } else {
557 // otherwise, get the next ref
558 nextRef, err := stack.RefFromBranch(branches[index+1])
559 if err != nil {
560 return git.Stack{}, err
561 }
563 next = nextRef.SHA
564 }
566 newRef := ref
567 newRef.Next = next
568 newRef.Prev = prev
570 newStack.Refs[newRef.SHA] = newRef
572 // and remove the branch from our list
573 stackBranches = slices.DeleteFunc(stackBranches,
574 func(branch string) bool {
575 return branch == ref.Branch
576 })
577 }
579 if len(stackBranches) > 0 {
580 return git.Stack{},
581 errors.New("missing one or more refs from the reordered list: " +
582 strings.Join(stackBranches, ", "))
583 }
585 return newStack, nil
586}
588func updateMRs(ctx context.Context, f cmdutils.Factory, client *gitlab.Client, baseBranch string, newStack git.Stack, oldStack git.Stack) error {
589 for _, ref := range newStack.Iter2() {
590 if ref.MR == "" ||
591 (ref.Next == oldStack.Refs[ref.SHA].Next &&
592 ref.Prev == oldStack.Refs[ref.SHA].Prev) {
593 continue
594 }
596 mr, _, err := mrutils.MRFromArgsWithOpts(ctx, f, []string{ref.Branch}, nil, "opened")
597 if err != nil {
598 return fmt.Errorf("error getting merge request from GitLab: %w", err)
599 }
601 previousBranch := baseBranch
602 if ref.Prev != "" {
603 previousBranch = newStack.Refs[ref.Prev].Branch
604 }
606 opts := gitlab.UpdateMergeRequestOptions{TargetBranch: &previousBranch}
608 _, err = api.UpdateMR(client, mr.ProjectID, mr.IID, &opts)
609 if err != nil {
610 return fmt.Errorf("error updating merge request on GitLab: %w", err)
611 }
612 }
614 return nil
615}
Diagnostics8 git calls · 47 ms
CallStatusSizeTime047 ms
discover200185 B3 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs 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 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
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=4 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 · hit4 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=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=44Open pack map
fetchtree:02001.8 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=1857 git.response.cache=HIT git.response.duration_ms=3 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:0200432 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=432 git.response.cache=HIT git.response.duration_ms=3 git.fetch.filter=tree:0 git.fetch.wants=ff2d1e7abc74964e5679ebdb51f1ac0d0dc3aff0 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=432 git.pkt.payload.max=405 git.sideband.band1.bytes=405 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=405 git.pack.trailer=8f3029a269217d94d12d0671e0490fe3d5506303Open pack map
fetchtree:0200201 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=201 git.response.cache=HIT git.response.duration_ms=3 git.fetch.filter=tree:0 git.fetch.wants=8d987c4ced47a5d0625aad4a9e3c1ff8fbef16f4 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=201 git.pkt.payload.max=174 git.sideband.band1.bytes=174 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=174 git.pack.trailer=68708387661594a72de23ba4caed851864a875aaOpen pack map
fetch2005.3 KiB · hit33 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=33 git.response.bytes=5426 git.response.cache=HIT git.response.duration_ms=33 git.fetch.wants=27d9e77f1d5f1a675dabc89af0eeeed93ea822e2 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=5426 git.pkt.payload.max=5399 git.sideband.band1.bytes=5399 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
- a5e22e740957a594
- Request
- 95ea2869…
- 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