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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
package commit
import (
"bytes"
"fmt"
"io"
pathPkg "path"
"path/filepath"
"strings"
"gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
"gitlab.com/gitlab-org/gitaly/internal/git/catfile"
)
const oidSize = 20
func extractEntryInfoFromTreeData(treeData *bytes.Buffer, commitOid, rootOid, rootPath string, treeInfo *catfile.ObjectInfo) ([]*gitalypb.TreeEntry, error) {
if len(treeInfo.Oid) == 0 {
return nil, fmt.Errorf("empty tree oid")
}
var entries []*gitalypb.TreeEntry
oidBuf := &bytes.Buffer{}
for treeData.Len() > 0 {
modeBytes, err := treeData.ReadBytes(' ')
if err != nil || len(modeBytes) <= 1 {
return nil, fmt.Errorf("read entry mode: %v", err)
}
modeBytes = modeBytes[:len(modeBytes)-1]
filename, err := treeData.ReadBytes('\x00')
if err != nil || len(filename) <= 1 {
return nil, fmt.Errorf("read entry path: %v", err)
}
filename = filename[:len(filename)-1]
oidBuf.Reset()
if _, err := io.CopyN(oidBuf, treeData, oidSize); err != nil {
return nil, fmt.Errorf("read entry oid: %v", err)
}
treeEntry, err := newTreeEntry(commitOid, rootOid, rootPath, filename, oidBuf.Bytes(), modeBytes)
if err != nil {
return nil, fmt.Errorf("new entry info: %v", err)
}
entries = append(entries, treeEntry)
}
return entries, nil
}
func treeEntries(c *catfile.Batch, revision, path string, rootOid string, recursive bool) ([]*gitalypb.TreeEntry, error) {
if path == "." {
path = ""
}
// If we ask 'git cat-file' for a path outside the repository tree it
// blows up with a fatal error. So, we avoid asking for this.
if strings.HasPrefix(filepath.Clean(path), "../") {
return nil, nil
}
if len(rootOid) == 0 {
rootTreeInfo, err := c.Info(revision + "^{tree}")
if err != nil {
if catfile.IsNotFound(err) {
return nil, nil
}
return nil, err
}
rootOid = rootTreeInfo.Oid
}
treeEntryInfo, err := c.Info(fmt.Sprintf("%s:%s", revision, path))
if err != nil {
if catfile.IsNotFound(err) {
return nil, nil
}
return nil, err
}
if treeEntryInfo.Type != "tree" {
return nil, nil
}
treeReader, err := c.Tree(treeEntryInfo.Oid)
if err != nil {
return nil, err
}
treeBytes := &bytes.Buffer{}
if _, err := treeBytes.ReadFrom(treeReader); err != nil {
return nil, err
}
entries, err := extractEntryInfoFromTreeData(treeBytes, revision, rootOid, path, treeEntryInfo)
if err != nil {
return nil, err
}
if !recursive {
return entries, nil
}
var orderedEntries []*gitalypb.TreeEntry
for _, entry := range entries {
orderedEntries = append(orderedEntries, entry)
if entry.Type == gitalypb.TreeEntry_TREE {
subentries, err := treeEntries(c, revision, string(entry.Path), rootOid, true)
if err != nil {
return nil, err
}
orderedEntries = append(orderedEntries, subentries...)
}
}
return orderedEntries, nil
}
// TreeEntryForRevisionAndPath returns a TreeEntry struct for the object present at the revision/path pair.
func TreeEntryForRevisionAndPath(c *catfile.Batch, revision, path string) (*gitalypb.TreeEntry, error) {
entries, err := treeEntries(c, revision, pathPkg.Dir(path), "", false)
if err != nil {
return nil, err
}
for _, entry := range entries {
if string(entry.Path) == path {
entry.RootOid = "" // Not sure why we do this
return entry, nil
}
}
return nil, nil
}
|
