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 gitaly
import (
"context"
"fmt"
"io"
gitalyclient "gitlab.com/gitlab-org/gitaly/v16/client"
"gitlab.com/gitlab-org/gitaly/v16/proto/go/gitalypb"
"gitlab.com/gitlab-org/gitaly/v16/streamio"
)
type SmartHTTPClient struct {
sidechannelRegistry *gitalyclient.SidechannelRegistry
gitalypb.SmartHTTPServiceClient
}
func (client *SmartHTTPClient) InfoRefsResponseReader(ctx context.Context, repo *gitalypb.Repository, rpc string, gitConfigOptions []string, gitProtocol string) (io.Reader, error) {
rpcRequest := &gitalypb.InfoRefsRequest{
Repository: repo,
GitConfigOptions: gitConfigOptions,
GitProtocol: gitProtocol,
}
switch rpc {
case "git-upload-pack":
stream, err := client.InfoRefsUploadPack(ctx, rpcRequest)
return infoRefsReader(stream), err
case "git-receive-pack":
stream, err := client.InfoRefsReceivePack(ctx, rpcRequest)
return infoRefsReader(stream), err
default:
return nil, fmt.Errorf("InfoRefsResponseWriterTo: Unsupported RPC: %q", rpc)
}
}
type infoRefsClient interface {
Recv() (*gitalypb.InfoRefsResponse, error)
}
func infoRefsReader(stream infoRefsClient) io.Reader {
return streamio.NewReader(func() ([]byte, error) {
resp, err := stream.Recv()
return resp.GetData(), err
})
}
func (client *SmartHTTPClient) ReceivePack(ctx context.Context, repo *gitalypb.Repository, glId string, glUsername string, glRepository string, gitConfigOptions []string, clientRequest io.Reader, clientResponse io.Writer, gitProtocol string) error {
stream, err := client.PostReceivePack(ctx)
if err != nil {
return err
}
rpcRequest := &gitalypb.PostReceivePackRequest{
Repository: repo,
GlId: glId,
GlUsername: glUsername,
GlRepository: glRepository,
GitConfigOptions: gitConfigOptions,
GitProtocol: gitProtocol,
}
if err := stream.Send(rpcRequest); err != nil {
return fmt.Errorf("initial request: %v", err)
}
numStreams := 2
errC := make(chan error, numStreams)
go func() {
rr := streamio.NewReader(func() ([]byte, error) {
response, err := stream.Recv()
return response.GetData(), err
})
_, err := io.Copy(clientResponse, rr)
errC <- err
}()
go func() {
sw := streamio.NewWriter(func(data []byte) error {
return stream.Send(&gitalypb.PostReceivePackRequest{Data: data})
})
_, err := io.Copy(sw, clientRequest)
stream.CloseSend()
errC <- err
}()
for i := 0; i < numStreams; i++ {
if err := <-errC; err != nil {
return err
}
}
return nil
}
func (client *SmartHTTPClient) UploadPack(ctx context.Context, repo *gitalypb.Repository, clientRequest io.Reader, clientResponse io.Writer, gitConfigOptions []string, gitProtocol string) error {
ctx, waiter := client.sidechannelRegistry.Register(ctx, func(conn gitalyclient.SidechannelConn) error {
if _, err := io.Copy(conn, clientRequest); err != nil {
return fmt.Errorf("copy request body: %w", err)
}
if err := conn.CloseWrite(); err != nil {
return fmt.Errorf("close request body: %w", err)
}
if _, err := io.Copy(clientResponse, conn); err != nil {
return fmt.Errorf("copy response body: %w", err)
}
return nil
})
defer waiter.Close()
rpcRequest := &gitalypb.PostUploadPackWithSidechannelRequest{
Repository: repo,
GitConfigOptions: gitConfigOptions,
GitProtocol: gitProtocol,
}
if _, err := client.PostUploadPackWithSidechannel(ctx, rpcRequest); err != nil {
return fmt.Errorf("PostUploadPackWithSidechannel: %w", err)
}
if err := waiter.Close(); err != nil {
return fmt.Errorf("close sidechannel waiter: %w", err)
}
return nil
}
|
