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
|
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/gitaly/service"
"gitlab.com/gitlab-org/gitaly/v15/internal/structerr"
"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, structerr.NewInvalidArgument("%w", err)
}
repo := s.localrepo(in.GetRepository())
tag, err := s.findTag(ctx, repo, in.GetTagName())
if err != nil {
return nil, structerr.NewInternal("%w", 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.ObjectContentReader, 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: %w", 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: %w", 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.Command{
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: %w", err)
}
objectReader, cancel, err := s.catfileCache.ObjectReader(ctx, repo)
if err != nil {
return nil, fmt.Errorf("creating object reader: %w", 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, fmt.Errorf("parsing tag: %w", err)
}
} else {
return nil, structerr.NewNotFound("tag does not exist").WithDetail(
&gitalypb.FindTagError{
Error: &gitalypb.FindTagError_TagNotFound{
TagNotFound: &gitalypb.ReferenceNotFoundError{
ReferenceName: []byte(fmt.Sprintf("refs/tags/%s", tagName)),
},
},
},
)
}
if err = tagCmd.Wait(); err != nil {
return nil, err
}
return tag, nil
}
func (s *server) validateFindTagRequest(in *gitalypb.FindTagRequest) error {
repository := in.GetRepository()
if err := service.ValidateRepository(repository); err != nil {
return err
}
if _, err := s.locator.GetRepoPath(repository); err != nil {
return fmt.Errorf("invalid git directory: %w", err)
}
if in.GetTagName() == nil {
return errors.New("tag name is empty")
}
return nil
}
|