Use gitaly-proto 0.5.0. Adds protobuf/ptypes

internal/testhelper/gitaly.go

@@ -25,3 +25,7 @@ func (s *GitalyTestServer) InfoRefsReceivePack(in *pb.InfoRefsRequest, stream pb
 	}
 	return stream.Send(response)
 }
+
+// TODO replace these empty implementations
+func (*GitalyTestServer) PostUploadPack(pb.SmartHTTP_PostUploadPackServer) error   { return nil }
+func (*GitalyTestServer) PostReceivePack(pb.SmartHTTP_PostReceivePackServer) error { return nil }

vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go

+// Code generated by protoc-gen-go.
+// source: github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
+// DO NOT EDIT!
+
+/*
+Package timestamp is a generated protocol buffer package.
+
+It is generated from these files:
+	github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
+
+It has these top-level messages:
+	Timestamp
+*/
+package timestamp
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// A Timestamp represents a point in time independent of any time zone
+// or calendar, represented as seconds and fractions of seconds at
+// nanosecond resolution in UTC Epoch time. It is encoded using the
+// Proleptic Gregorian Calendar which extends the Gregorian calendar
+// backwards to year one. It is encoded assuming all minutes are 60
+// seconds long, i.e. leap seconds are "smeared" so that no leap second
+// table is needed for interpretation. Range is from
+// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
+// By restricting to that range, we ensure that we can convert to
+// and from  RFC 3339 date strings.
+// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
+//
+// Example 1: Compute Timestamp from POSIX `time()`.
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(time(NULL));
+//     timestamp.set_nanos(0);
+//
+// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+//
+//     struct timeval tv;
+//     gettimeofday(&tv, NULL);
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(tv.tv_sec);
+//     timestamp.set_nanos(tv.tv_usec * 1000);
+//
+// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+//
+//     FILETIME ft;
+//     GetSystemTimeAsFileTime(&ft);
+//     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+//
+//     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+//     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+//     Timestamp timestamp;
+//     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+//     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+//
+// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+//
+//     long millis = System.currentTimeMillis();
+//
+//     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+//         .setNanos((int) ((millis % 1000) * 1000000)).build();
+//
+//
+// Example 5: Compute Timestamp from current time in Python.
+//
+//     now = time.time()
+//     seconds = int(now)
+//     nanos = int((now - seconds) * 10**9)
+//     timestamp = Timestamp(seconds=seconds, nanos=nanos)
+//
+//
+type Timestamp struct {
+	// Represents seconds of UTC time since Unix epoch
+	// 1970-01-01T00:00:00Z. Must be from from 0001-01-01T00:00:00Z to
+	// 9999-12-31T23:59:59Z inclusive.
+	Seconds int64 `protobuf:"varint,1,opt,name=seconds" json:"seconds,omitempty"`
+	// Non-negative fractions of a second at nanosecond resolution. Negative
+	// second values with fractions must still have non-negative nanos values
+	// that count forward in time. Must be from 0 to 999,999,999
+	// inclusive.
+	Nanos int32 `protobuf:"varint,2,opt,name=nanos" json:"nanos,omitempty"`
+}
+
+func (m *Timestamp) Reset()                    { *m = Timestamp{} }
+func (m *Timestamp) String() string            { return proto.CompactTextString(m) }
+func (*Timestamp) ProtoMessage()               {}
+func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+func (*Timestamp) XXX_WellKnownType() string   { return "Timestamp" }
+
+func init() {
+	proto.RegisterType((*Timestamp)(nil), "google.protobuf.Timestamp")
+}
+
+func init() {
+	proto.RegisterFile("github.com/golang/protobuf/ptypes/timestamp/timestamp.proto", fileDescriptor0)
+}
+
+var fileDescriptor0 = []byte{
+	// 194 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xb2, 0x4e, 0xcf, 0x2c, 0xc9,
+	0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, 0x4b, 0xd7, 0x2f, 0x28,
+	0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0x28, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x2f, 0xc9,
+	0xcc, 0x4d, 0x2d, 0x2e, 0x49, 0xcc, 0x2d, 0x40, 0xb0, 0xf4, 0xc0, 0x6a, 0x84, 0xf8, 0xd3, 0xf3,
+	0xf3, 0xd3, 0x73, 0x52, 0xf5, 0x60, 0x3a, 0x94, 0xac, 0xb9, 0x38, 0x43, 0x60, 0x6a, 0x84, 0x24,
+	0xb8, 0xd8, 0x8b, 0x53, 0x93, 0xf3, 0xf3, 0x52, 0x8a, 0x25, 0x18, 0x15, 0x18, 0x35, 0x98, 0x83,
+	0x60, 0x5c, 0x21, 0x11, 0x2e, 0xd6, 0xbc, 0xc4, 0xbc, 0xfc, 0x62, 0x09, 0x26, 0x05, 0x46, 0x0d,
+	0xd6, 0x20, 0x08, 0xc7, 0xa9, 0x91, 0x91, 0x4b, 0x38, 0x39, 0x3f, 0x57, 0x0f, 0xcd, 0x50, 0x27,
+	0x3e, 0xb8, 0x91, 0x01, 0x20, 0xa1, 0x00, 0xc6, 0x28, 0x6d, 0x12, 0x1c, 0xbd, 0x80, 0x91, 0xf1,
+	0x07, 0x23, 0xe3, 0x22, 0x26, 0x66, 0xf7, 0x00, 0xa7, 0x55, 0x4c, 0x72, 0xee, 0x10, 0xc3, 0x03,
+	0xa0, 0xca, 0xf5, 0xc2, 0x53, 0x73, 0x72, 0xbc, 0xf3, 0xf2, 0xcb, 0xf3, 0x42, 0x40, 0xda, 0x92,
+	0xd8, 0xc0, 0xe6, 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x17, 0x5f, 0xb7, 0xdc, 0x17, 0x01,
+	0x00, 0x00,
+}

vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto

+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option go_package = "github.com/golang/protobuf/ptypes/timestamp";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "TimestampProto";
+option java_multiple_files = true;
+option java_generate_equals_and_hash = true;
+option objc_class_prefix = "GPB";
+
+// A Timestamp represents a point in time independent of any time zone
+// or calendar, represented as seconds and fractions of seconds at
+// nanosecond resolution in UTC Epoch time. It is encoded using the
+// Proleptic Gregorian Calendar which extends the Gregorian calendar
+// backwards to year one. It is encoded assuming all minutes are 60
+// seconds long, i.e. leap seconds are "smeared" so that no leap second
+// table is needed for interpretation. Range is from
+// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
+// By restricting to that range, we ensure that we can convert to
+// and from  RFC 3339 date strings.
+// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
+//
+// Example 1: Compute Timestamp from POSIX `time()`.
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(time(NULL));
+//     timestamp.set_nanos(0);
+//
+// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+//
+//     struct timeval tv;
+//     gettimeofday(&tv, NULL);
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(tv.tv_sec);
+//     timestamp.set_nanos(tv.tv_usec * 1000);
+//
+// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+//
+//     FILETIME ft;
+//     GetSystemTimeAsFileTime(&ft);
+//     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+//
+//     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+//     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+//     Timestamp timestamp;
+//     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+//     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+//
+// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+//
+//     long millis = System.currentTimeMillis();
+//
+//     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+//         .setNanos((int) ((millis % 1000) * 1000000)).build();
+//
+//
+// Example 5: Compute Timestamp from current time in Python.
+//
+//     now = time.time()
+//     seconds = int(now)
+//     nanos = int((now - seconds) * 10**9)
+//     timestamp = Timestamp(seconds=seconds, nanos=nanos)
+//
+//
+message Timestamp {
+
+  // Represents seconds of UTC time since Unix epoch
+  // 1970-01-01T00:00:00Z. Must be from from 0001-01-01T00:00:00Z to
+  // 9999-12-31T23:59:59Z inclusive.
+  int64 seconds = 1;
+
+  // Non-negative fractions of a second at nanosecond resolution. Negative
+  // second values with fractions must still have non-negative nanos values
+  // that count forward in time. Must be from 0 to 999,999,999
+  // inclusive.
+  int32 nanos = 2;
+}

vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION

-0.3.0
+0.5.0

vendor/gitlab.com/gitlab-org/gitaly-proto/go/commit.pb.go

