1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
package lstree
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"strings"
"gitlab.com/gitlab-org/gitaly/v15/internal/git"
"gitlab.com/gitlab-org/gitaly/v15/internal/git/localrepo"
)
var (
// ErrNotExist indicates that the requested tree does not exist, either because the revision
// is invalid or because the path is not valid.
ErrNotExist = errors.New("invalid object name")
// ErrNotTreeish indicates that the requested revision or path does not resolve to a tree
// object.
ErrNotTreeish = errors.New("not treeish")
)
// ListEntriesConfig is configuration that can be passed to ListEntries.
type ListEntriesConfig struct {
// Recursive indicates whether the listing shall be recursive or not.
Recursive bool
// RelativePath is the relative path at which listing of entries should be started.
RelativePath string
}
// ListEntries lists tree entries for the given treeish. By default, this will do a non-recursive
// listing starting from the root of the given treeish. This behaviour can be changed by passing a
// config.
func ListEntries(
ctx context.Context,
repo *localrepo.Repo,
treeish git.Revision,
cfg *ListEntriesConfig,
) ([]*localrepo.TreeEntry, error) {
if cfg == nil {
cfg = &ListEntriesConfig{}
}
flags := []git.Option{git.Flag{Name: "-z"}}
if cfg.Recursive {
flags = append(flags,
git.Flag{Name: "-r"},
git.Flag{Name: "-t"},
)
}
var stderr bytes.Buffer
cmd, err := repo.Exec(ctx, git.Command{
Name: "ls-tree",
Args: []string{fmt.Sprintf("%s:%s", treeish, cfg.RelativePath)},
Flags: flags,
}, git.WithStderr(&stderr))
if err != nil {
return nil, fmt.Errorf("spawning git-ls-tree: %w", err)
}
objectHash, err := repo.ObjectHash(ctx)
if err != nil {
return nil, fmt.Errorf("detecting object hash: %w", err)
}
parser := NewParser(cmd, objectHash)
var entries []*localrepo.TreeEntry
for {
entry, err := parser.NextEntry()
if err != nil {
if errors.Is(err, io.EOF) {
break
}
return nil, fmt.Errorf("parsing tree entry: %w", err)
}
entries = append(entries, entry)
}
if err := cmd.Wait(); err != nil {
errorMessage := stderr.String()
if strings.HasPrefix(errorMessage, "fatal: not a tree object") {
return nil, ErrNotTreeish
} else if strings.HasPrefix(errorMessage, "fatal: Not a valid object name") {
return nil, ErrNotExist
}
return nil, fmt.Errorf("waiting for git-ls-tree: %w, stderr: %q", err, errorMessage)
}
return entries, nil
}
|
