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
|
package ssh
import (
"errors"
"fmt"
"sync"
"github.com/grpc-ecosystem/go-grpc-middleware/logging/logrus/ctxlogrus"
log "github.com/sirupsen/logrus"
"gitlab.com/gitlab-org/gitaly/v15/internal/command"
"gitlab.com/gitlab-org/gitaly/v15/internal/git"
"gitlab.com/gitlab-org/gitaly/v15/internal/gitaly/transaction"
"gitlab.com/gitlab-org/gitaly/v15/internal/helper"
"gitlab.com/gitlab-org/gitaly/v15/internal/transaction/voting"
"gitlab.com/gitlab-org/gitaly/v15/proto/go/gitalypb"
"gitlab.com/gitlab-org/gitaly/v15/streamio"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
func (s *server) SSHReceivePack(stream gitalypb.SSHService_SSHReceivePackServer) error {
req, err := stream.Recv() // First request contains only Repository, GlId, and GlUsername
if err != nil {
return helper.ErrInternal(err)
}
ctxlogrus.Extract(stream.Context()).WithFields(log.Fields{
"GlID": req.GlId,
"GlRepository": req.GlRepository,
"GlUsername": req.GlUsername,
"GitConfigOptions": req.GitConfigOptions,
"GitProtocol": req.GitProtocol,
}).Debug("SSHReceivePack")
if err = validateFirstReceivePackRequest(req); err != nil {
return helper.ErrInvalidArgument(err)
}
if err := s.sshReceivePack(stream, req); err != nil {
return helper.ErrInternal(err)
}
return nil
}
func (s *server) sshReceivePack(stream gitalypb.SSHService_SSHReceivePackServer, req *gitalypb.SSHReceivePackRequest) error {
ctx := stream.Context()
stdin := streamio.NewReader(func() ([]byte, error) {
request, err := stream.Recv()
return request.GetStdin(), err
})
var m sync.Mutex
stdout := streamio.NewSyncWriter(&m, func(p []byte) error {
return stream.Send(&gitalypb.SSHReceivePackResponse{Stdout: p})
})
stderr := streamio.NewSyncWriter(&m, func(p []byte) error {
return stream.Send(&gitalypb.SSHReceivePackResponse{Stderr: p})
})
repoPath, err := s.locator.GetRepoPath(req.Repository)
if err != nil {
return err
}
config, err := git.ConvertConfigOptions(req.GitConfigOptions)
if err != nil {
return err
}
cmd, err := s.gitCmdFactory.NewWithoutRepo(ctx,
git.SubCmd{
Name: "receive-pack",
Args: []string{repoPath},
},
git.WithStdin(stdin),
git.WithStdout(stdout),
git.WithStderr(stderr),
git.WithReceivePackHooks(req, "ssh"),
git.WithGitProtocol(req),
git.WithConfig(config...),
)
if err != nil {
return fmt.Errorf("start cmd: %v", err)
}
if err := cmd.Wait(); err != nil {
status, ok := command.ExitStatus(err)
if !ok {
return fmt.Errorf("extracting exit status: %w", err)
}
// When the command has failed we both want to send its exit status as well as
// return an error from this RPC call. Otherwise we'd fail the RPC, but retrun with
// an `OK` error code to the client.
if errSend := stream.Send(&gitalypb.SSHReceivePackResponse{
ExitStatus: &gitalypb.ExitStatus{Value: int32(status)},
}); errSend != nil {
ctxlogrus.Extract(ctx).WithError(errSend).Error("send final status code")
}
return fmt.Errorf("cmd wait: %v", err)
}
// In cases where all reference updates are rejected by git-receive-pack(1), we would end up
// with no transactional votes at all. We thus do a final vote which concludes this RPC to
// ensure there's always at least one vote. In case there was diverging behaviour in
// git-receive-pack(1) which led to a different outcome across voters, then this final vote
// would fail because the sequence of votes would be different.
if err := transaction.VoteOnContext(ctx, s.txManager, voting.Vote{}, voting.Committed); err != nil {
// When the pre-receive hook failed, git-receive-pack(1) exits with code 0.
// It's arguable whether this is the expected behavior, but anyhow it means
// cmd.Wait() did not error out. On the other hand, the gitaly-hooks command did
// stop the transaction upon failure. So this final vote fails.
// To avoid this error being presented to the end user, ignore it when the
// transaction was stopped.
if !errors.Is(err, transaction.ErrTransactionStopped) {
return status.Errorf(codes.Aborted, "final transactional vote: %v", err)
}
}
return nil
}
func validateFirstReceivePackRequest(req *gitalypb.SSHReceivePackRequest) error {
if req.GlId == "" {
return errors.New("empty GlId")
}
if req.Stdin != nil {
return errors.New("non-empty data in first request")
}
if req.Repository == nil {
return errors.New("repository is empty")
}
return nil
}
|