+// Code generated by protoc-gen-go.
+// source: commit.proto
+// DO NOT EDIT!
+
+/*
+Package gitaly is a generated protocol buffer package.
+
+It is generated from these files:
+	commit.proto
+	diff.proto
+	notifications.proto
+	ref.proto
+	shared.proto
+	smarthttp.proto
+	ssh.proto
+
+It has these top-level messages:
+	CommitIsAncestorRequest
+	CommitIsAncestorResponse
+	CommitDiffRequest
+	CommitDiffResponse
+	PostReceiveRequest
+	PostReceiveResponse
+	FindDefaultBranchNameRequest
+	FindDefaultBranchNameResponse
+	FindAllBranchNamesRequest
+	FindAllBranchNamesResponse
+	FindAllTagNamesRequest
+	FindAllTagNamesResponse
+	FindRefNameRequest
+	FindRefNameResponse
+	FindLocalBranchesRequest
+	FindLocalBranchesResponse
+	FindLocalBranchResponse
+	FindLocalBranchCommitAuthor
+	Repository
+	ExitStatus
+	InfoRefsRequest
+	InfoRefsResponse
+	PostUploadPackRequest
+	PostUploadPackResponse
+	PostReceivePackRequest
+	PostReceivePackResponse
+	SSHUploadPackRequest
+	SSHUploadPackResponse
+	SSHReceivePackRequest
+	SSHReceivePackResponse
+*/
+package gitaly
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type CommitIsAncestorRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	AncestorId string      `protobuf:"bytes,2,opt,name=ancestor_id,json=ancestorId" json:"ancestor_id,omitempty"`
+	ChildId    string      `protobuf:"bytes,3,opt,name=child_id,json=childId" json:"child_id,omitempty"`
+}
+
+func (m *CommitIsAncestorRequest) Reset()                    { *m = CommitIsAncestorRequest{} }
+func (m *CommitIsAncestorRequest) String() string            { return proto.CompactTextString(m) }
+func (*CommitIsAncestorRequest) ProtoMessage()               {}
+func (*CommitIsAncestorRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *CommitIsAncestorRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *CommitIsAncestorRequest) GetAncestorId() string {
+	if m != nil {
+		return m.AncestorId
+	}
+	return ""
+}
+
+func (m *CommitIsAncestorRequest) GetChildId() string {
+	if m != nil {
+		return m.ChildId
+	}
+	return ""
+}
+
+type CommitIsAncestorResponse struct {
+	Value bool `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
+}
+
+func (m *CommitIsAncestorResponse) Reset()                    { *m = CommitIsAncestorResponse{} }
+func (m *CommitIsAncestorResponse) String() string            { return proto.CompactTextString(m) }
+func (*CommitIsAncestorResponse) ProtoMessage()               {}
+func (*CommitIsAncestorResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *CommitIsAncestorResponse) GetValue() bool {
+	if m != nil {
+		return m.Value
+	}
+	return false
+}
+
+func init() {
+	proto.RegisterType((*CommitIsAncestorRequest)(nil), "gitaly.CommitIsAncestorRequest")
+	proto.RegisterType((*CommitIsAncestorResponse)(nil), "gitaly.CommitIsAncestorResponse")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for Commit service
+
+type CommitClient interface {
+	CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error)
+}
+
+type commitClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewCommitClient(cc *grpc.ClientConn) CommitClient {
+	return &commitClient{cc}
+}
+
+func (c *commitClient) CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error) {
+	out := new(CommitIsAncestorResponse)
+	err := grpc.Invoke(ctx, "/gitaly.Commit/CommitIsAncestor", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Commit service
+
+type CommitServer interface {
+	CommitIsAncestor(context.Context, *CommitIsAncestorRequest) (*CommitIsAncestorResponse, error)
+}
+
+func RegisterCommitServer(s *grpc.Server, srv CommitServer) {
+	s.RegisterService(&_Commit_serviceDesc, srv)
+}
+
+func _Commit_CommitIsAncestor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CommitIsAncestorRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(CommitServer).CommitIsAncestor(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.Commit/CommitIsAncestor",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(CommitServer).CommitIsAncestor(ctx, req.(*CommitIsAncestorRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Commit_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.Commit",
+	HandlerType: (*CommitServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "CommitIsAncestor",
+			Handler:    _Commit_CommitIsAncestor_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "commit.proto",
+}
+
+func init() { proto.RegisterFile("commit.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 213 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x50, 0xbf, 0x4e, 0x84, 0x30,
+	0x18, 0xb7, 0x1a, 0x11, 0x3f, 0x18, 0xcc, 0x17, 0x13, 0x91, 0x05, 0xc2, 0xc4, 0x44, 0x0c, 0x3e,
+	0x81, 0x71, 0x62, 0xed, 0xe2, 0x68, 0x2a, 0x6d, 0xa4, 0x09, 0x50, 0x6c, 0x8b, 0x09, 0x8f, 0x70,
+	0x6f, 0x7d, 0xb9, 0xf6, 0xb8, 0x5c, 0xee, 0xc2, 0xf8, 0xfb, 0xdb, 0x5f, 0x3f, 0x88, 0x5b, 0x35,
+	0x0c, 0xd2, 0x56, 0x93, 0x56, 0x56, 0x61, 0xf0, 0x2b, 0x2d, 0xeb, 0x97, 0x34, 0x36, 0x1d, 0xd3,
+	0x82, 0x7b, 0xb6, 0xd8, 0x11, 0x78, 0xf9, 0x74, 0xb6, 0xc6, 0x7c, 0x8c, 0xad, 0x30, 0x56, 0x69,
+	0x2a, 0xfe, 0x66, 0x61, 0x2c, 0xd6, 0x00, 0x5a, 0x4c, 0xca, 0x48, 0xab, 0xf4, 0x92, 0x90, 0x9c,
+	0x94, 0x51, 0x8d, 0x95, 0xaf, 0xa9, 0xe8, 0x49, 0xa1, 0x67, 0x2e, 0xcc, 0x20, 0x62, 0xc7, 0x9a,
+	0x6f, 0xc9, 0x93, 0xdb, 0x9c, 0x94, 0x8f, 0x14, 0x56, 0xaa, 0xe1, 0xf8, 0x0a, 0x61, 0xdb, 0xc9,
+	0x9e, 0x1f, 0xd4, 0x3b, 0xa7, 0x3e, 0x38, 0xdc, 0xf0, 0xe2, 0x0d, 0x92, 0xeb, 0x29, 0x66, 0x52,
+	0xa3, 0x11, 0xf8, 0x0c, 0xf7, 0xff, 0xac, 0x9f, 0x85, 0x9b, 0x11, 0x52, 0x0f, 0x6a, 0x06, 0x81,
+	0x4f, 0xe0, 0x17, 0x3c, 0x5d, 0x66, 0x31, 0x5b, 0xb7, 0x6e, 0x7c, 0x30, 0xcd, 0xb7, 0x0d, 0xfe,
+	0xd9, 0xe2, 0xe6, 0x27, 0x70, 0x77, 0x7a, 0xdf, 0x07, 0x00, 0x00, 0xff, 0xff, 0x5d, 0x48, 0xb7,
+	0xcb, 0x4d, 0x01, 0x00, 0x00,
+}

vendor/gitlab.com/gitlab-org/gitaly-proto/go/diff.pb.go

+// Code generated by protoc-gen-go.
+// source: diff.proto
+// DO NOT EDIT!
+
+package gitaly
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type CommitDiffRequest struct {
+	Repository    *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	LeftCommitId  string      `protobuf:"bytes,2,opt,name=left_commit_id,json=leftCommitId" json:"left_commit_id,omitempty"`
+	RightCommitId string      `protobuf:"bytes,3,opt,name=right_commit_id,json=rightCommitId" json:"right_commit_id,omitempty"`
+}
+
+func (m *CommitDiffRequest) Reset()                    { *m = CommitDiffRequest{} }
+func (m *CommitDiffRequest) String() string            { return proto.CompactTextString(m) }
+func (*CommitDiffRequest) ProtoMessage()               {}
+func (*CommitDiffRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
+
+func (m *CommitDiffRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *CommitDiffRequest) GetLeftCommitId() string {
+	if m != nil {
+		return m.LeftCommitId
+	}
+	return ""
+}
+
+func (m *CommitDiffRequest) GetRightCommitId() string {
+	if m != nil {
+		return m.RightCommitId
+	}
+	return ""
+}
+
+// A CommitDiffResponse corresponds to a single changed file in a commit.
+type CommitDiffResponse struct {
+	FromPath []byte `protobuf:"bytes,1,opt,name=from_path,json=fromPath,proto3" json:"from_path,omitempty"`
+	ToPath   []byte `protobuf:"bytes,2,opt,name=to_path,json=toPath,proto3" json:"to_path,omitempty"`
+	// Blob ID as returned via `git diff --full-index`
+	FromId    string   `protobuf:"bytes,3,opt,name=from_id,json=fromId" json:"from_id,omitempty"`
+	ToId      string   `protobuf:"bytes,4,opt,name=to_id,json=toId" json:"to_id,omitempty"`
+	OldMode   int32    `protobuf:"varint,5,opt,name=old_mode,json=oldMode" json:"old_mode,omitempty"`
+	NewMode   int32    `protobuf:"varint,6,opt,name=new_mode,json=newMode" json:"new_mode,omitempty"`
+	Binary    bool     `protobuf:"varint,7,opt,name=binary" json:"binary,omitempty"`
+	RawChunks [][]byte `protobuf:"bytes,8,rep,name=raw_chunks,json=rawChunks,proto3" json:"raw_chunks,omitempty"`
+}
+
+func (m *CommitDiffResponse) Reset()                    { *m = CommitDiffResponse{} }
+func (m *CommitDiffResponse) String() string            { return proto.CompactTextString(m) }
+func (*CommitDiffResponse) ProtoMessage()               {}
+func (*CommitDiffResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
+
+func (m *CommitDiffResponse) GetFromPath() []byte {
+	if m != nil {
+		return m.FromPath
+	}
+	return nil
+}
+
+func (m *CommitDiffResponse) GetToPath() []byte {
+	if m != nil {
+		return m.ToPath
+	}
+	return nil
+}
+
+func (m *CommitDiffResponse) GetFromId() string {
+	if m != nil {
+		return m.FromId
+	}
+	return ""
+}
+
+func (m *CommitDiffResponse) GetToId() string {
+	if m != nil {
+		return m.ToId
+	}
+	return ""
+}
+
+func (m *CommitDiffResponse) GetOldMode() int32 {
+	if m != nil {
+		return m.OldMode
+	}
+	return 0
+}
+
+func (m *CommitDiffResponse) GetNewMode() int32 {
+	if m != nil {
+		return m.NewMode
+	}
+	return 0
+}
+
+func (m *CommitDiffResponse) GetBinary() bool {
+	if m != nil {
+		return m.Binary
+	}
+	return false
+}
+
+func (m *CommitDiffResponse) GetRawChunks() [][]byte {
+	if m != nil {
+		return m.RawChunks
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*CommitDiffRequest)(nil), "gitaly.CommitDiffRequest")
+	proto.RegisterType((*CommitDiffResponse)(nil), "gitaly.CommitDiffResponse")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for Diff service
+
+type DiffClient interface {
+	// Returns stream of CommitDiffResponse: 1 per changed file
+	CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (Diff_CommitDiffClient, error)
+}
+
+type diffClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewDiffClient(cc *grpc.ClientConn) DiffClient {
+	return &diffClient{cc}
+}
+
+func (c *diffClient) CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (Diff_CommitDiffClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_Diff_serviceDesc.Streams[0], c.cc, "/gitaly.Diff/CommitDiff", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &diffCommitDiffClient{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 Diff_CommitDiffClient interface {
+	Recv() (*CommitDiffResponse, error)
+	grpc.ClientStream
+}
+
+type diffCommitDiffClient struct {
+	grpc.ClientStream
+}
+
+func (x *diffCommitDiffClient) Recv() (*CommitDiffResponse, error) {
+	m := new(CommitDiffResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Server API for Diff service
+
+type DiffServer interface {
+	// Returns stream of CommitDiffResponse: 1 per changed file
+	CommitDiff(*CommitDiffRequest, Diff_CommitDiffServer) error
+}
+
+func RegisterDiffServer(s *grpc.Server, srv DiffServer) {
+	s.RegisterService(&_Diff_serviceDesc, srv)
+}
+
+func _Diff_CommitDiff_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(CommitDiffRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(DiffServer).CommitDiff(m, &diffCommitDiffServer{stream})
+}
+
+type Diff_CommitDiffServer interface {
+	Send(*CommitDiffResponse) error
+	grpc.ServerStream
+}
+
+type diffCommitDiffServer struct {
+	grpc.ServerStream
+}
+
+func (x *diffCommitDiffServer) Send(m *CommitDiffResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+var _Diff_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.Diff",
+	HandlerType: (*DiffServer)(nil),
+	Methods:     []grpc.MethodDesc{},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "CommitDiff",
+			Handler:       _Diff_CommitDiff_Handler,
+			ServerStreams: true,
+		},
+	},
+	Metadata: "diff.proto",
+}
+
+func init() { proto.RegisterFile("diff.proto", fileDescriptor1) }
+
+var fileDescriptor1 = []byte{
+	// 328 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x91, 0xdd, 0x4a, 0xf3, 0x30,
+	0x18, 0xc7, 0xdf, 0xec, 0xa3, 0xeb, 0x9e, 0xb7, 0x2a, 0x46, 0xd0, 0x6e, 0x22, 0x94, 0x21, 0xd2,
+	0xa3, 0x21, 0xf3, 0x12, 0x26, 0xc8, 0x0e, 0x44, 0xc9, 0x0d, 0x94, 0x6c, 0x49, 0xd7, 0x60, 0xdb,
+	0xa7, 0xa6, 0x19, 0x65, 0x17, 0xe2, 0x25, 0x7a, 0x1f, 0xd2, 0xc4, 0xcd, 0x82, 0x1e, 0xe6, 0xf7,
+	0xfb, 0x27, 0x79, 0x3e, 0x00, 0x84, 0x4a, 0xd3, 0x79, 0xa5, 0xd1, 0x20, 0xf5, 0xb6, 0xca, 0xf0,
+	0x7c, 0x3f, 0x0d, 0xea, 0x8c, 0x6b, 0x29, 0x1c, 0x9d, 0x7d, 0x10, 0x38, 0x5f, 0x62, 0x51, 0x28,
+	0xf3, 0xa8, 0xd2, 0x94, 0xc9, 0xf7, 0x9d, 0xac, 0x0d, 0x5d, 0x00, 0x68, 0x59, 0x61, 0xad, 0x0c,
+	0xea, 0x7d, 0x48, 0x22, 0x12, 0xff, 0x5f, 0xd0, 0xb9, 0x7b, 0x60, 0xce, 0x8e, 0x86, 0x75, 0x52,
+	0xf4, 0x16, 0x4e, 0x73, 0x99, 0x9a, 0x64, 0x63, 0x5f, 0x4b, 0x94, 0x08, 0x7b, 0x11, 0x89, 0xc7,
+	0x2c, 0x68, 0xa9, 0xfb, 0x62, 0x25, 0xe8, 0x1d, 0x9c, 0x69, 0xb5, 0xcd, 0xba, 0xb1, 0xbe, 0x8d,
+	0x9d, 0x58, 0x7c, 0xc8, 0xcd, 0x3e, 0x09, 0xd0, 0x6e, 0x5d, 0x75, 0x85, 0x65, 0x2d, 0xe9, 0x35,
+	0x8c, 0x53, 0x8d, 0x45, 0x52, 0x71, 0x93, 0xd9, 0xba, 0x02, 0xe6, 0xb7, 0xe0, 0x95, 0x9b, 0x8c,
+	0x5e, 0xc1, 0xc8, 0xa0, 0x53, 0x3d, 0xab, 0x3c, 0x83, 0x07, 0x61, 0x6f, 0x1d, 0x3f, 0xf3, 0xda,
+	0xe3, 0x4a, 0xd0, 0x0b, 0x18, 0x1a, 0x6c, 0xf1, 0xc0, 0xe2, 0x81, 0xc1, 0x95, 0xa0, 0x13, 0xf0,
+	0x31, 0x17, 0x49, 0x81, 0x42, 0x86, 0xc3, 0x88, 0xc4, 0x43, 0x36, 0xc2, 0x5c, 0x3c, 0xa3, 0x90,
+	0xad, 0x2a, 0x65, 0xe3, 0x94, 0xe7, 0x54, 0x29, 0x1b, 0xab, 0x2e, 0xc1, 0x5b, 0xab, 0x92, 0xeb,
+	0x7d, 0x38, 0x8a, 0x48, 0xec, 0xb3, 0xef, 0x13, 0xbd, 0x01, 0xd0, 0xbc, 0x49, 0x36, 0xd9, 0xae,
+	0x7c, 0xab, 0x43, 0x3f, 0xea, 0xc7, 0x01, 0x1b, 0x6b, 0xde, 0x2c, 0x2d, 0x58, 0xbc, 0xc0, 0xa0,
+	0x6d, 0x90, 0x3e, 0x01, 0xfc, 0xb4, 0x4b, 0x27, 0x87, 0x59, 0xff, 0x5a, 0xcd, 0x74, 0xfa, 0x97,
+	0x72, 0xd3, 0x99, 0xfd, 0xbb, 0x27, 0x6b, 0xcf, 0xee, 0xf5, 0xe1, 0x2b, 0x00, 0x00, 0xff, 0xff,
+	0xca, 0xe9, 0x71, 0x86, 0xfb, 0x01, 0x00, 0x00,
+}

vendor/gitlab.com/gitlab-org/gitaly-proto/go/notifications.pb.go

+// Code generated by protoc-gen-go.
+// source: notifications.proto
+// DO NOT EDIT!
+
+package gitaly
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type PostReceiveRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+}
+
+func (m *PostReceiveRequest) Reset()                    { *m = PostReceiveRequest{} }
+func (m *PostReceiveRequest) String() string            { return proto.CompactTextString(m) }
+func (*PostReceiveRequest) ProtoMessage()               {}
+func (*PostReceiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
+
+func (m *PostReceiveRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+type PostReceiveResponse struct {
+}
+
+func (m *PostReceiveResponse) Reset()                    { *m = PostReceiveResponse{} }
+func (m *PostReceiveResponse) String() string            { return proto.CompactTextString(m) }
+func (*PostReceiveResponse) ProtoMessage()               {}
+func (*PostReceiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
+
+func init() {
+	proto.RegisterType((*PostReceiveRequest)(nil), "gitaly.PostReceiveRequest")
+	proto.RegisterType((*PostReceiveResponse)(nil), "gitaly.PostReceiveResponse")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for Notifications service
+
+type NotificationsClient interface {
+	PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error)
+}
+
+type notificationsClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewNotificationsClient(cc *grpc.ClientConn) NotificationsClient {
+	return &notificationsClient{cc}
+}
+
+func (c *notificationsClient) PostReceive(ctx context.Context, in *PostReceiveRequest, opts ...grpc.CallOption) (*PostReceiveResponse, error) {
+	out := new(PostReceiveResponse)
+	err := grpc.Invoke(ctx, "/gitaly.Notifications/PostReceive", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Notifications service
+
+type NotificationsServer interface {
+	PostReceive(context.Context, *PostReceiveRequest) (*PostReceiveResponse, error)
+}
+
+func RegisterNotificationsServer(s *grpc.Server, srv NotificationsServer) {
+	s.RegisterService(&_Notifications_serviceDesc, srv)
+}
+
+func _Notifications_PostReceive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(PostReceiveRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NotificationsServer).PostReceive(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.Notifications/PostReceive",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NotificationsServer).PostReceive(ctx, req.(*PostReceiveRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Notifications_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.Notifications",
+	HandlerType: (*NotificationsServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "PostReceive",
+			Handler:    _Notifications_PostReceive_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "notifications.proto",
+}
+
+func init() { proto.RegisterFile("notifications.proto", fileDescriptor2) }
+
+var fileDescriptor2 = []byte{
+	// 163 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xce, 0xcb, 0x2f, 0xc9,
+	0x4c, 0xcb, 0x4c, 0x4e, 0x2c, 0xc9, 0xcc, 0xcf, 0x2b, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17,
+	0x62, 0x4b, 0xcf, 0x2c, 0x49, 0xcc, 0xa9, 0x94, 0xe2, 0x29, 0xce, 0x48, 0x2c, 0x4a, 0x4d, 0x81,
+	0x88, 0x2a, 0x79, 0x70, 0x09, 0x05, 0xe4, 0x17, 0x97, 0x04, 0xa5, 0x26, 0xa7, 0x66, 0x96, 0xa5,
+	0x06, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97, 0x08, 0x19, 0x71, 0x71, 0x15, 0xa5, 0x16, 0xe4, 0x17,
+	0x67, 0x96, 0xe4, 0x17, 0x55, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b, 0x09, 0xe9, 0x41, 0x0c,
+	0xd0, 0x0b, 0x82, 0xcb, 0x04, 0x21, 0xa9, 0x52, 0x12, 0xe5, 0x12, 0x46, 0x31, 0xa9, 0xb8, 0x20,
+	0x3f, 0xaf, 0x38, 0xd5, 0x28, 0x92, 0x8b, 0xd7, 0x0f, 0xd9, 0x35, 0x42, 0x1e, 0x5c, 0xdc, 0x48,
+	0xea, 0x84, 0xa4, 0x60, 0xc6, 0x62, 0x3a, 0x43, 0x4a, 0x1a, 0xab, 0x1c, 0xc4, 0x60, 0x25, 0x86,
+	0x24, 0x36, 0xb0, 0x17, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xf2, 0x5e, 0x1f, 0x64, 0xef,
+	0x00, 0x00, 0x00,
+}

vendor/gitlab.com/gitlab-org/gitaly-proto/go/shared.pb.go

@@ -15,12 +15,14 @@ var _ = math.Inf
 
 type Repository struct {
 	Path         string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
+	StorageName  string `protobuf:"bytes,2,opt,name=storage_name,json=storageName" json:"storage_name,omitempty"`
+	RelativePath string `protobuf:"bytes,3,opt,name=relative_path,json=relativePath" json:"relative_path,omitempty"`
 }
 
 func (m *Repository) Reset()                    { *m = Repository{} }
 func (m *Repository) String() string            { return proto.CompactTextString(m) }
 func (*Repository) ProtoMessage()               {}
-func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
+func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
 
 func (m *Repository) GetPath() string {
 	if m != nil {
@@ -29,6 +31,20 @@ func (m *Repository) GetPath() string {
 	return ""
 }
 
+func (m *Repository) GetStorageName() string {
+	if m != nil {
+		return m.StorageName
+	}
+	return ""
+}
+
+func (m *Repository) GetRelativePath() string {
+	if m != nil {
+		return m.RelativePath
+	}
+	return ""
+}
+
 type ExitStatus struct {
 	Value int32 `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
 }
