Commit 602f461a authored by Jacob Vosmaer (GitLab)'s avatar Jacob Vosmaer (GitLab)

Merge branch '156-raw-archive' into 'master'

Bridge between Gitaly and GitLab for a new repository snapshot endpoint

Closes #156

See merge request gitlab-org/gitlab-workhorse!248
parents 9c54fcc3 b0798c9b
......@@ -2,6 +2,7 @@ package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"math/rand"
......@@ -22,6 +23,8 @@ import (
pb "gitlab.com/gitlab-org/gitaly-proto/go"
"github.com/golang/protobuf/jsonpb"
"github.com/golang/protobuf/proto"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"google.golang.org/grpc"
......@@ -579,6 +582,106 @@ func TestGetPatchProxiedToGitalyInterruptedStream(t *testing.T) {
}
}
func TestGetSnapshotProxiedToGitalySuccessfully(t *testing.T) {
gitalyServer, socketPath := startGitalyServer(t, codes.OK)
defer gitalyServer.Stop()
gitalyAddress := "unix://" + socketPath
expectedBody := testhelper.GitalyGetSnapshotResponseMock
archiveLength := len(expectedBody)
params := buildGetSnapshotParams(gitalyAddress, buildPbRepo("default", "foo/bar.git"))
resp, body, err := doSendDataRequest("/api/v4/projects/:id/snapshot", "git-snapshot", params)
require.NoError(t, err)
assert.Equal(t, http.StatusOK, resp.StatusCode, "GET %q: status code", resp.Request.URL)
assert.Equal(t, expectedBody, string(body), "GET %q: body", resp.Request.URL)
assert.Equal(t, archiveLength, len(body), "GET %q: body size", resp.Request.URL)
testhelper.AssertResponseHeader(t, resp, "Content-Disposition", `attachment; filename="snapshot.tar"`)
testhelper.AssertResponseHeader(t, resp, "Content-Type", "application/x-tar")
testhelper.AssertResponseHeader(t, resp, "Content-Transfer-Encoding", "binary")
testhelper.AssertResponseHeader(t, resp, "Cache-Control", "private")
}
func TestGetSnapshotProxiedToGitalyInterruptedStream(t *testing.T) {
gitalyServer, socketPath := startGitalyServer(t, codes.OK)
defer gitalyServer.Stop()
gitalyAddress := "unix://" + socketPath
params := buildGetSnapshotParams(gitalyAddress, buildPbRepo("default", "foo/bar.git"))
resp, _, err := doSendDataRequest("/api/v4/projects/:id/snapshot", "git-snapshot", params)
require.NoError(t, err)
// This causes the server stream to be interrupted instead of consumed entirely.
resp.Body.Close()
done := make(chan struct{})
go func() {
gitalyServer.WaitGroup.Wait()
close(done)
}()
select {
case <-done:
return
case <-time.After(10 * time.Second):
t.Fatal("time out waiting for gitaly handler to return")
}
}
func buildGetSnapshotParams(gitalyAddress string, repo *pb.Repository) string {
msg := serializedMessage("GetSnapshotRequest", &pb.GetSnapshotRequest{Repository: repo})
return buildGitalyRpcParams(gitalyAddress, msg)
}
type rpcArg struct {
k string
v interface{}
}
// Gitlab asks workhorse to perform some long-running RPCs for it by sending
// the RPC arguments (which are protobuf messages) in HTTP response headers.
// The messages are encoded to JSON objects using pbjson, The strings are then
// re-encoded to JSON strings using json. We must replicate this behaviour here
func buildGitalyRpcParams(gitalyAddress string, rpcArgs ...rpcArg) string {
built := map[string]interface{}{
"GitalyServer": map[string]string{
"Address": gitalyAddress,
"Token": "",
},
}
for _, arg := range rpcArgs {
built[arg.k] = arg.v
}
b, err := json.Marshal(interface{}(built))
if err != nil {
panic(err)
}
return string(b)
}
func buildPbRepo(storageName, relativePath string) *pb.Repository {
return &pb.Repository{
StorageName: storageName,
RelativePath: relativePath,
}
}
func serializedMessage(name string, arg proto.Message) rpcArg {
m := &jsonpb.Marshaler{}
str, err := m.MarshalToString(arg)
if err != nil {
panic(err)
}
return rpcArg{name, str}
}
type combinedServer struct {
*grpc.Server
*testhelper.GitalyTestServer
......
package git
import (
"fmt"
"io"
"net/http"
"github.com/golang/protobuf/jsonpb"
pb "gitlab.com/gitlab-org/gitaly-proto/go"
"gitlab.com/gitlab-org/gitlab-workhorse/internal/gitaly"
"gitlab.com/gitlab-org/gitlab-workhorse/internal/helper"
"gitlab.com/gitlab-org/gitlab-workhorse/internal/senddata"
)
type snapshot struct {
senddata.Prefix
}
type snapshotParams struct {
GitalyServer gitaly.Server
GetSnapshotRequest string
}
var (
SendSnapshot = &snapshot{"git-snapshot:"}
)
func (s *snapshot) Inject(w http.ResponseWriter, r *http.Request, sendData string) {
var params snapshotParams
if err := s.Unpack(&params, sendData); err != nil {
helper.Fail500(w, r, fmt.Errorf("SendSnapshot: unpack sendData: %v", err))
return
}
request := &pb.GetSnapshotRequest{}
if err := jsonpb.UnmarshalString(params.GetSnapshotRequest, request); err != nil {
helper.Fail500(w, r, fmt.Errorf("SendSnapshot: unmarshal GetSnapshotRequest: %v", err))
return
}
c, err := gitaly.NewRepositoryClient(params.GitalyServer)
if err != nil {
helper.Fail500(w, r, fmt.Errorf("SendSnapshot: gitaly.NewRepositoryClient: %v", err))
return
}
reader, err := c.SnapshotReader(r.Context(), request)
if err != nil {
helper.Fail500(w, r, fmt.Errorf("SendSnapshot: client.SnapshotReader: %v", err))
return
}
w.Header().Del("Content-Length")
w.Header().Set("Content-Disposition", `attachment; filename="snapshot.tar"`)
w.Header().Set("Content-Type", "application/x-tar")
w.Header().Set("Content-Transfer-Encoding", "binary")
w.Header().Set("Cache-Control", "private")
w.WriteHeader(http.StatusOK) // Errors aren't detectable beyond this point
if _, err := io.Copy(w, reader); err != nil {
helper.LogError(r, fmt.Errorf("SendSnapshot: copy gitaly output: %v", err))
}
return
}
......@@ -28,3 +28,18 @@ func (client *RepositoryClient) ArchiveReader(ctx context.Context, request *pb.G
return resp.GetData(), err
}), nil
}
// SnapshotReader performs a GetSnapshot Gitaly request and returns an io.Reader
// for the response
func (client *RepositoryClient) SnapshotReader(ctx context.Context, request *pb.GetSnapshotRequest) (io.Reader, error) {
c, err := client.GetSnapshot(ctx, request)
if err != nil {
return nil, fmt.Errorf("RepositoryService::GetSnapshot: %v", err)
}
return streamio.NewReader(func() ([]byte, error) {
resp, err := c.Recv()
return resp.GetData(), err
}), nil
}
......@@ -23,11 +23,14 @@ type GitalyTestServer struct {
}
var (
GitalyInfoRefsResponseMock = strings.Repeat("Mock Gitaly InfoRefsResponse data", 100000)
GitalyGetBlobResponseMock = strings.Repeat("Mock Gitaly GetBlobResponse data", 100000)
GitalyGetArchiveResponseMock = strings.Repeat("Mock Gitaly GetArchiveResponse data", 100000)
GitalyGetDiffResponseMock = strings.Repeat("Mock Gitaly GetDiffResponse data", 100000)
GitalyGetPatchResponseMock = strings.Repeat("Mock Gitaly GetPatchResponse data", 100000)
GitalyInfoRefsResponseMock = strings.Repeat("Mock Gitaly InfoRefsResponse data", 100000)
GitalyGetBlobResponseMock = strings.Repeat("Mock Gitaly GetBlobResponse data", 100000)
GitalyGetArchiveResponseMock = strings.Repeat("Mock Gitaly GetArchiveResponse data", 100000)
GitalyGetDiffResponseMock = strings.Repeat("Mock Gitaly GetDiffResponse data", 100000)
GitalyGetPatchResponseMock = strings.Repeat("Mock Gitaly GetPatchResponse data", 100000)
GitalyGetSnapshotResponseMock = strings.Repeat("Mock Gitaly GetSnapshotResponse data", 100000)
GitalyReceivePackResponseMock []byte
GitalyUploadPackResponseMock []byte
)
......@@ -280,6 +283,27 @@ func (s *GitalyTestServer) RawPatch(in *pb.RawPatchRequest, stream pb.DiffServic
return s.finalError()
}
func (s *GitalyTestServer) GetSnapshot(in *pb.GetSnapshotRequest, stream pb.RepositoryService_GetSnapshotServer) error {
s.WaitGroup.Add(1)
defer s.WaitGroup.Done()
if err := validateRepository(in.GetRepository()); err != nil {
return err
}
nSends, err := sendBytes([]byte(GitalyGetSnapshotResponseMock), 100, func(p []byte) error {
return stream.Send(&pb.GetSnapshotResponse{Data: p})
})
if err != nil {
return err
}
if nSends <= 1 {
panic("should have sent more than one message")
}
return s.finalError()
}
func (s *GitalyTestServer) RepositoryExists(context.Context, *pb.RepositoryExistsRequest) (*pb.RepositoryExistsResponse, error) {
return nil, nil
}
......@@ -408,6 +432,10 @@ func (s *GitalyTestServer) Cleanup(context.Context, *pb.CleanupRequest) (*pb.Cle
return nil, nil
}
func (s *GitalyTestServer) CreateRepositoryFromSnapshot(context.Context, *pb.CreateRepositoryFromSnapshotRequest) (*pb.CreateRepositoryFromSnapshotResponse, error) {
return nil, nil
}
// sendBytes returns the number of times the 'sender' function was called and an error.
func sendBytes(data []byte, chunkSize int, sender func([]byte) error) (int, error) {
i := 0
......
......@@ -140,6 +140,7 @@ func (u *Upstream) configureRoutes() {
git.SendBlob,
git.SendDiff,
git.SendPatch,
git.SendSnapshot,
artifacts.SendEntry,
sendurl.SendURL,
)
......
......@@ -219,6 +219,10 @@ It has these top-level messages:
GetInfoAttributesResponse
CalculateChecksumRequest
CalculateChecksumResponse
GetSnapshotRequest
GetSnapshotResponse
CreateRepositoryFromSnapshotRequest
CreateRepositoryFromSnapshotResponse
ServerInfoRequest
ServerInfoResponse
Repository
......
......@@ -1003,6 +1003,82 @@ func (m *CalculateChecksumResponse) GetChecksum() string {
return ""
}
type GetSnapshotRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
}
func (m *GetSnapshotRequest) Reset() { *m = GetSnapshotRequest{} }
func (m *GetSnapshotRequest) String() string { return proto.CompactTextString(m) }
func (*GetSnapshotRequest) ProtoMessage() {}
func (*GetSnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{50} }
func (m *GetSnapshotRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
type GetSnapshotResponse struct {
Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
}
func (m *GetSnapshotResponse) Reset() { *m = GetSnapshotResponse{} }
func (m *GetSnapshotResponse) String() string { return proto.CompactTextString(m) }
func (*GetSnapshotResponse) ProtoMessage() {}
func (*GetSnapshotResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{51} }
func (m *GetSnapshotResponse) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
type CreateRepositoryFromSnapshotRequest struct {
Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
HttpUrl string `protobuf:"bytes,2,opt,name=http_url,json=httpUrl" json:"http_url,omitempty"`
HttpAuth string `protobuf:"bytes,3,opt,name=http_auth,json=httpAuth" json:"http_auth,omitempty"`
}
func (m *CreateRepositoryFromSnapshotRequest) Reset() { *m = CreateRepositoryFromSnapshotRequest{} }
func (m *CreateRepositoryFromSnapshotRequest) String() string { return proto.CompactTextString(m) }
func (*CreateRepositoryFromSnapshotRequest) ProtoMessage() {}
func (*CreateRepositoryFromSnapshotRequest) Descriptor() ([]byte, []int) {
return fileDescriptor10, []int{52}
}
func (m *CreateRepositoryFromSnapshotRequest) GetRepository() *Repository {
if m != nil {
return m.Repository
}
return nil
}
func (m *CreateRepositoryFromSnapshotRequest) GetHttpUrl() string {
if m != nil {
return m.HttpUrl
}
return ""
}
func (m *CreateRepositoryFromSnapshotRequest) GetHttpAuth() string {
if m != nil {
return m.HttpAuth
}
return ""
}
type CreateRepositoryFromSnapshotResponse struct {
}
func (m *CreateRepositoryFromSnapshotResponse) Reset() { *m = CreateRepositoryFromSnapshotResponse{} }
func (m *CreateRepositoryFromSnapshotResponse) String() string { return proto.CompactTextString(m) }
func (*CreateRepositoryFromSnapshotResponse) ProtoMessage() {}
func (*CreateRepositoryFromSnapshotResponse) Descriptor() ([]byte, []int) {
return fileDescriptor10, []int{53}
}
func init() {
proto.RegisterType((*RepositoryExistsRequest)(nil), "gitaly.RepositoryExistsRequest")
proto.RegisterType((*RepositoryExistsResponse)(nil), "gitaly.RepositoryExistsResponse")
......@@ -1054,6 +1130,10 @@ func init() {
proto.RegisterType((*GetInfoAttributesResponse)(nil), "gitaly.GetInfoAttributesResponse")
proto.RegisterType((*CalculateChecksumRequest)(nil), "gitaly.CalculateChecksumRequest")
proto.RegisterType((*CalculateChecksumResponse)(nil), "gitaly.CalculateChecksumResponse")
proto.RegisterType((*GetSnapshotRequest)(nil), "gitaly.GetSnapshotRequest")
proto.RegisterType((*GetSnapshotResponse)(nil), "gitaly.GetSnapshotResponse")
proto.RegisterType((*CreateRepositoryFromSnapshotRequest)(nil), "gitaly.CreateRepositoryFromSnapshotRequest")
proto.RegisterType((*CreateRepositoryFromSnapshotResponse)(nil), "gitaly.CreateRepositoryFromSnapshotResponse")
proto.RegisterEnum("gitaly.GetArchiveRequest_Format", GetArchiveRequest_Format_name, GetArchiveRequest_Format_value)
}
......@@ -1093,6 +1173,8 @@ type RepositoryServiceClient interface {
GetInfoAttributes(ctx context.Context, in *GetInfoAttributesRequest, opts ...grpc.CallOption) (RepositoryService_GetInfoAttributesClient, error)
CalculateChecksum(ctx context.Context, in *CalculateChecksumRequest, opts ...grpc.CallOption) (*CalculateChecksumResponse, error)
Cleanup(ctx context.Context, in *CleanupRequest, opts ...grpc.CallOption) (*CleanupResponse, error)
GetSnapshot(ctx context.Context, in *GetSnapshotRequest, opts ...grpc.CallOption) (RepositoryService_GetSnapshotClient, error)
CreateRepositoryFromSnapshot(ctx context.Context, in *CreateRepositoryFromSnapshotRequest, opts ...grpc.CallOption) (*CreateRepositoryFromSnapshotResponse, error)
}
type repositoryServiceClient struct {
......@@ -1422,6 +1504,47 @@ func (c *repositoryServiceClient) Cleanup(ctx context.Context, in *CleanupReques
return out, nil
}
func (c *repositoryServiceClient) GetSnapshot(ctx context.Context, in *GetSnapshotRequest, opts ...grpc.CallOption) (RepositoryService_GetSnapshotClient, error) {
stream, err := grpc.NewClientStream(ctx, &_RepositoryService_serviceDesc.Streams[4], c.cc, "/gitaly.RepositoryService/GetSnapshot", opts...)
if err != nil {
return nil, err
}
x := &repositoryServiceGetSnapshotClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type RepositoryService_GetSnapshotClient interface {
Recv() (*GetSnapshotResponse, error)
grpc.ClientStream
}
type repositoryServiceGetSnapshotClient struct {
grpc.ClientStream
}
func (x *repositoryServiceGetSnapshotClient) Recv() (*GetSnapshotResponse, error) {
m := new(GetSnapshotResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *repositoryServiceClient) CreateRepositoryFromSnapshot(ctx context.Context, in *CreateRepositoryFromSnapshotRequest, opts ...grpc.CallOption) (*CreateRepositoryFromSnapshotResponse, error) {
out := new(CreateRepositoryFromSnapshotResponse)
err := grpc.Invoke(ctx, "/gitaly.RepositoryService/CreateRepositoryFromSnapshot", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for RepositoryService service
type RepositoryServiceServer interface {
......@@ -1450,6 +1573,8 @@ type RepositoryServiceServer interface {
GetInfoAttributes(*GetInfoAttributesRequest, RepositoryService_GetInfoAttributesServer) error
CalculateChecksum(context.Context, *CalculateChecksumRequest) (*CalculateChecksumResponse, error)
Cleanup(context.Context, *CleanupRequest) (*CleanupResponse, error)
GetSnapshot(*GetSnapshotRequest, RepositoryService_GetSnapshotServer) error
CreateRepositoryFromSnapshot(context.Context, *CreateRepositoryFromSnapshotRequest) (*CreateRepositoryFromSnapshotResponse, error)
}
func RegisterRepositoryServiceServer(s *grpc.Server, srv RepositoryServiceServer) {
......@@ -1923,6 +2048,45 @@ func _RepositoryService_Cleanup_Handler(srv interface{}, ctx context.Context, de
return interceptor(ctx, in, info, handler)
}
func _RepositoryService_GetSnapshot_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(GetSnapshotRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(RepositoryServiceServer).GetSnapshot(m, &repositoryServiceGetSnapshotServer{stream})
}
type RepositoryService_GetSnapshotServer interface {
Send(*GetSnapshotResponse) error
grpc.ServerStream
}
type repositoryServiceGetSnapshotServer struct {
grpc.ServerStream
}
func (x *repositoryServiceGetSnapshotServer) Send(m *GetSnapshotResponse) error {
return x.ServerStream.SendMsg(m)
}
func _RepositoryService_CreateRepositoryFromSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateRepositoryFromSnapshotRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(RepositoryServiceServer).CreateRepositoryFromSnapshot(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/gitaly.RepositoryService/CreateRepositoryFromSnapshot",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(RepositoryServiceServer).CreateRepositoryFromSnapshot(ctx, req.(*CreateRepositoryFromSnapshotRequest))
}
return interceptor(ctx, in, info, handler)
}
var _RepositoryService_serviceDesc = grpc.ServiceDesc{
ServiceName: "gitaly.RepositoryService",
HandlerType: (*RepositoryServiceServer)(nil),
......@@ -2011,6 +2175,10 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
MethodName: "Cleanup",
Handler: _RepositoryService_Cleanup_Handler,
},
{
MethodName: "CreateRepositoryFromSnapshot",
Handler: _RepositoryService_CreateRepositoryFromSnapshot_Handler,
},
},
Streams: []grpc.StreamDesc{
{
......@@ -2033,6 +2201,11 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
Handler: _RepositoryService_GetInfoAttributes_Handler,
ServerStreams: true,
},
{
StreamName: "GetSnapshot",
Handler: _RepositoryService_GetSnapshot_Handler,
ServerStreams: true,
},
},
Metadata: "repository-service.proto",
}
......@@ -2040,105 +2213,112 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("repository-service.proto", fileDescriptor10) }
var fileDescriptor10 = []byte{
// 1587 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0xef, 0x6e, 0xdb, 0x36,
0x10, 0xb7, 0xf3, 0xd7, 0xbe, 0xb8, 0xad, 0xc3, 0xfc, 0x93, 0x95, 0xb4, 0x49, 0xb8, 0x62, 0xcb,
0xda, 0x2e, 0x28, 0x92, 0x0f, 0x1b, 0xb0, 0x0d, 0x45, 0x92, 0x35, 0x89, 0xd7, 0xa6, 0xc8, 0x94,
0x0e, 0x05, 0x82, 0x0d, 0x86, 0x22, 0xd3, 0xb6, 0x60, 0x59, 0x72, 0x49, 0x2a, 0x6d, 0xfa, 0x79,
0x1f, 0xf6, 0x5c, 0x7d, 0x85, 0x3d, 0xc6, 0x5e, 0x62, 0x10, 0x45, 0x89, 0x92, 0x25, 0x65, 0x05,
0xd4, 0x61, 0xdf, 0xc4, 0xe3, 0xf1, 0x77, 0xa7, 0x3b, 0xde, 0xe9, 0x77, 0x02, 0x8d, 0x92, 0xb1,
0xc7, 0x6c, 0xee, 0xd1, 0x9b, 0x6f, 0x18, 0xa1, 0xd7, 0xb6, 0x45, 0x76, 0xc7, 0xd4, 0xe3, 0x1e,
0x9a, 0xeb, 0xdb, 0xdc, 0x74, 0x6e, 0xf4, 0x06, 0x1b, 0x98, 0x94, 0x74, 0x43, 0x29, 0x3e, 0x83,
0x35, 0x23, 0x3e, 0xf1, 0xfc, 0xbd, 0xcd, 0x38, 0x33, 0xc8, 0x5b, 0x9f, 0x30, 0x8e, 0xf6, 0x00,
0x14, 0x98, 0x56, 0xdd, 0xaa, 0xee, 0x2c, 0xec, 0xa1, 0xdd, 0x10, 0x65, 0x57, 0x1d, 0x32, 0x12,
0x5a, 0x78, 0x0f, 0xb4, 0x2c, 0x1c, 0x1b, 0x7b, 0x2e, 0x23, 0x68, 0x15, 0xe6, 0x88, 0x90, 0x08,
0xac, 0x9a, 0x21, 0x57, 0xf8, 0x95, 0x38, 0x63, 0x5a, 0xc3, 0xb6, 0x6b, 0x51, 0x32, 0x22, 0x2e,
0x37, 0x9d, 0x32, 0x3e, 0xac, 0x43, 0x2b, 0x07, 0x2f, 0x74, 0x02, 0x3b, 0xb0, 0x18, 0x6e, 0x1e,
0xfb, 0x4e, 0x19, 0x2b, 0xe8, 0x0b, 0xb8, 0x63, 0x51, 0x62, 0x72, 0xd2, 0xb9, 0xb2, 0xf9, 0xc8,
0x1c, 0x6b, 0x53, 0xe2, 0xa5, 0x1a, 0xa1, 0xf0, 0x50, 0xc8, 0xf0, 0x32, 0xa0, 0xa4, 0x35, 0xe9,
0xc3, 0x18, 0x56, 0x4e, 0x4c, 0x7a, 0x65, 0xf6, 0xc9, 0x91, 0xe7, 0x38, 0xc4, 0xe2, 0xff, 0xb9,
0x1f, 0x1a, 0xac, 0x4e, 0x5a, 0x94, 0xbe, 0xfc, 0x04, 0x77, 0x8f, 0x1c, 0x62, 0xba, 0xfe, 0xb8,
0x4c, 0xc8, 0x17, 0xe1, 0x5e, 0x8c, 0x22, 0x81, 0x5f, 0xc0, 0x8a, 0x52, 0xbe, 0xb0, 0x3f, 0x90,
0x32, 0xf8, 0x4f, 0x60, 0x75, 0x12, 0x4c, 0x5e, 0x2a, 0x04, 0x33, 0xcc, 0xfe, 0x40, 0x04, 0xce,
0xb4, 0x21, 0x9e, 0xf1, 0x10, 0x5a, 0x07, 0xe3, 0xb1, 0x73, 0x73, 0x62, 0x73, 0x93, 0x73, 0x6a,
0x5f, 0xf9, 0x9c, 0x94, 0xb9, 0xd5, 0x48, 0x87, 0x1a, 0x25, 0xd7, 0x36, 0xb3, 0x3d, 0x57, 0x84,
0xb7, 0x61, 0xc4, 0x6b, 0xbc, 0x01, 0x7a, 0x9e, 0x31, 0x19, 0x85, 0x3f, 0xa6, 0x00, 0x1d, 0x13,
0x6e, 0x0d, 0x0c, 0x32, 0xf2, 0x78, 0x99, 0x18, 0x04, 0xe5, 0x43, 0x05, 0x88, 0x70, 0xa1, 0x6e,
0xc8, 0x15, 0x5a, 0x86, 0xd9, 0x9e, 0x47, 0x2d, 0xa2, 0x4d, 0x8b, 0xc4, 0x87, 0x0b, 0xb4, 0x06,
0xf3, 0xae, 0xd7, 0xe1, 0x66, 0x9f, 0x69, 0x33, 0x61, 0xb5, 0xb9, 0xde, 0x6b, 0xb3, 0xcf, 0x90,
0x06, 0xf3, 0xdc, 0x1e, 0x11, 0xcf, 0xe7, 0xda, 0xec, 0x56, 0x75, 0x67, 0xd6, 0x88, 0x96, 0xc1,
0x11, 0xc6, 0x06, 0x9d, 0x21, 0xb9, 0xd1, 0xe6, 0x42, 0x0b, 0x8c, 0x0d, 0x5e, 0x90, 0x1b, 0xb4,
0x09, 0x0b, 0x43, 0xd7, 0x7b, 0xe7, 0x76, 0x06, 0x5e, 0x50, 0xbd, 0xf3, 0x62, 0x13, 0x84, 0xe8,
0x34, 0x90, 0xa0, 0x16, 0xd4, 0x5c, 0xaf, 0x33, 0xa6, 0xbe, 0x4b, 0xb4, 0xba, 0xb0, 0x36, 0xef,
0x7a, 0xe7, 0xc1, 0xf2, 0xe7, 0x99, 0x5a, 0xad, 0x59, 0xc7, 0x2b, 0xb0, 0x94, 0x8a, 0x82, 0x8c,
0xce, 0x19, 0xac, 0x1d, 0x89, 0x6b, 0x9a, 0x78, 0xe5, 0x12, 0xb7, 0x44, 0x07, 0x2d, 0x0b, 0x27,
0x4d, 0xfd, 0x5d, 0x85, 0xc5, 0x13, 0xc2, 0x0f, 0xa8, 0x35, 0xb0, 0xaf, 0x4b, 0xe5, 0x61, 0x1d,
0xea, 0x96, 0x37, 0x1a, 0xd9, 0xbc, 0x63, 0x77, 0x65, 0x2a, 0x6a, 0xa1, 0xa0, 0xdd, 0x0d, 0x92,
0x34, 0xa6, 0xa4, 0x67, 0xbf, 0x17, 0xd9, 0xa8, 0x1b, 0x72, 0x85, 0xbe, 0x83, 0xb9, 0x9e, 0x47,
0x47, 0x26, 0x17, 0xd9, 0xb8, 0xbb, 0xb7, 0x15, 0x19, 0xc9, 0xf8, 0xb4, 0x7b, 0x2c, 0xf4, 0x0c,
0xa9, 0x8f, 0xf7, 0x61, 0x2e, 0x94, 0xa0, 0x79, 0x98, 0xbe, 0x6c, 0x9f, 0x37, 0x2b, 0xc1, 0xc3,
0xeb, 0x03, 0xa3, 0x59, 0x45, 0x00, 0x73, 0xaf, 0x0f, 0x8c, 0xce, 0xc9, 0x65, 0x73, 0x0a, 0x2d,
0xc0, 0x7c, 0xf0, 0x7c, 0x78, 0xb9, 0xd7, 0x9c, 0xc6, 0x3b, 0x80, 0x92, 0xc0, 0xaa, 0x56, 0xba,
0x26, 0x37, 0xc5, 0x7b, 0x36, 0x0c, 0xf1, 0x1c, 0xa4, 0xe0, 0xd4, 0x64, 0x2f, 0x3d, 0xcb, 0x74,
0x0e, 0xa9, 0xe9, 0x5a, 0x83, 0x52, 0x95, 0x82, 0x9f, 0x82, 0x96, 0x85, 0x93, 0xe6, 0x97, 0x61,
0xf6, 0xda, 0x74, 0x7c, 0x22, 0xdb, 0x7f, 0xb8, 0xc0, 0x7f, 0x55, 0x41, 0x13, 0x77, 0xe3, 0xc2,
0xf3, 0xa9, 0x45, 0xc2, 0x53, 0x65, 0xf2, 0xf3, 0x0c, 0x16, 0x99, 0x80, 0xea, 0x24, 0x8e, 0x4e,
0x15, 0x1e, 0x6d, 0x86, 0xca, 0x46, 0xaa, 0xa3, 0x4a, 0x80, 0x2b, 0xe1, 0x8c, 0x48, 0x65, 0xc3,
0x68, 0xb0, 0x84, 0x83, 0xe8, 0x3e, 0x00, 0x37, 0x69, 0x9f, 0xf0, 0x0e, 0x25, 0x3d, 0x91, 0xd4,
0x86, 0x51, 0x0f, 0x25, 0x06, 0xe9, 0xe1, 0x7d, 0x68, 0xe5, 0xbc, 0x94, 0xfa, 0x10, 0x52, 0xc2,
0x7c, 0x87, 0x47, 0x1f, 0xc2, 0x70, 0x85, 0x0f, 0x60, 0xe1, 0x98, 0x59, 0xc3, 0x32, 0xf1, 0x7f,
0x08, 0x8d, 0x10, 0x42, 0xc5, 0x9c, 0x50, 0xea, 0x51, 0x99, 0xf3, 0x70, 0x81, 0x3f, 0x56, 0xe1,
0xde, 0x1b, 0x6a, 0x07, 0x85, 0xd2, 0x2b, 0x13, 0xea, 0x26, 0x4c, 0x07, 0x6f, 0x1f, 0xb6, 0xc4,
0xe0, 0x31, 0xd5, 0x29, 0xa7, 0xd3, 0x9d, 0x12, 0x6d, 0x43, 0xc3, 0x73, 0xba, 0x9d, 0x78, 0x3f,
0x0c, 0xda, 0x82, 0xe7, 0x74, 0x8d, 0x48, 0x25, 0xee, 0x65, 0xb3, 0xc9, 0x5e, 0xb6, 0x0c, 0xb3,
0x6c, 0x40, 0x1c, 0x47, 0xb4, 0xa5, 0x9a, 0x11, 0x2e, 0xf0, 0x0e, 0x34, 0xd5, 0x3b, 0xdc, 0xfa,
0xba, 0x03, 0x58, 0x3e, 0xb6, 0xdd, 0xee, 0x19, 0xa1, 0x7d, 0x72, 0x68, 0xb2, 0x52, 0xd5, 0xbf,
0x01, 0xf5, 0xe8, 0x05, 0x98, 0x36, 0xb5, 0x35, 0x1d, 0xa4, 0x3d, 0x16, 0xe0, 0xc7, 0xb0, 0x32,
0x61, 0x49, 0x95, 0xde, 0x95, 0xc9, 0xc2, 0xab, 0x5f, 0x37, 0xc4, 0x33, 0xfe, 0xb3, 0x0a, 0x8b,
0x61, 0xbf, 0x3a, 0xf6, 0xe8, 0xf0, 0xff, 0xbc, 0xf2, 0x01, 0x4f, 0x49, 0x7a, 0x12, 0x73, 0xa5,
0x56, 0x9b, 0x19, 0x24, 0x70, 0xb6, 0xed, 0x9e, 0x53, 0xaf, 0x4f, 0x09, 0x63, 0x25, 0x5b, 0x27,
0x15, 0x70, 0x89, 0xd6, 0x19, 0x0a, 0xda, 0x5d, 0xfc, 0x23, 0xe8, 0x79, 0xd6, 0x64, 0x00, 0x37,
0x61, 0xc1, 0x76, 0x3b, 0x63, 0x29, 0x96, 0x85, 0x03, 0x76, 0xac, 0x18, 0x3a, 0x7b, 0xf1, 0xd6,
0x37, 0xd9, 0xe0, 0xb3, 0x39, 0xcb, 0x04, 0x5c, 0xc2, 0xd9, 0x50, 0x10, 0x39, 0x9b, 0xb5, 0xf6,
0xa9, 0xce, 0xf6, 0xe0, 0xc1, 0xe4, 0x97, 0xea, 0x98, 0x7a, 0xa3, 0x5f, 0x8d, 0x97, 0x25, 0xcb,
0xd1, 0xa7, 0x8e, 0xf4, 0x35, 0x78, 0xc4, 0xdb, 0xb0, 0x59, 0x68, 0x47, 0x26, 0xb9, 0x0d, 0x4b,
0xa1, 0xca, 0xa1, 0xef, 0x76, 0x9d, 0x52, 0x2c, 0xed, 0x11, 0x2c, 0xa7, 0xa1, 0x6e, 0xf9, 0xee,
0x10, 0x40, 0xa2, 0x7a, 0x8f, 0x3c, 0xb7, 0x67, 0xf7, 0x4b, 0xe6, 0xa9, 0xe7, 0x3b, 0x4e, 0x67,
0x6c, 0xf2, 0x41, 0x94, 0xa7, 0x40, 0x70, 0x6e, 0xf2, 0x01, 0x7e, 0x0c, 0x4b, 0x29, 0x33, 0xb7,
0xf6, 0x89, 0x21, 0x6c, 0xe7, 0x45, 0xab, 0x74, 0x60, 0xe2, 0x00, 0x4c, 0x25, 0x02, 0xf0, 0x10,
0xf0, 0x6d, 0xc6, 0x64, 0x76, 0x4e, 0x01, 0x05, 0x0d, 0xe5, 0xa5, 0x6d, 0x11, 0xb7, 0x54, 0xe3,
0xc2, 0x47, 0xb0, 0x94, 0x42, 0x92, 0x91, 0x78, 0x02, 0xc8, 0x09, 0x45, 0x1d, 0x36, 0xf0, 0x28,
0xef, 0xb8, 0xe6, 0x28, 0x6a, 0x53, 0x4d, 0xb9, 0x73, 0x11, 0x6c, 0xbc, 0x32, 0x47, 0x24, 0x18,
0xd5, 0x4e, 0x08, 0x6f, 0xbb, 0x3d, 0xef, 0xe0, 0x73, 0x10, 0x6b, 0xfc, 0x3d, 0xb4, 0x72, 0xf0,
0xa4, 0x6b, 0x0f, 0x00, 0x14, 0xa3, 0x96, 0x99, 0x4a, 0x48, 0x02, 0x67, 0x8e, 0x4c, 0xc7, 0xf2,
0x1d, 0x93, 0x93, 0xa3, 0x01, 0xb1, 0x86, 0xcc, 0x1f, 0x95, 0x71, 0xe6, 0x5b, 0x68, 0xe5, 0xe0,
0x49, 0x67, 0x74, 0xa8, 0x59, 0x52, 0x26, 0xa3, 0x13, 0xaf, 0xf7, 0x3e, 0x36, 0xc5, 0x50, 0x19,
0x8d, 0x27, 0xe1, 0xd4, 0x8d, 0xde, 0x40, 0x73, 0x72, 0x14, 0x46, 0x9b, 0x59, 0x17, 0x52, 0x33,
0xb7, 0xbe, 0x55, 0xac, 0x20, 0x6f, 0x44, 0x05, 0x5d, 0x46, 0x23, 0x6c, 0x62, 0xbe, 0x45, 0xc9,
0x83, 0xb9, 0xa3, 0xb4, 0xbe, 0x7d, 0x8b, 0x46, 0x8c, 0xfd, 0x1c, 0x40, 0x0d, 0xac, 0xa8, 0x95,
0x3e, 0x92, 0x18, 0x99, 0x75, 0x3d, 0x6f, 0x2b, 0x86, 0xf9, 0x05, 0xee, 0xa6, 0xe7, 0x4d, 0x74,
0x3f, 0x26, 0xbc, 0x79, 0x93, 0xaf, 0xfe, 0xa0, 0x68, 0x3b, 0x09, 0x99, 0x1e, 0x01, 0x15, 0x64,
0xee, 0x9c, 0xa9, 0x20, 0xf3, 0x27, 0x47, 0x5c, 0x41, 0xbf, 0x03, 0xca, 0x8e, 0x6e, 0x28, 0x8e,
0x53, 0xe1, 0x0c, 0xa9, 0xe3, 0xdb, 0x54, 0x62, 0xf8, 0x53, 0x58, 0x48, 0x0c, 0x3d, 0x28, 0x8e,
0x58, 0x76, 0x1e, 0xd4, 0xd7, 0x73, 0xf7, 0x62, 0xa4, 0x37, 0xd0, 0x9c, 0xec, 0x15, 0xea, 0x2a,
0x15, 0x4c, 0x50, 0xea, 0x2a, 0x15, 0xce, 0x44, 0x15, 0x74, 0x02, 0xa0, 0xe6, 0x04, 0x95, 0xee,
0xcc, 0x50, 0xa2, 0xd2, 0x9d, 0x1d, 0x2b, 0x70, 0xe5, 0x69, 0x35, 0xf0, 0x70, 0x92, 0xf7, 0x2b,
0x0f, 0x0b, 0x06, 0x0c, 0xe5, 0x61, 0xd1, 0xc8, 0x10, 0x5e, 0xf6, 0x0c, 0x91, 0x56, 0x97, 0xbd,
0x68, 0x70, 0x50, 0x97, 0xbd, 0x90, 0x85, 0xe3, 0x0a, 0xda, 0x87, 0x99, 0x80, 0x2c, 0xa3, 0xa5,
0x58, 0x59, 0xb1, 0x6f, 0x7d, 0x39, 0x2d, 0x8c, 0x0f, 0x3d, 0x83, 0x5a, 0x44, 0x3b, 0xd1, 0x5a,
0xa4, 0x33, 0x41, 0xa6, 0x75, 0x2d, 0xbb, 0x11, 0x03, 0xbc, 0x82, 0x3b, 0x29, 0x8e, 0x88, 0x36,
0x62, 0x4b, 0x39, 0x24, 0x55, 0xbf, 0x5f, 0xb0, 0x9b, 0x2c, 0x59, 0xc5, 0xdd, 0x54, 0x0e, 0x33,
0xcc, 0x52, 0xe5, 0x30, 0x87, 0xea, 0x89, 0x62, 0xc8, 0xd2, 0x2f, 0x55, 0x0c, 0x85, 0x44, 0x50,
0x15, 0x43, 0x31, 0x7b, 0x8b, 0xe0, 0x27, 0x09, 0x53, 0x12, 0xbe, 0x80, 0xba, 0x25, 0xe1, 0x8b,
0xf8, 0x16, 0xae, 0x20, 0x27, 0xfb, 0x27, 0x41, 0x12, 0x1d, 0xf4, 0x65, 0x51, 0x1d, 0xa4, 0x19,
0x97, 0xfe, 0xd5, 0xbf, 0xea, 0xc5, 0xd6, 0xce, 0xa0, 0x91, 0x24, 0x3a, 0x68, 0x3d, 0x7d, 0x34,
0x45, 0x18, 0xf4, 0x8d, 0xfc, 0xcd, 0x44, 0xf1, 0xbc, 0x03, 0xbd, 0x98, 0x0a, 0xa0, 0xaf, 0x6f,
0xf3, 0x2b, 0x6d, 0xea, 0xd1, 0xa7, 0xa8, 0x46, 0x86, 0x77, 0xaa, 0x41, 0x87, 0x4a, 0xb0, 0x23,
0xd5, 0xa1, 0xb2, 0xcc, 0x4c, 0x75, 0xa8, 0x1c, 0x3a, 0x25, 0x7b, 0x9d, 0x62, 0x17, 0x89, 0x5e,
0x97, 0x21, 0x2f, 0x89, 0x5e, 0x97, 0xa5, 0x23, 0xb8, 0x82, 0x7e, 0x13, 0xff, 0x69, 0xd2, 0x94,
0x00, 0x25, 0x7f, 0x97, 0xe4, 0xb2, 0x0f, 0x55, 0xf0, 0x85, 0x7c, 0x42, 0x84, 0xfa, 0x12, 0x16,
0x33, 0xdf, 0x78, 0x85, 0x5e, 0x44, 0x27, 0x14, 0x7a, 0x21, 0x41, 0xc0, 0x15, 0xf4, 0x03, 0xcc,
0xcb, 0x9f, 0xa0, 0x68, 0x35, 0xd6, 0x4f, 0xfd, 0x5b, 0xd5, 0xd7, 0x32, 0xf2, 0xe8, 0xf4, 0xd5,
0x9c, 0xf8, 0x1f, 0xbf, 0xff, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x23, 0xc7, 0xc8, 0xe3, 0xc1,
0x17, 0x00, 0x00,
// 1698 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0x5f, 0x6f, 0xdb, 0xc8,
0x11, 0x97, 0xfc, 0x4f, 0xd2, 0x48, 0x97, 0x93, 0xd7, 0xff, 0x28, 0xda, 0x89, 0xed, 0xbd, 0xe0,
0xea, 0xbb, 0xa4, 0xc6, 0xc1, 0x7e, 0x68, 0x81, 0xb6, 0x38, 0xd8, 0x6e, 0x6c, 0x2b, 0x89, 0x03,
0x97, 0x4e, 0x10, 0xc0, 0x68, 0x21, 0xd0, 0xd4, 0x4a, 0x24, 0x44, 0x91, 0xca, 0xee, 0xd2, 0x89,
0xd3, 0xd7, 0x3e, 0x14, 0xe8, 0x53, 0xbf, 0x52, 0xbf, 0x42, 0x3f, 0x46, 0xbf, 0x44, 0xc1, 0xe5,
0x8a, 0x4b, 0x8a, 0xa4, 0x1a, 0x80, 0x29, 0xee, 0x8d, 0x3b, 0xbb, 0xfb, 0x9b, 0xd9, 0x99, 0x9d,
0xd1, 0x6f, 0x56, 0xa0, 0x51, 0x32, 0xf1, 0x99, 0xc3, 0x7d, 0xfa, 0xf0, 0x6b, 0x46, 0xe8, 0xbd,
0x63, 0x91, 0xc3, 0x09, 0xf5, 0xb9, 0x8f, 0x56, 0x86, 0x0e, 0x37, 0xdd, 0x07, 0xbd, 0xc5, 0x6c,
0x93, 0x92, 0x7e, 0x24, 0xc5, 0x57, 0xb0, 0x65, 0xc4, 0x3b, 0x5e, 0x7c, 0x72, 0x18, 0x67, 0x06,
0xf9, 0x10, 0x10, 0xc6, 0xd1, 0x11, 0x80, 0x02, 0xd3, 0xaa, 0x7b, 0xd5, 0x83, 0xe6, 0x11, 0x3a,
0x8c, 0x50, 0x0e, 0xd5, 0x26, 0x23, 0xb1, 0x0a, 0x1f, 0x81, 0x96, 0x85, 0x63, 0x13, 0xdf, 0x63,
0x04, 0x6d, 0xc2, 0x0a, 0x11, 0x12, 0x81, 0x55, 0x37, 0xe4, 0x08, 0xbf, 0x11, 0x7b, 0x4c, 0x6b,
0xd4, 0xf5, 0x2c, 0x4a, 0xc6, 0xc4, 0xe3, 0xa6, 0x5b, 0xc6, 0x86, 0x6d, 0xe8, 0xe4, 0xe0, 0x45,
0x46, 0x60, 0x17, 0x56, 0xa3, 0xc9, 0xf3, 0xc0, 0x2d, 0xa3, 0x05, 0x7d, 0x07, 0xdf, 0x58, 0x94,
0x98, 0x9c, 0xf4, 0xee, 0x1c, 0x3e, 0x36, 0x27, 0xda, 0x82, 0x38, 0x54, 0x2b, 0x12, 0x9e, 0x0a,
0x19, 0x5e, 0x07, 0x94, 0xd4, 0x26, 0x6d, 0x98, 0xc0, 0xc6, 0x85, 0x49, 0xef, 0xcc, 0x21, 0x39,
0xf3, 0x5d, 0x97, 0x58, 0xfc, 0xff, 0x6e, 0x87, 0x06, 0x9b, 0xb3, 0x1a, 0xa5, 0x2d, 0x7f, 0x84,
0x47, 0x67, 0x2e, 0x31, 0xbd, 0x60, 0x52, 0xc6, 0xe5, 0xab, 0xf0, 0x6d, 0x8c, 0x22, 0x81, 0x5f,
0xc1, 0x86, 0x5a, 0x7c, 0xe3, 0x7c, 0x26, 0x65, 0xf0, 0x9f, 0xc3, 0xe6, 0x2c, 0x98, 0xbc, 0x54,
0x08, 0x96, 0x98, 0xf3, 0x99, 0x08, 0x9c, 0x45, 0x43, 0x7c, 0xe3, 0x11, 0x74, 0x4e, 0x26, 0x13,
0xf7, 0xe1, 0xc2, 0xe1, 0x26, 0xe7, 0xd4, 0xb9, 0x0b, 0x38, 0x29, 0x73, 0xab, 0x91, 0x0e, 0x75,
0x4a, 0xee, 0x1d, 0xe6, 0xf8, 0x9e, 0x70, 0x6f, 0xcb, 0x88, 0xc7, 0x78, 0x07, 0xf4, 0x3c, 0x65,
0xd2, 0x0b, 0x7f, 0x5b, 0x00, 0x74, 0x4e, 0xb8, 0x65, 0x1b, 0x64, 0xec, 0xf3, 0x32, 0x3e, 0x08,
0xd3, 0x87, 0x0a, 0x10, 0x61, 0x42, 0xc3, 0x90, 0x23, 0xb4, 0x0e, 0xcb, 0x03, 0x9f, 0x5a, 0x44,
0x5b, 0x14, 0x81, 0x8f, 0x06, 0x68, 0x0b, 0x6a, 0x9e, 0xdf, 0xe3, 0xe6, 0x90, 0x69, 0x4b, 0x51,
0xb6, 0x79, 0xfe, 0x5b, 0x73, 0xc8, 0x90, 0x06, 0x35, 0xee, 0x8c, 0x89, 0x1f, 0x70, 0x6d, 0x79,
0xaf, 0x7a, 0xb0, 0x6c, 0x4c, 0x87, 0xe1, 0x16, 0xc6, 0xec, 0xde, 0x88, 0x3c, 0x68, 0x2b, 0x91,
0x06, 0xc6, 0xec, 0x57, 0xe4, 0x01, 0xed, 0x42, 0x73, 0xe4, 0xf9, 0x1f, 0xbd, 0x9e, 0xed, 0x87,
0xd9, 0x5b, 0x13, 0x93, 0x20, 0x44, 0x97, 0xa1, 0x04, 0x75, 0xa0, 0xee, 0xf9, 0xbd, 0x09, 0x0d,
0x3c, 0xa2, 0x35, 0x84, 0xb6, 0x9a, 0xe7, 0x5f, 0x87, 0xc3, 0x97, 0x4b, 0xf5, 0x7a, 0xbb, 0x81,
0x37, 0x60, 0x2d, 0xe5, 0x05, 0xe9, 0x9d, 0x2b, 0xd8, 0x3a, 0x13, 0xd7, 0x34, 0x71, 0xe4, 0x12,
0xb7, 0x44, 0x07, 0x2d, 0x0b, 0x27, 0x55, 0xfd, 0xa7, 0x0a, 0xab, 0x17, 0x84, 0x9f, 0x50, 0xcb,
0x76, 0xee, 0x4b, 0xc5, 0x61, 0x1b, 0x1a, 0x96, 0x3f, 0x1e, 0x3b, 0xbc, 0xe7, 0xf4, 0x65, 0x28,
0xea, 0x91, 0xa0, 0xdb, 0x0f, 0x83, 0x34, 0xa1, 0x64, 0xe0, 0x7c, 0x12, 0xd1, 0x68, 0x18, 0x72,
0x84, 0x7e, 0x0b, 0x2b, 0x03, 0x9f, 0x8e, 0x4d, 0x2e, 0xa2, 0xf1, 0xe8, 0x68, 0x6f, 0xaa, 0x24,
0x63, 0xd3, 0xe1, 0xb9, 0x58, 0x67, 0xc8, 0xf5, 0xf8, 0x18, 0x56, 0x22, 0x09, 0xaa, 0xc1, 0xe2,
0x6d, 0xf7, 0xba, 0x5d, 0x09, 0x3f, 0xde, 0x9e, 0x18, 0xed, 0x2a, 0x02, 0x58, 0x79, 0x7b, 0x62,
0xf4, 0x2e, 0x6e, 0xdb, 0x0b, 0xa8, 0x09, 0xb5, 0xf0, 0xfb, 0xf4, 0xf6, 0xa8, 0xbd, 0x88, 0x0f,
0x00, 0x25, 0x81, 0x55, 0xae, 0xf4, 0x4d, 0x6e, 0x8a, 0x73, 0xb6, 0x0c, 0xf1, 0x1d, 0x86, 0xe0,
0xd2, 0x64, 0xaf, 0x7d, 0xcb, 0x74, 0x4f, 0xa9, 0xe9, 0x59, 0x76, 0xa9, 0x4c, 0xc1, 0x3f, 0x81,
0x96, 0x85, 0x93, 0xea, 0xd7, 0x61, 0xf9, 0xde, 0x74, 0x03, 0x22, 0xcb, 0x7f, 0x34, 0xc0, 0xff,
0xae, 0x82, 0x26, 0xee, 0xc6, 0x8d, 0x1f, 0x50, 0x8b, 0x44, 0xbb, 0xca, 0xc4, 0xe7, 0x67, 0x58,
0x65, 0x02, 0xaa, 0x97, 0xd8, 0xba, 0x50, 0xb8, 0xb5, 0x1d, 0x2d, 0x36, 0x52, 0x15, 0x55, 0x02,
0xdc, 0x09, 0x63, 0x44, 0x28, 0x5b, 0x46, 0x8b, 0x25, 0x0c, 0x44, 0x8f, 0x01, 0xb8, 0x49, 0x87,
0x84, 0xf7, 0x28, 0x19, 0x88, 0xa0, 0xb6, 0x8c, 0x46, 0x24, 0x31, 0xc8, 0x00, 0x1f, 0x43, 0x27,
0xe7, 0x50, 0xea, 0x87, 0x90, 0x12, 0x16, 0xb8, 0x7c, 0xfa, 0x43, 0x18, 0x8d, 0xf0, 0x09, 0x34,
0xcf, 0x99, 0x35, 0x2a, 0xe3, 0xff, 0xa7, 0xd0, 0x8a, 0x20, 0x94, 0xcf, 0x09, 0xa5, 0x3e, 0x95,
0x31, 0x8f, 0x06, 0xf8, 0x5f, 0x55, 0xf8, 0xf6, 0x3d, 0x75, 0xc2, 0x44, 0x19, 0x94, 0x71, 0x75,
0x1b, 0x16, 0xc3, 0xd3, 0x47, 0x25, 0x31, 0xfc, 0x4c, 0x55, 0xca, 0xc5, 0x74, 0xa5, 0x44, 0xfb,
0xd0, 0xf2, 0xdd, 0x7e, 0x2f, 0x9e, 0x8f, 0x9c, 0xd6, 0xf4, 0xdd, 0xbe, 0x31, 0x5d, 0x12, 0xd7,
0xb2, 0xe5, 0x64, 0x2d, 0x5b, 0x87, 0x65, 0x66, 0x13, 0xd7, 0x15, 0x65, 0xa9, 0x6e, 0x44, 0x03,
0x7c, 0x00, 0x6d, 0x75, 0x86, 0xb9, 0xc7, 0xb5, 0x61, 0xfd, 0xdc, 0xf1, 0xfa, 0x57, 0x84, 0x0e,
0xc9, 0xa9, 0xc9, 0x4a, 0x65, 0xff, 0x0e, 0x34, 0xa6, 0x07, 0x60, 0xda, 0xc2, 0xde, 0x62, 0x18,
0xf6, 0x58, 0x80, 0x9f, 0xc1, 0xc6, 0x8c, 0x26, 0x95, 0x7a, 0x77, 0x26, 0x8b, 0xae, 0x7e, 0xc3,
0x10, 0xdf, 0xf8, 0xef, 0x55, 0x58, 0x8d, 0xea, 0xd5, 0xb9, 0x4f, 0x47, 0xbf, 0xe4, 0x95, 0x0f,
0x79, 0x4a, 0xd2, 0x92, 0x98, 0x2b, 0x75, 0xba, 0xcc, 0x20, 0xa1, 0xb1, 0x5d, 0xef, 0x9a, 0xfa,
0x43, 0x4a, 0x18, 0x2b, 0x59, 0x3a, 0xa9, 0x80, 0x4b, 0x94, 0xce, 0x48, 0xd0, 0xed, 0xe3, 0x3f,
0x80, 0x9e, 0xa7, 0x4d, 0x3a, 0x70, 0x17, 0x9a, 0x8e, 0xd7, 0x9b, 0x48, 0xb1, 0x4c, 0x1c, 0x70,
0xe2, 0x85, 0x91, 0xb1, 0x37, 0x1f, 0x02, 0x93, 0xd9, 0x5f, 0xcd, 0x58, 0x26, 0xe0, 0x12, 0xc6,
0x46, 0x82, 0xa9, 0xb1, 0x59, 0x6d, 0x5f, 0x6a, 0xec, 0x00, 0x9e, 0xcc, 0xfe, 0x52, 0x9d, 0x53,
0x7f, 0xfc, 0xce, 0x78, 0x5d, 0x32, 0x1d, 0x03, 0xea, 0x4a, 0x5b, 0xc3, 0x4f, 0xbc, 0x0f, 0xbb,
0x85, 0x7a, 0x64, 0x90, 0xbb, 0xb0, 0x16, 0x2d, 0x39, 0x0d, 0xbc, 0xbe, 0x5b, 0x8a, 0xa5, 0xfd,
0x08, 0xeb, 0x69, 0xa8, 0x39, 0xbf, 0x3b, 0x04, 0x90, 0xc8, 0xde, 0x33, 0xdf, 0x1b, 0x38, 0xc3,
0x92, 0x71, 0x1a, 0x04, 0xae, 0xdb, 0x9b, 0x98, 0xdc, 0x9e, 0xc6, 0x29, 0x14, 0x5c, 0x9b, 0xdc,
0xc6, 0xcf, 0x60, 0x2d, 0xa5, 0x66, 0x6e, 0x9d, 0x18, 0xc1, 0x7e, 0x9e, 0xb7, 0x4a, 0x3b, 0x26,
0x76, 0xc0, 0x42, 0xc2, 0x01, 0x4f, 0x01, 0xcf, 0x53, 0x26, 0xa3, 0x73, 0x09, 0x28, 0x2c, 0x28,
0xaf, 0x1d, 0x8b, 0x78, 0xa5, 0x0a, 0x17, 0x3e, 0x83, 0xb5, 0x14, 0x92, 0xf4, 0xc4, 0x73, 0x40,
0x6e, 0x24, 0xea, 0x31, 0xdb, 0xa7, 0xbc, 0xe7, 0x99, 0xe3, 0x69, 0x99, 0x6a, 0xcb, 0x99, 0x9b,
0x70, 0xe2, 0x8d, 0x39, 0x26, 0x61, 0xab, 0x76, 0x41, 0x78, 0xd7, 0x1b, 0xf8, 0x27, 0x5f, 0x83,
0x58, 0xe3, 0xdf, 0x41, 0x27, 0x07, 0x4f, 0x9a, 0xf6, 0x04, 0x40, 0x31, 0x6a, 0x19, 0xa9, 0x84,
0x24, 0x34, 0xe6, 0xcc, 0x74, 0xad, 0xc0, 0x35, 0x39, 0x39, 0xb3, 0x89, 0x35, 0x62, 0xc1, 0xb8,
0x8c, 0x31, 0xbf, 0x81, 0x4e, 0x0e, 0x9e, 0x34, 0x46, 0x87, 0xba, 0x25, 0x65, 0xd2, 0x3b, 0xf1,
0x38, 0x0c, 0xd2, 0x05, 0xe1, 0x37, 0x9e, 0x39, 0x61, 0xb6, 0x5f, 0xa6, 0x99, 0xc3, 0x3f, 0xc0,
0x5a, 0x0a, 0x69, 0x4e, 0x02, 0xfd, 0xb3, 0x0a, 0xdf, 0xe5, 0x5d, 0xa0, 0xaf, 0x60, 0x46, 0xc8,
0xe7, 0x6d, 0xce, 0x27, 0x3d, 0x55, 0x4d, 0x6a, 0xe1, 0xf8, 0x1d, 0x75, 0xc3, 0x6c, 0x13, 0x53,
0x66, 0xc0, 0x6d, 0xc9, 0x71, 0xc5, 0xda, 0x93, 0x80, 0xdb, 0xf8, 0x7b, 0x78, 0x3a, 0xdf, 0xa4,
0xe8, 0x3c, 0x47, 0xff, 0x40, 0xa2, 0x0b, 0x9f, 0xf6, 0x73, 0xd1, 0x33, 0x05, 0x7a, 0x0f, 0xed,
0xd9, 0xb7, 0x03, 0xb4, 0x9b, 0xb5, 0x34, 0xf5, 0x48, 0xa1, 0xef, 0x15, 0x2f, 0x90, 0x29, 0x54,
0x41, 0xb7, 0xd3, 0x9e, 0x3f, 0xf1, 0x20, 0x80, 0x92, 0x1b, 0x73, 0xdf, 0x1e, 0xf4, 0xfd, 0x39,
0x2b, 0x62, 0xec, 0x17, 0x00, 0xaa, 0xc3, 0x47, 0x9d, 0xf4, 0x96, 0xc4, 0x1b, 0x83, 0xae, 0xe7,
0x4d, 0xc5, 0x30, 0x7f, 0x82, 0x47, 0xe9, 0x06, 0x1d, 0x3d, 0x8e, 0x3b, 0x84, 0xbc, 0xa7, 0x02,
0xfd, 0x49, 0xd1, 0x74, 0x12, 0x32, 0xdd, 0x33, 0x2b, 0xc8, 0xdc, 0xc6, 0x5c, 0x41, 0xe6, 0xb7,
0xda, 0xb8, 0x82, 0xfe, 0x02, 0x28, 0xdb, 0xeb, 0xa2, 0xd8, 0x4f, 0x85, 0x4d, 0xb7, 0x8e, 0xe7,
0x2d, 0x89, 0xe1, 0x2f, 0xa1, 0x99, 0xe8, 0x12, 0x51, 0xec, 0xb1, 0x6c, 0x03, 0xad, 0x6f, 0xe7,
0xce, 0xc5, 0x48, 0xef, 0xa1, 0x3d, 0x7b, 0x11, 0xd5, 0x55, 0x2a, 0x68, 0x39, 0xd5, 0x55, 0x2a,
0x6c, 0x22, 0x2b, 0xe8, 0x02, 0x40, 0x35, 0x56, 0x2a, 0xdc, 0x99, 0x2e, 0x4e, 0x85, 0x3b, 0xdb,
0x87, 0xe1, 0xca, 0x4f, 0xd5, 0xd0, 0xc2, 0xd9, 0x46, 0x49, 0x59, 0x58, 0xd0, 0x91, 0x29, 0x0b,
0x8b, 0x7a, 0xac, 0xe8, 0xb2, 0x67, 0x3a, 0x0f, 0x75, 0xd9, 0x8b, 0x3a, 0x2d, 0x75, 0xd9, 0x0b,
0xdb, 0x16, 0x5c, 0x41, 0xc7, 0xb0, 0x14, 0x76, 0x17, 0x68, 0x2d, 0x5e, 0xac, 0xda, 0x15, 0x7d,
0x3d, 0x2d, 0x8c, 0x37, 0xfd, 0x0c, 0xf5, 0x29, 0x4f, 0x47, 0x5b, 0xd3, 0x35, 0x33, 0xdd, 0x87,
0xae, 0x65, 0x27, 0x62, 0x80, 0x37, 0xf0, 0x4d, 0x8a, 0x54, 0xa3, 0x9d, 0x58, 0x53, 0x0e, 0xab,
0xd7, 0x1f, 0x17, 0xcc, 0x26, 0x53, 0x56, 0x91, 0x5d, 0x15, 0xc3, 0x0c, 0x15, 0x57, 0x31, 0xcc,
0xe1, 0xc6, 0x22, 0x19, 0xb2, 0x7c, 0x55, 0x25, 0x43, 0x21, 0x73, 0x56, 0xc9, 0x50, 0x4c, 0x77,
0xa7, 0xf0, 0xb3, 0x0c, 0x33, 0x09, 0x5f, 0xc0, 0x75, 0x93, 0xf0, 0x45, 0x04, 0x15, 0x57, 0x90,
0x9b, 0x7d, 0x7a, 0x91, 0xcc, 0x10, 0x7d, 0x5f, 0x94, 0x07, 0x69, 0x8a, 0xaa, 0xff, 0xea, 0x7f,
0xae, 0x8b, 0xb5, 0x5d, 0x41, 0x2b, 0xc9, 0x0c, 0xd1, 0x76, 0x7a, 0x6b, 0x8a, 0x61, 0xe9, 0x3b,
0xf9, 0x93, 0x89, 0xe4, 0xf9, 0x08, 0x7a, 0x31, 0x77, 0x42, 0x3f, 0xcc, 0xb3, 0x2b, 0xad, 0xea,
0xc7, 0x2f, 0x59, 0x3a, 0x55, 0x7c, 0x50, 0x0d, 0x2b, 0x54, 0x82, 0x4e, 0xaa, 0x0a, 0x95, 0xa5,
0xb2, 0xaa, 0x42, 0xe5, 0xf0, 0x4f, 0x59, 0xeb, 0x14, 0x1d, 0x4b, 0xd4, 0xba, 0x0c, 0xdb, 0x4b,
0xd4, 0xba, 0x2c, 0x7f, 0xc3, 0x15, 0xf4, 0x67, 0xf1, 0xb0, 0x95, 0xe6, 0x50, 0x28, 0xf9, 0xbe,
0x94, 0x4b, 0xd7, 0x54, 0xc2, 0x17, 0x12, 0x30, 0xe1, 0xea, 0x5b, 0x58, 0xcd, 0x90, 0x22, 0x85,
0x5e, 0xc4, 0xbf, 0x14, 0x7a, 0x21, 0xa3, 0xc2, 0x15, 0xf4, 0x7b, 0xa8, 0xc9, 0x57, 0x63, 0xb4,
0x19, 0xaf, 0x4f, 0x3d, 0x46, 0xeb, 0x5b, 0x19, 0x79, 0xbc, 0xfb, 0x25, 0x34, 0x13, 0x5c, 0x09,
0x25, 0x0b, 0xee, 0x0c, 0x07, 0x52, 0x1e, 0xcc, 0x21, 0x57, 0xe2, 0x94, 0x7f, 0x85, 0x9d, 0x79,
0xc4, 0x05, 0x3d, 0x9b, 0x77, 0x4f, 0x66, 0xb5, 0x3d, 0xff, 0xb2, 0xc5, 0x53, 0xf5, 0x77, 0x2b,
0xe2, 0x9f, 0x98, 0xe3, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x04, 0x94, 0xb1, 0xc3, 0xbb, 0x19,
0x00, 0x00,
}
......@@ -197,12 +197,12 @@
"revisionTime": "2016-11-17T07:43:51Z"
},
{
"checksumSHA1": "MVrf0BwLEpU3uGHmYOrIWVoJGCk=",
"checksumSHA1": "B+FjK1qIgELTplSb/hl3ZHGHjl0=",
"path": "gitlab.com/gitlab-org/gitaly-proto/go",
"revision": "00d4006669b30b6a0fe66aaa9fa72285d18616fb",
"revisionTime": "2018-04-03T14:25:38Z",
"version": "v0.95.0",
"versionExact": "v0.95.0"
"revision": "8680efed3cdd68f3a2d4ccd56fb6684a6761d59e",
"revisionTime": "2018-04-05T16:15:56Z",
"version": "v0.96.0",
"versionExact": "v0.96.0"
},
{
"checksumSHA1": "dUHJbKas746n5fLzlwxHb6FOCxs=",
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment