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
|
package repository
import (
"context"
"errors"
"github.com/grpc-ecosystem/go-grpc-middleware/logging/logrus/ctxlogrus"
gitalyerrors "gitlab.com/gitlab-org/gitaly/v15/internal/errors"
"gitlab.com/gitlab-org/gitaly/v15/internal/git"
"gitlab.com/gitlab-org/gitaly/v15/internal/git/localrepo"
"gitlab.com/gitlab-org/gitaly/v15/internal/git/remoterepo"
"gitlab.com/gitlab-org/gitaly/v15/internal/helper"
"gitlab.com/gitlab-org/gitaly/v15/proto/go/gitalypb"
)
func validateFetchSourceBranchRequest(in *gitalypb.FetchSourceBranchRequest) error {
if in.GetRepository() == nil {
return gitalyerrors.ErrEmptyRepository
}
if err := git.ValidateRevision(in.GetSourceBranch()); err != nil {
return err
}
if err := git.ValidateRevision(in.GetTargetRef()); err != nil {
return err
}
return nil
}
func (s *server) FetchSourceBranch(ctx context.Context, req *gitalypb.FetchSourceBranchRequest) (*gitalypb.FetchSourceBranchResponse, error) {
if err := validateFetchSourceBranchRequest(req); err != nil {
return nil, helper.ErrInvalidArgument(err)
}
targetRepo := s.localrepo(req.GetRepository())
sourceRepo, err := remoterepo.New(ctx, req.GetSourceRepository(), s.conns)
if err != nil {
return nil, helper.ErrInternal(err)
}
var sourceOid git.ObjectID
var containsObject bool
// If source and target repository are the same, then we know that both
// are local. We can thus optimize and locally resolve the reference
// instead of using an RPC call. We also know that we can always skip
// the fetch as the object will be available.
if helper.RepoPathEqual(req.GetRepository(), req.GetSourceRepository()) {
var err error
sourceOid, err = targetRepo.ResolveRevision(ctx, git.Revision(req.GetSourceBranch()))
if err != nil {
if errors.Is(err, git.ErrReferenceNotFound) {
return &gitalypb.FetchSourceBranchResponse{Result: false}, nil
}
return nil, helper.ErrInternal(err)
}
containsObject = true
} else {
var err error
sourceOid, err = sourceRepo.ResolveRevision(ctx, git.Revision(req.GetSourceBranch()))
if err != nil {
if errors.Is(err, git.ErrReferenceNotFound) {
return &gitalypb.FetchSourceBranchResponse{Result: false}, nil
}
return nil, helper.ErrInternal(err)
}
// Otherwise, if the source is a remote repository, we check
// whether the target repo already contains the desired object.
// If so, we can skip the fetch.
containsObject, err = targetRepo.HasRevision(ctx, sourceOid.Revision()+"^{commit}")
if err != nil {
return nil, helper.ErrInternal(err)
}
}
// There's no need to perform the fetch if we already have the object
// available.
if !containsObject {
if err := targetRepo.FetchInternal(
ctx,
req.GetSourceRepository(),
[]string{sourceOid.String()},
localrepo.FetchOpts{Tags: localrepo.FetchOptsTagsNone},
); err != nil {
// Design quirk: if the fetch fails, this RPC returns Result: false, but no error.
if errors.As(err, &localrepo.ErrFetchFailed{}) {
ctxlogrus.Extract(ctx).
WithField("oid", sourceOid.String()).
WithError(err).Warn("git fetch failed")
return &gitalypb.FetchSourceBranchResponse{Result: false}, nil
}
return nil, err
}
}
if err := targetRepo.UpdateRef(ctx, git.ReferenceName(req.GetTargetRef()), sourceOid, ""); err != nil {
return nil, err
}
return &gitalypb.FetchSourceBranchResponse{Result: true}, nil
}
|