@@ -36,7 +52,7 @@ type ExitStatus struct {
 func (m *ExitStatus) Reset()                    { *m = ExitStatus{} }
 func (m *ExitStatus) String() string            { return proto.CompactTextString(m) }
 func (*ExitStatus) ProtoMessage()               {}
-func (*ExitStatus) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
+func (*ExitStatus) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} }
 
 func (m *ExitStatus) GetValue() int32 {
 	if m != nil {
@@ -50,15 +66,19 @@ func init() {
 	proto.RegisterType((*ExitStatus)(nil), "gitaly.ExitStatus")
 }
 
-func init() { proto.RegisterFile("shared.proto", fileDescriptor1) }
+func init() { proto.RegisterFile("shared.proto", fileDescriptor4) }
 
-var fileDescriptor1 = []byte{
-	// 111 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x29, 0xce, 0x48, 0x2c,
-	0x4a, 0x4d, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x4b, 0xcf, 0x2c, 0x49, 0xcc, 0xa9,
-	0x54, 0x52, 0xe0, 0xe2, 0x0a, 0x4a, 0x2d, 0xc8, 0x2f, 0xce, 0x2c, 0xc9, 0x2f, 0xaa, 0x14, 0x12,
-	0xe2, 0x62, 0x29, 0x48, 0x2c, 0xc9, 0x90, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0c, 0x02, 0xb3, 0x95,
-	0x94, 0xb8, 0xb8, 0x5c, 0x2b, 0x32, 0x4b, 0x82, 0x4b, 0x12, 0x4b, 0x4a, 0x8b, 0x85, 0x44, 0xb8,
-	0x58, 0xcb, 0x12, 0x73, 0x4a, 0x53, 0xc1, 0x4a, 0x58, 0x83, 0x20, 0x9c, 0x24, 0x36, 0xb0, 0xa1,
-	0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfd, 0x48, 0xc1, 0x82, 0x64, 0x00, 0x00, 0x00,
+var fileDescriptor4 = []byte{
+	// 161 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x34, 0x8e, 0xb1, 0xca, 0xc2, 0x40,
+	0x10, 0x84, 0xc9, 0xff, 0x9b, 0x80, 0x6b, 0x6c, 0x16, 0x8b, 0x94, 0x1a, 0x1b, 0x2b, 0x1b, 0x9f,
+	0xc1, 0x56, 0xe4, 0x7c, 0x80, 0xb0, 0xe2, 0x92, 0x3b, 0xb8, 0x78, 0xc7, 0xdd, 0x26, 0x98, 0xb7,
+	0x17, 0x56, 0xed, 0x76, 0xbf, 0x99, 0x61, 0x06, 0xea, 0x6c, 0x29, 0xf1, 0xe3, 0x18, 0x53, 0x90,
+	0x80, 0x55, 0xef, 0x84, 0xfc, 0xdc, 0x5a, 0x00, 0xc3, 0x31, 0x64, 0x27, 0x21, 0xcd, 0x88, 0xb0,
+	0x88, 0x24, 0xb6, 0x29, 0xb6, 0xc5, 0x61, 0x69, 0xf4, 0xc6, 0x1d, 0xd4, 0x59, 0x42, 0xa2, 0x9e,
+	0xbb, 0x27, 0x0d, 0xdc, 0xfc, 0xa9, 0xb6, 0xfa, 0xb2, 0x0b, 0x0d, 0x8c, 0x7b, 0x58, 0x27, 0xf6,
+	0x24, 0x6e, 0xe2, 0x4e, 0xf3, 0xff, 0xea, 0xa9, 0x7f, 0xf0, 0x4a, 0x62, 0xdb, 0x16, 0xe0, 0xfc,
+	0x72, 0x72, 0x13, 0x92, 0x31, 0xe3, 0x06, 0xca, 0x89, 0xfc, 0xc8, 0x5a, 0x55, 0x9a, 0xcf, 0x73,
+	0xaf, 0x74, 0xdc, 0xe9, 0x1d, 0x00, 0x00, 0xff, 0xff, 0xbd, 0xf7, 0x56, 0x73, 0xac, 0x00, 0x00,
+	0x00,
 }

vendor/gitlab.com/gitlab-org/gitaly-proto/go/ssh.pb.go

@@ -28,7 +28,7 @@ type SSHUploadPackRequest struct {
 func (m *SSHUploadPackRequest) Reset()                    { *m = SSHUploadPackRequest{} }
 func (m *SSHUploadPackRequest) String() string            { return proto.CompactTextString(m) }
 func (*SSHUploadPackRequest) ProtoMessage()               {}
-func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
+func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} }
 
 func (m *SSHUploadPackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -57,7 +57,7 @@ type SSHUploadPackResponse struct {
 func (m *SSHUploadPackResponse) Reset()                    { *m = SSHUploadPackResponse{} }
 func (m *SSHUploadPackResponse) String() string            { return proto.CompactTextString(m) }
 func (*SSHUploadPackResponse) ProtoMessage()               {}
-func (*SSHUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{1} }
+func (*SSHUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1} }
 
 func (m *SSHUploadPackResponse) GetStdout() []byte {
 	if m != nil {
@@ -92,7 +92,7 @@ type SSHReceivePackRequest struct {
 func (m *SSHReceivePackRequest) Reset()                    { *m = SSHReceivePackRequest{} }
 func (m *SSHReceivePackRequest) String() string            { return proto.CompactTextString(m) }
 func (*SSHReceivePackRequest) ProtoMessage()               {}
-func (*SSHReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{2} }
+func (*SSHReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{2} }
 
 func (m *SSHReceivePackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -128,7 +128,7 @@ type SSHReceivePackResponse struct {
 func (m *SSHReceivePackResponse) Reset()                    { *m = SSHReceivePackResponse{} }
 func (m *SSHReceivePackResponse) String() string            { return proto.CompactTextString(m) }
 func (*SSHReceivePackResponse) ProtoMessage()               {}
-func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{3} }
+func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{3} }
 
 func (m *SSHReceivePackResponse) GetStdout() []byte {
 	if m != nil {
@@ -331,11 +331,11 @@ var _SSH_serviceDesc = grpc.ServiceDesc{
 	Metadata: "ssh.proto",
 }
 
-func init() { proto.RegisterFile("ssh.proto", fileDescriptor3) }
+func init() { proto.RegisterFile("ssh.proto", fileDescriptor6) }
 
-var fileDescriptor3 = []byte{
+var fileDescriptor6 = []byte{
 	// 284 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xbc, 0x52, 0xcd, 0x4a, 0xc3, 0x40,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x52, 0xcd, 0x4a, 0xc3, 0x40,
 	0x10, 0x76, 0xad, 0x0d, 0x74, 0x1a, 0x3d, 0xac, 0xb5, 0x84, 0xa0, 0x52, 0x72, 0xca, 0x29, 0x48,
 	0xfa, 0x0c, 0x42, 0xbd, 0xc9, 0x86, 0x9e, 0x6b, 0xec, 0x2e, 0xe9, 0x62, 0xe8, 0xc6, 0x9d, 0x49,
 	0x69, 0x41, 0xdf, 0xc9, 0x47, 0x14, 0x92, 0x58, 0x92, 0x6a, 0x8f, 0xf6, 0xb6, 0x33, 0xdf, 0xce,

vendor/vendor.json

@@ -41,6 +41,12 @@
 			"path": "github.com/golang/protobuf/proto",
 			"revision": "8ee79997227bf9b34611aee7946ae64735e6fd93"
 		},
+		{
+			"checksumSHA1": "sfoot+dHmmOgWZS6GJ5X79ClZM0=",
+			"path": "github.com/golang/protobuf/ptypes/timestamp",
+			"revision": "c9c7427a2a70d2eb3bafa0ab2dc163e45f143317",
+			"revisionTime": "2017-03-07T00:15:33Z"
+		},
 		{
 			"checksumSHA1": "SmBqqqR0T+1Ksx5zwCl295Vey0s=",
 			"comment": "v1.0.0-39-ge8f0f8a",
@@ -122,20 +128,20 @@
 			"revisionTime": "2016-11-17T07:43:51Z"
 		},
 		{
-			"checksumSHA1": "HWuFvDMQ5zp554X4QpVjBUgW5wk=",
+			"checksumSHA1": "qnITGZYkVMWqbOeVVt6jMKJ544M=",
 			"path": "gitlab.com/gitlab-org/gitaly-proto/go",
-			"revision": "84b3ffd032eea7af8df96fb9d7bdc100dac2c569",
-			"revisionTime": "2017-02-27T16:43:55Z",
-			"version": "v0.3.0",
-			"versionExact": "v0.3.0"
+			"revision": "52f77b23166e640a932e50223472d761404afb42",
+			"revisionTime": "2017-03-29T16:52:58Z",
+			"version": "v0.5.0",
+			"versionExact": "v0.5.0"
 		},
 		{
 			"checksumSHA1": "2E36lBoyaVky2EJP1E5ub6Rg+uI=",
 			"path": "gitlab.com/gitlab-org/gitaly-proto/go/helper",
-			"revision": "84b3ffd032eea7af8df96fb9d7bdc100dac2c569",
-			"revisionTime": "2017-02-27T16:43:55Z",
-			"version": "v0.3.0",
-			"versionExact": "v0.3.0"
+			"revision": "52f77b23166e640a932e50223472d761404afb42",
+			"revisionTime": "2017-03-29T16:52:58Z",
+			"version": "v0.5.0",
+			"versionExact": "v0.5.0"
 		},
 		{
 			"checksumSHA1": "9jjO5GjLa0XF/nfWihF02RoH4qc=",