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
|
package ref
import (
"bufio"
"context"
"errors"
"fmt"
"strings"
"gitlab.com/gitlab-org/gitaly/v15/internal/git"
"gitlab.com/gitlab-org/gitaly/v15/internal/git/catfile"
"gitlab.com/gitlab-org/gitaly/v15/internal/helper"
"gitlab.com/gitlab-org/gitaly/v15/internal/metadata/featureflag"
"gitlab.com/gitlab-org/gitaly/v15/proto/go/gitalypb"
)
func (s *server) FindTag(ctx context.Context, in *gitalypb.FindTagRequest) (*gitalypb.FindTagResponse, error) {
if err := s.validateFindTagRequest(in); err != nil {
return nil, helper.ErrInvalidArgument(err)
}
repo := s.localrepo(in.GetRepository())
tag, err := s.findTag(ctx, repo, in.GetTagName())
if err != nil {
return nil, helper.ErrInternal(err)
}
return &gitalypb.FindTagResponse{Tag: tag}, nil
}
// parseTagLine parses a line of text with the output format %(objectname) %(objecttype) %(refname:lstrip=2)
func parseTagLine(ctx context.Context, objectReader catfile.ObjectReader, tagLine string) (*gitalypb.Tag, error) {
fields := strings.SplitN(tagLine, " ", 3)
if len(fields) != 3 {
return nil, fmt.Errorf("invalid output from for-each-ref command: %v", tagLine)
}
tagID, refType, refName := fields[0], fields[1], fields[2]
tag := &gitalypb.Tag{
Id: tagID,
Name: []byte(refName),
}
switch refType {
// annotated tag
case "tag":
tag, err := catfile.GetTag(ctx, objectReader, git.Revision(tagID), refName)
if err != nil {
return nil, fmt.Errorf("getting annotated tag: %v", err)
}
catfile.TrimTagMessage(tag)
return tag, nil
case "commit":
commit, err := catfile.GetCommit(ctx, objectReader, git.Revision(tagID))
if err != nil {
return nil, fmt.Errorf("getting commit catfile: %v", err)
}
tag.TargetCommit = commit
return tag, nil
default:
return tag, nil
}
}
func (s *server) findTag(ctx context.Context, repo git.RepositoryExecutor, tagName []byte) (*gitalypb.Tag, error) {
tagCmd, err := repo.Exec(ctx,
git.SubCmd{
Name: "tag",
Flags: []git.Option{
git.Flag{Name: "-l"}, git.ValueFlag{Name: "--format", Value: tagFormat},
},
Args: []string{string(tagName)},
},
git.WithRefTxHook(repo),
)
if err != nil {
return nil, fmt.Errorf("for-each-ref error: %v", err)
}
objectReader, cancel, err := s.catfileCache.ObjectReader(ctx, repo)
if err != nil {
return nil, err
}
defer cancel()
var tag *gitalypb.Tag
scanner := bufio.NewScanner(tagCmd)
if scanner.Scan() {
tag, err = parseTagLine(ctx, objectReader, scanner.Text())
if err != nil {
return nil, err
}
} else {
if featureflag.FindTagStructuredError.IsEnabled(ctx) {
detailedErr, err := helper.ErrWithDetails(
helper.ErrNotFoundf("tag does not exist"),
&gitalypb.FindTagError{
Error: &gitalypb.FindTagError_TagNotFound{
TagNotFound: &gitalypb.ReferenceNotFoundError{
ReferenceName: []byte(fmt.Sprintf("refs/tags/%s", tagName)),
},
},
},
)
if err != nil {
return nil, helper.ErrInternalf("generating detailed error: %w", err)
}
return nil, detailedErr
}
return nil, errors.New("no tag found")
}
if err = tagCmd.Wait(); err != nil {
return nil, err
}
return tag, nil
}
func (s *server) validateFindTagRequest(in *gitalypb.FindTagRequest) error {
if in.GetRepository() == nil {
return errors.New("repository is empty")
}
if _, err := s.locator.GetRepoPath(in.GetRepository()); err != nil {
return fmt.Errorf("invalid git directory: %v", err)
}
if in.GetTagName() == nil {
return errors.New("tag name is empty")
}
return nil
}
|
