Merge branch 'deprecation-2' into 'master'

Remove deprecated methods

See merge request gitlab-org/gitaly!910

24 files changed, 275 insertions, 1421 deletions

diff --git a/changelogs/unreleased/deprecation-2.yml b/changelogs/unreleased/deprecation-2.yml
new file mode 100644
index 000000000..6831a545e
--- /dev/null
+++ b/changelogs/unreleased/deprecation-2.yml
@@ -0,0 +1,5 @@
+---
+title: Remove deprecated methods
+merge_request: 910
+author:
+type: removed
diff --git a/internal/service/commit/tree_entry.go b/internal/service/commit/tree_entry.go
index cacfe7c26..ea0a5c088 100644
--- a/internal/service/commit/tree_entry.go
+++ b/internal/service/commit/tree_entry.go
@@ -14,7 +14,7 @@ import (
 	"google.golang.org/grpc/status"
 )
 
-func sendTreeEntry(stream gitalypb.Commit_TreeEntryServer, c *catfile.Batch, revision, path string, limit int64) error {
+func sendTreeEntry(stream gitalypb.CommitService_TreeEntryServer, c *catfile.Batch, revision, path string, limit int64) error {
 	treeEntry, err := TreeEntryForRevisionAndPath(c, revision, path)
 	if err != nil {
 		return err
diff --git a/internal/service/commit/tree_entry_test.go b/internal/service/commit/tree_entry_test.go
index 9d221dd82..5bf11378f 100644
--- a/internal/service/commit/tree_entry_test.go
+++ b/internal/service/commit/tree_entry_test.go
@@ -197,7 +197,7 @@ func TestFailedTreeEntryRequestDueToValidationError(t *testing.T) {
 	}
 }
 
-func getTreeEntryFromTreeEntryClient(t *testing.T, client gitalypb.Commit_TreeEntryClient) *treeEntry {
+func getTreeEntryFromTreeEntryClient(t *testing.T, client gitalypb.CommitService_TreeEntryClient) *treeEntry {
 	fetchedTreeEntry := &treeEntry{}
 	firstResponseReceived := false
 
@@ -222,7 +222,7 @@ func getTreeEntryFromTreeEntryClient(t *testing.T, client gitalypb.Commit_TreeEn
 	return fetchedTreeEntry
 }
 
-func assertExactReceivedTreeEntry(t *testing.T, client gitalypb.Commit_TreeEntryClient, expectedTreeEntry *treeEntry) {
+func assertExactReceivedTreeEntry(t *testing.T, client gitalypb.CommitService_TreeEntryClient, expectedTreeEntry *treeEntry) {
 	fetchedTreeEntry := getTreeEntryFromTreeEntryClient(t, client)
 
 	if fetchedTreeEntry.oid != expectedTreeEntry.oid {
@@ -246,7 +246,7 @@ func assertExactReceivedTreeEntry(t *testing.T, client gitalypb.Commit_TreeEntry
 	}
 }
 
-func drainTreeEntryResponse(c gitalypb.Commit_TreeEntryClient) error {
+func drainTreeEntryResponse(c gitalypb.CommitService_TreeEntryClient) error {
 	var err error
 	for err == nil {
 		_, err = c.Recv()
diff --git a/internal/service/diff/commit_test.go b/internal/service/diff/commit_test.go
index 6124ad6c8..0e371843c 100644
--- a/internal/service/diff/commit_test.go
+++ b/internal/service/diff/commit_test.go
@@ -959,7 +959,7 @@ func TestFailedCommitDeltaRequestWithNonExistentCommit(t *testing.T) {
 	testhelper.RequireGrpcError(t, err, codes.Unavailable)
 }
 
-func drainCommitDiffResponse(c gitalypb.Diff_CommitDiffClient) error {
+func drainCommitDiffResponse(c gitalypb.DiffService_CommitDiffClient) error {
 	for {
 		_, err := c.Recv()
 		if err != nil {
@@ -968,7 +968,7 @@ func drainCommitDiffResponse(c gitalypb.Diff_CommitDiffClient) error {
 	}
 }
 
-func drainCommitDeltaResponse(c gitalypb.Diff_CommitDeltaClient) error {
+func drainCommitDeltaResponse(c gitalypb.DiffService_CommitDeltaClient) error {
 	for {
 		_, err := c.Recv()
 		if err != nil {
@@ -1068,7 +1068,7 @@ func assertExactReceivedDiffs(t *testing.T, client gitalypb.DiffService_CommitDi
 	}
 }
 
-func assertExactReceivedDeltas(t *testing.T, client gitalypb.Diff_CommitDeltaClient, expectedDeltas []diff.Diff) {
+func assertExactReceivedDeltas(t *testing.T, client gitalypb.DiffService_CommitDeltaClient, expectedDeltas []diff.Diff) {
 	i := 0
 	for {
 		fetchedDeltas, err := client.Recv()
diff --git a/internal/service/ref/util.go b/internal/service/ref/util.go
index 833f61084..f40221d47 100644
--- a/internal/service/ref/util.go
+++ b/internal/service/ref/util.go
@@ -76,19 +76,19 @@ func buildBranch(c *catfile.Batch, elements [][]byte) (*gitalypb.Branch, error)
 	}, nil
 }
 
-func newFindAllBranchNamesWriter(stream gitalypb.Ref_FindAllBranchNamesServer) lines.Sender {
+func newFindAllBranchNamesWriter(stream gitalypb.RefService_FindAllBranchNamesServer) lines.Sender {
 	return func(refs [][]byte) error {
 		return stream.Send(&gitalypb.FindAllBranchNamesResponse{Names: refs})
 	}
 }
 
-func newFindAllTagNamesWriter(stream gitalypb.Ref_FindAllTagNamesServer) lines.Sender {
+func newFindAllTagNamesWriter(stream gitalypb.RefService_FindAllTagNamesServer) lines.Sender {
 	return func(refs [][]byte) error {
 		return stream.Send(&gitalypb.FindAllTagNamesResponse{Names: refs})
 	}
 }
 
-func newFindLocalBranchesWriter(stream gitalypb.Ref_FindLocalBranchesServer, c *catfile.Batch) lines.Sender {
+func newFindLocalBranchesWriter(stream gitalypb.RefService_FindLocalBranchesServer, c *catfile.Batch) lines.Sender {
 	return func(refs [][]byte) error {
 		var branches []*gitalypb.FindLocalBranchResponse
 
diff --git a/internal/service/smarthttp/receive_pack_test.go b/internal/service/smarthttp/receive_pack_test.go
index d51bcc234..c4b48a9f7 100644
--- a/internal/service/smarthttp/receive_pack_test.go
+++ b/internal/service/smarthttp/receive_pack_test.go
@@ -251,7 +251,7 @@ func TestFailedReceivePackRequestDueToValidationError(t *testing.T) {
 	}
 }
 
-func drainPostReceivePackResponse(stream gitalypb.SmartHTTP_PostReceivePackClient) error {
+func drainPostReceivePackResponse(stream gitalypb.SmartHTTPService_PostReceivePackClient) error {
 	var err error
 	for err == nil {
 		_, err = stream.Recv()
diff --git a/internal/service/ssh/receive_pack_test.go b/internal/service/ssh/receive_pack_test.go
index e5e3d3a56..95753ae14 100644
--- a/internal/service/ssh/receive_pack_test.go
+++ b/internal/service/ssh/receive_pack_test.go
@@ -225,7 +225,7 @@ func makeCommit(t *testing.T, localRepoPath string) ([]byte, []byte, bool) {
 	return oldHead, newHead, t.Failed()
 }
 
-func drainPostReceivePackResponse(stream gitalypb.SSH_SSHReceivePackClient) error {
+func drainPostReceivePackResponse(stream gitalypb.SSHService_SSHReceivePackClient) error {
 	var err error
 	for err == nil {
 		_, err = stream.Recv()
diff --git a/internal/service/ssh/upload_pack_test.go b/internal/service/ssh/upload_pack_test.go
index 34e76a86e..843b766bd 100644
--- a/internal/service/ssh/upload_pack_test.go
+++ b/internal/service/ssh/upload_pack_test.go
@@ -218,7 +218,7 @@ func testClone(t *testing.T, serverSocketPath, storageName, relativePath, localR
 	return string(localHead), string(remoteHead), string(localTags), string(remoteTags), nil
 }
 
-func drainPostUploadPackResponse(stream gitalypb.SSH_SSHUploadPackClient) error {
+func drainPostUploadPackResponse(stream gitalypb.SSHService_SSHUploadPackClient) error {
 	var err error
 	for err == nil {
 		_, err = stream.Recv()
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/blob.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/blob.pb.go
index ccfe493e9..507883ee4 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/blob.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/blob.pb.go
@@ -8,7 +8,6 @@ It is generated from these files:
 	blob.proto
 	commit.proto
 	conflicts.proto
-	deprecated-services.proto
 	diff.proto
 	namespace.proto
 	notifications.proto
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/deprecated-services.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/deprecated-services.pb.go
deleted file mode 100644
index 411d34f10..000000000
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/deprecated-services.pb.go
+++ /dev/null
@@ -1,1146 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: deprecated-services.proto
-
-package gitalypb
-
-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
-
-// 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)
-	TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (Commit_TreeEntryClient, 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
-}
-
-func (c *commitClient) TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (Commit_TreeEntryClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_Commit_serviceDesc.Streams[0], c.cc, "/gitaly.Commit/TreeEntry", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &commitTreeEntryClient{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 Commit_TreeEntryClient interface {
-	Recv() (*TreeEntryResponse, error)
-	grpc.ClientStream
-}
-
-type commitTreeEntryClient struct {
-	grpc.ClientStream
-}
-
-func (x *commitTreeEntryClient) Recv() (*TreeEntryResponse, error) {
-	m := new(TreeEntryResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-// Server API for Commit service
-
-type CommitServer interface {
-	CommitIsAncestor(context.Context, *CommitIsAncestorRequest) (*CommitIsAncestorResponse, error)
-	TreeEntry(*TreeEntryRequest, Commit_TreeEntryServer) 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)
-}
-
-func _Commit_TreeEntry_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(TreeEntryRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
-	}
-	return srv.(CommitServer).TreeEntry(m, &commitTreeEntryServer{stream})
-}
-
-type Commit_TreeEntryServer interface {
-	Send(*TreeEntryResponse) error
-	grpc.ServerStream
-}
-
-type commitTreeEntryServer struct {
-	grpc.ServerStream
-}
-
-func (x *commitTreeEntryServer) Send(m *TreeEntryResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-var _Commit_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "gitaly.Commit",
-	HandlerType: (*CommitServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "CommitIsAncestor",
-			Handler:    _Commit_CommitIsAncestor_Handler,
-		},
-	},
-	Streams: []grpc.StreamDesc{
-		{
-			StreamName:    "TreeEntry",
-			Handler:       _Commit_TreeEntry_Handler,
-			ServerStreams: true,
-		},
-	},
-	Metadata: "deprecated-services.proto",
-}
-
-// Client API for Diff service
-
-type DiffClient interface {
-	// Returns stream of CommitDiffResponse with patches chunked over messages
-	CommitDiff(ctx context.Context, in *CommitDiffRequest, opts ...grpc.CallOption) (Diff_CommitDiffClient, error)
-	// Return a stream so we can divide the response in chunks of deltas
-	CommitDelta(ctx context.Context, in *CommitDeltaRequest, opts ...grpc.CallOption) (Diff_CommitDeltaClient, 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
-}
-
-func (c *diffClient) CommitDelta(ctx context.Context, in *CommitDeltaRequest, opts ...grpc.CallOption) (Diff_CommitDeltaClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_Diff_serviceDesc.Streams[1], c.cc, "/gitaly.Diff/CommitDelta", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &diffCommitDeltaClient{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_CommitDeltaClient interface {
-	Recv() (*CommitDeltaResponse, error)
-	grpc.ClientStream
-}
-
-type diffCommitDeltaClient struct {
-	grpc.ClientStream
-}
-
-func (x *diffCommitDeltaClient) Recv() (*CommitDeltaResponse, error) {
-	m := new(CommitDeltaResponse)
-	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 with patches chunked over messages
-	CommitDiff(*CommitDiffRequest, Diff_CommitDiffServer) error
-	// Return a stream so we can divide the response in chunks of deltas
-	CommitDelta(*CommitDeltaRequest, Diff_CommitDeltaServer) 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)
-}
-
-func _Diff_CommitDelta_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(CommitDeltaRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
-	}
-	return srv.(DiffServer).CommitDelta(m, &diffCommitDeltaServer{stream})
-}
-
-type Diff_CommitDeltaServer interface {
-	Send(*CommitDeltaResponse) error
-	grpc.ServerStream
-}
-
-type diffCommitDeltaServer struct {
-	grpc.ServerStream
-}
-
-func (x *diffCommitDeltaServer) Send(m *CommitDeltaResponse) 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,
-		},
-		{
-			StreamName:    "CommitDelta",
-			Handler:       _Diff_CommitDelta_Handler,
-			ServerStreams: true,
-		},
-	},
-	Metadata: "deprecated-services.proto",
-}
-
-// 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: "deprecated-services.proto",
-}
-
-// Client API for Ref service
-
-type RefClient interface {
-	FindDefaultBranchName(ctx context.Context, in *FindDefaultBranchNameRequest, opts ...grpc.CallOption) (*FindDefaultBranchNameResponse, error)
-	FindAllBranchNames(ctx context.Context, in *FindAllBranchNamesRequest, opts ...grpc.CallOption) (Ref_FindAllBranchNamesClient, error)
-	FindAllTagNames(ctx context.Context, in *FindAllTagNamesRequest, opts ...grpc.CallOption) (Ref_FindAllTagNamesClient, error)
-	// Find a Ref matching the given constraints. Response may be empty.
-	FindRefName(ctx context.Context, in *FindRefNameRequest, opts ...grpc.CallOption) (*FindRefNameResponse, error)
-	// Return a stream so we can divide the response in chunks of branches
-	FindLocalBranches(ctx context.Context, in *FindLocalBranchesRequest, opts ...grpc.CallOption) (Ref_FindLocalBranchesClient, error)
-}
-
-type refClient struct {
-	cc *grpc.ClientConn
-}
-
-func NewRefClient(cc *grpc.ClientConn) RefClient {
-	return &refClient{cc}
-}
-
-func (c *refClient) FindDefaultBranchName(ctx context.Context, in *FindDefaultBranchNameRequest, opts ...grpc.CallOption) (*FindDefaultBranchNameResponse, error) {
-	out := new(FindDefaultBranchNameResponse)
-	err := grpc.Invoke(ctx, "/gitaly.Ref/FindDefaultBranchName", in, out, c.cc, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *refClient) FindAllBranchNames(ctx context.Context, in *FindAllBranchNamesRequest, opts ...grpc.CallOption) (Ref_FindAllBranchNamesClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_Ref_serviceDesc.Streams[0], c.cc, "/gitaly.Ref/FindAllBranchNames", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &refFindAllBranchNamesClient{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 Ref_FindAllBranchNamesClient interface {
-	Recv() (*FindAllBranchNamesResponse, error)
-	grpc.ClientStream
-}
-
-type refFindAllBranchNamesClient struct {
-	grpc.ClientStream
-}
-
-func (x *refFindAllBranchNamesClient) Recv() (*FindAllBranchNamesResponse, error) {
-	m := new(FindAllBranchNamesResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func (c *refClient) FindAllTagNames(ctx context.Context, in *FindAllTagNamesRequest, opts ...grpc.CallOption) (Ref_FindAllTagNamesClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_Ref_serviceDesc.Streams[1], c.cc, "/gitaly.Ref/FindAllTagNames", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &refFindAllTagNamesClient{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 Ref_FindAllTagNamesClient interface {
-	Recv() (*FindAllTagNamesResponse, error)
-	grpc.ClientStream
-}
-
-type refFindAllTagNamesClient struct {
-	grpc.ClientStream
-}
-
-func (x *refFindAllTagNamesClient) Recv() (*FindAllTagNamesResponse, error) {
-	m := new(FindAllTagNamesResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func (c *refClient) FindRefName(ctx context.Context, in *FindRefNameRequest, opts ...grpc.CallOption) (*FindRefNameResponse, error) {
-	out := new(FindRefNameResponse)
-	err := grpc.Invoke(ctx, "/gitaly.Ref/FindRefName", in, out, c.cc, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *refClient) FindLocalBranches(ctx context.Context, in *FindLocalBranchesRequest, opts ...grpc.CallOption) (Ref_FindLocalBranchesClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_Ref_serviceDesc.Streams[2], c.cc, "/gitaly.Ref/FindLocalBranches", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &refFindLocalBranchesClient{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 Ref_FindLocalBranchesClient interface {
-	Recv() (*FindLocalBranchesResponse, error)
-	grpc.ClientStream
-}
-
-type refFindLocalBranchesClient struct {
-	grpc.ClientStream
-}
-
-func (x *refFindLocalBranchesClient) Recv() (*FindLocalBranchesResponse, error) {
-	m := new(FindLocalBranchesResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-// Server API for Ref service
-
-type RefServer interface {
-	FindDefaultBranchName(context.Context, *FindDefaultBranchNameRequest) (*FindDefaultBranchNameResponse, error)
-	FindAllBranchNames(*FindAllBranchNamesRequest, Ref_FindAllBranchNamesServer) error
-	FindAllTagNames(*FindAllTagNamesRequest, Ref_FindAllTagNamesServer) error
-	// Find a Ref matching the given constraints. Response may be empty.
-	FindRefName(context.Context, *FindRefNameRequest) (*FindRefNameResponse, error)
-	// Return a stream so we can divide the response in chunks of branches
-	FindLocalBranches(*FindLocalBranchesRequest, Ref_FindLocalBranchesServer) error
-}
-
-func RegisterRefServer(s *grpc.Server, srv RefServer) {
-	s.RegisterService(&_Ref_serviceDesc, srv)
-}
-
-func _Ref_FindDefaultBranchName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(FindDefaultBranchNameRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(RefServer).FindDefaultBranchName(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/gitaly.Ref/FindDefaultBranchName",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(RefServer).FindDefaultBranchName(ctx, req.(*FindDefaultBranchNameRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Ref_FindAllBranchNames_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(FindAllBranchNamesRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
-	}
-	return srv.(RefServer).FindAllBranchNames(m, &refFindAllBranchNamesServer{stream})
-}
-
-type Ref_FindAllBranchNamesServer interface {
-	Send(*FindAllBranchNamesResponse) error
-	grpc.ServerStream
-}
-
-type refFindAllBranchNamesServer struct {
-	grpc.ServerStream
-}
-
-func (x *refFindAllBranchNamesServer) Send(m *FindAllBranchNamesResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func _Ref_FindAllTagNames_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(FindAllTagNamesRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
-	}
-	return srv.(RefServer).FindAllTagNames(m, &refFindAllTagNamesServer{stream})
-}
-
-type Ref_FindAllTagNamesServer interface {
-	Send(*FindAllTagNamesResponse) error
-	grpc.ServerStream
-}
-
-type refFindAllTagNamesServer struct {
-	grpc.ServerStream
-}
-
-func (x *refFindAllTagNamesServer) Send(m *FindAllTagNamesResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func _Ref_FindRefName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(FindRefNameRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(RefServer).FindRefName(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/gitaly.Ref/FindRefName",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(RefServer).FindRefName(ctx, req.(*FindRefNameRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Ref_FindLocalBranches_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(FindLocalBranchesRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
-	}
-	return srv.(RefServer).FindLocalBranches(m, &refFindLocalBranchesServer{stream})
-}
-
-type Ref_FindLocalBranchesServer interface {
-	Send(*FindLocalBranchesResponse) error
-	grpc.ServerStream
-}
-
-type refFindLocalBranchesServer struct {
-	grpc.ServerStream
-}
-
-func (x *refFindLocalBranchesServer) Send(m *FindLocalBranchesResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-var _Ref_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "gitaly.Ref",
-	HandlerType: (*RefServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "FindDefaultBranchName",
-			Handler:    _Ref_FindDefaultBranchName_Handler,
-		},
-		{
-			MethodName: "FindRefName",
-			Handler:    _Ref_FindRefName_Handler,
-		},
-	},
-	Streams: []grpc.StreamDesc{
-		{
-			StreamName:    "FindAllBranchNames",
-			Handler:       _Ref_FindAllBranchNames_Handler,
-			ServerStreams: true,
-		},
-		{
-			StreamName:    "FindAllTagNames",
-			Handler:       _Ref_FindAllTagNames_Handler,
-			ServerStreams: true,
-		},
-		{
-			StreamName:    "FindLocalBranches",
-			Handler:       _Ref_FindLocalBranches_Handler,
-			ServerStreams: true,
-		},
-	},
-	Metadata: "deprecated-services.proto",
-}
-
-// Client API for SmartHTTP service
-
-type SmartHTTPClient interface {
-	// The response body for GET /info/refs?service=git-upload-pack
-	InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsUploadPackClient, error)
-	// The response body for GET /info/refs?service=git-receive-pack
-	InfoRefsReceivePack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsReceivePackClient, error)
-	// Request and response body for POST /upload-pack
-	PostUploadPack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostUploadPackClient, error)
-	// Request and response body for POST /receive-pack
-	PostReceivePack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostReceivePackClient, error)
-}
-
-type smartHTTPClient struct {
-	cc *grpc.ClientConn
-}
-
-func NewSmartHTTPClient(cc *grpc.ClientConn) SmartHTTPClient {
-	return &smartHTTPClient{cc}
-}
-
-func (c *smartHTTPClient) InfoRefsUploadPack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsUploadPackClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[0], c.cc, "/gitaly.SmartHTTP/InfoRefsUploadPack", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &smartHTTPInfoRefsUploadPackClient{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 SmartHTTP_InfoRefsUploadPackClient interface {
-	Recv() (*InfoRefsResponse, error)
-	grpc.ClientStream
-}
-
-type smartHTTPInfoRefsUploadPackClient struct {
-	grpc.ClientStream
-}
-
-func (x *smartHTTPInfoRefsUploadPackClient) Recv() (*InfoRefsResponse, error) {
-	m := new(InfoRefsResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func (c *smartHTTPClient) InfoRefsReceivePack(ctx context.Context, in *InfoRefsRequest, opts ...grpc.CallOption) (SmartHTTP_InfoRefsReceivePackClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[1], c.cc, "/gitaly.SmartHTTP/InfoRefsReceivePack", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &smartHTTPInfoRefsReceivePackClient{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 SmartHTTP_InfoRefsReceivePackClient interface {
-	Recv() (*InfoRefsResponse, error)
-	grpc.ClientStream
-}
-
-type smartHTTPInfoRefsReceivePackClient struct {
-	grpc.ClientStream
-}
-
-func (x *smartHTTPInfoRefsReceivePackClient) Recv() (*InfoRefsResponse, error) {
-	m := new(InfoRefsResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func (c *smartHTTPClient) PostUploadPack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostUploadPackClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[2], c.cc, "/gitaly.SmartHTTP/PostUploadPack", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &smartHTTPPostUploadPackClient{stream}
-	return x, nil
-}
-
-type SmartHTTP_PostUploadPackClient interface {
-	Send(*PostUploadPackRequest) error
-	Recv() (*PostUploadPackResponse, error)
-	grpc.ClientStream
-}
-
-type smartHTTPPostUploadPackClient struct {
-	grpc.ClientStream
-}
-
-func (x *smartHTTPPostUploadPackClient) Send(m *PostUploadPackRequest) error {
-	return x.ClientStream.SendMsg(m)
-}
-
-func (x *smartHTTPPostUploadPackClient) Recv() (*PostUploadPackResponse, error) {
-	m := new(PostUploadPackResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func (c *smartHTTPClient) PostReceivePack(ctx context.Context, opts ...grpc.CallOption) (SmartHTTP_PostReceivePackClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_SmartHTTP_serviceDesc.Streams[3], c.cc, "/gitaly.SmartHTTP/PostReceivePack", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &smartHTTPPostReceivePackClient{stream}
-	return x, nil
-}
-
-type SmartHTTP_PostReceivePackClient interface {
-	Send(*PostReceivePackRequest) error
-	Recv() (*PostReceivePackResponse, error)
-	grpc.ClientStream
-}
-
-type smartHTTPPostReceivePackClient struct {
-	grpc.ClientStream
-}
-
-func (x *smartHTTPPostReceivePackClient) Send(m *PostReceivePackRequest) error {
-	return x.ClientStream.SendMsg(m)
-}
-
-func (x *smartHTTPPostReceivePackClient) Recv() (*PostReceivePackResponse, error) {
-	m := new(PostReceivePackResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-// Server API for SmartHTTP service
-
-type SmartHTTPServer interface {
-	// The response body for GET /info/refs?service=git-upload-pack
-	InfoRefsUploadPack(*InfoRefsRequest, SmartHTTP_InfoRefsUploadPackServer) error
-	// The response body for GET /info/refs?service=git-receive-pack
-	InfoRefsReceivePack(*InfoRefsRequest, SmartHTTP_InfoRefsReceivePackServer) error
-	// Request and response body for POST /upload-pack
-	PostUploadPack(SmartHTTP_PostUploadPackServer) error
-	// Request and response body for POST /receive-pack
-	PostReceivePack(SmartHTTP_PostReceivePackServer) error
-}
-
-func RegisterSmartHTTPServer(s *grpc.Server, srv SmartHTTPServer) {
-	s.RegisterService(&_SmartHTTP_serviceDesc, srv)
-}
-
-func _SmartHTTP_InfoRefsUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(InfoRefsRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
-	}
-	return srv.(SmartHTTPServer).InfoRefsUploadPack(m, &smartHTTPInfoRefsUploadPackServer{stream})
-}
-
-type SmartHTTP_InfoRefsUploadPackServer interface {
-	Send(*InfoRefsResponse) error
-	grpc.ServerStream
-}
-
-type smartHTTPInfoRefsUploadPackServer struct {
-	grpc.ServerStream
-}
-
-func (x *smartHTTPInfoRefsUploadPackServer) Send(m *InfoRefsResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func _SmartHTTP_InfoRefsReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(InfoRefsRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
-	}
-	return srv.(SmartHTTPServer).InfoRefsReceivePack(m, &smartHTTPInfoRefsReceivePackServer{stream})
-}
-
-type SmartHTTP_InfoRefsReceivePackServer interface {
-	Send(*InfoRefsResponse) error
-	grpc.ServerStream
-}
-
-type smartHTTPInfoRefsReceivePackServer struct {
-	grpc.ServerStream
-}
-
-func (x *smartHTTPInfoRefsReceivePackServer) Send(m *InfoRefsResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func _SmartHTTP_PostUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(SmartHTTPServer).PostUploadPack(&smartHTTPPostUploadPackServer{stream})
-}
-
-type SmartHTTP_PostUploadPackServer interface {
-	Send(*PostUploadPackResponse) error
-	Recv() (*PostUploadPackRequest, error)
-	grpc.ServerStream
-}
-
-type smartHTTPPostUploadPackServer struct {
-	grpc.ServerStream
-}
-
-func (x *smartHTTPPostUploadPackServer) Send(m *PostUploadPackResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func (x *smartHTTPPostUploadPackServer) Recv() (*PostUploadPackRequest, error) {
-	m := new(PostUploadPackRequest)
-	if err := x.ServerStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func _SmartHTTP_PostReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(SmartHTTPServer).PostReceivePack(&smartHTTPPostReceivePackServer{stream})
-}
-
-type SmartHTTP_PostReceivePackServer interface {
-	Send(*PostReceivePackResponse) error
-	Recv() (*PostReceivePackRequest, error)
-	grpc.ServerStream
-}
-
-type smartHTTPPostReceivePackServer struct {
-	grpc.ServerStream
-}
-
-func (x *smartHTTPPostReceivePackServer) Send(m *PostReceivePackResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func (x *smartHTTPPostReceivePackServer) Recv() (*PostReceivePackRequest, error) {
-	m := new(PostReceivePackRequest)
-	if err := x.ServerStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-var _SmartHTTP_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "gitaly.SmartHTTP",
-	HandlerType: (*SmartHTTPServer)(nil),
-	Methods:     []grpc.MethodDesc{},
-	Streams: []grpc.StreamDesc{
-		{
-			StreamName:    "InfoRefsUploadPack",
-			Handler:       _SmartHTTP_InfoRefsUploadPack_Handler,
-			ServerStreams: true,
-		},
-		{
-			StreamName:    "InfoRefsReceivePack",
-			Handler:       _SmartHTTP_InfoRefsReceivePack_Handler,
-			ServerStreams: true,
-		},
-		{
-			StreamName:    "PostUploadPack",
-			Handler:       _SmartHTTP_PostUploadPack_Handler,
-			ServerStreams: true,
-			ClientStreams: true,
-		},
-		{
-			StreamName:    "PostReceivePack",
-			Handler:       _SmartHTTP_PostReceivePack_Handler,
-			ServerStreams: true,
-			ClientStreams: true,
-		},
-	},
-	Metadata: "deprecated-services.proto",
-}
-
-// Client API for SSH service
-
-type SSHClient interface {
-	// To forward 'git upload-pack' to Gitaly for SSH sessions
-	SSHUploadPack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHUploadPackClient, error)
-	// To forward 'git receive-pack' to Gitaly for SSH sessions
-	SSHReceivePack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHReceivePackClient, error)
-}
-
-type sSHClient struct {
-	cc *grpc.ClientConn
-}
-
-func NewSSHClient(cc *grpc.ClientConn) SSHClient {
-	return &sSHClient{cc}
-}
-
-func (c *sSHClient) SSHUploadPack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHUploadPackClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_SSH_serviceDesc.Streams[0], c.cc, "/gitaly.SSH/SSHUploadPack", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &sSHSSHUploadPackClient{stream}
-	return x, nil
-}
-
-type SSH_SSHUploadPackClient interface {
-	Send(*SSHUploadPackRequest) error
-	Recv() (*SSHUploadPackResponse, error)
-	grpc.ClientStream
-}
-
-type sSHSSHUploadPackClient struct {
-	grpc.ClientStream
-}
-
-func (x *sSHSSHUploadPackClient) Send(m *SSHUploadPackRequest) error {
-	return x.ClientStream.SendMsg(m)
-}
-
-func (x *sSHSSHUploadPackClient) Recv() (*SSHUploadPackResponse, error) {
-	m := new(SSHUploadPackResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func (c *sSHClient) SSHReceivePack(ctx context.Context, opts ...grpc.CallOption) (SSH_SSHReceivePackClient, error) {
-	stream, err := grpc.NewClientStream(ctx, &_SSH_serviceDesc.Streams[1], c.cc, "/gitaly.SSH/SSHReceivePack", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &sSHSSHReceivePackClient{stream}
-	return x, nil
-}
-
-type SSH_SSHReceivePackClient interface {
-	Send(*SSHReceivePackRequest) error
-	Recv() (*SSHReceivePackResponse, error)
-	grpc.ClientStream
-}
-
-type sSHSSHReceivePackClient struct {
-	grpc.ClientStream
-}
-
-func (x *sSHSSHReceivePackClient) Send(m *SSHReceivePackRequest) error {
-	return x.ClientStream.SendMsg(m)
-}
-
-func (x *sSHSSHReceivePackClient) Recv() (*SSHReceivePackResponse, error) {
-	m := new(SSHReceivePackResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-// Server API for SSH service
-
-type SSHServer interface {
-	// To forward 'git upload-pack' to Gitaly for SSH sessions
-	SSHUploadPack(SSH_SSHUploadPackServer) error
-	// To forward 'git receive-pack' to Gitaly for SSH sessions
-	SSHReceivePack(SSH_SSHReceivePackServer) error
-}
-
-func RegisterSSHServer(s *grpc.Server, srv SSHServer) {
-	s.RegisterService(&_SSH_serviceDesc, srv)
-}
-
-func _SSH_SSHUploadPack_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(SSHServer).SSHUploadPack(&sSHSSHUploadPackServer{stream})
-}
-
-type SSH_SSHUploadPackServer interface {
-	Send(*SSHUploadPackResponse) error
-	Recv() (*SSHUploadPackRequest, error)
-	grpc.ServerStream
-}
-
-type sSHSSHUploadPackServer struct {
-	grpc.ServerStream
-}
-
-func (x *sSHSSHUploadPackServer) Send(m *SSHUploadPackResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func (x *sSHSSHUploadPackServer) Recv() (*SSHUploadPackRequest, error) {
-	m := new(SSHUploadPackRequest)
-	if err := x.ServerStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func _SSH_SSHReceivePack_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(SSHServer).SSHReceivePack(&sSHSSHReceivePackServer{stream})
-}
-
-type SSH_SSHReceivePackServer interface {
-	Send(*SSHReceivePackResponse) error
-	Recv() (*SSHReceivePackRequest, error)
-	grpc.ServerStream
-}
-
-type sSHSSHReceivePackServer struct {
-	grpc.ServerStream
-}
-
-func (x *sSHSSHReceivePackServer) Send(m *SSHReceivePackResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func (x *sSHSSHReceivePackServer) Recv() (*SSHReceivePackRequest, error) {
-	m := new(SSHReceivePackRequest)
-	if err := x.ServerStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-var _SSH_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "gitaly.SSH",
-	HandlerType: (*SSHServer)(nil),
-	Methods:     []grpc.MethodDesc{},
-	Streams: []grpc.StreamDesc{
-		{
-			StreamName:    "SSHUploadPack",
-			Handler:       _SSH_SSHUploadPack_Handler,
-			ServerStreams: true,
-			ClientStreams: true,
-		},
-		{
-			StreamName:    "SSHReceivePack",
-			Handler:       _SSH_SSHReceivePack_Handler,
-			ServerStreams: true,
-			ClientStreams: true,
-		},
-	},
-	Metadata: "deprecated-services.proto",
-}
-
-func init() { proto.RegisterFile("deprecated-services.proto", fileDescriptor3) }
-
-var fileDescriptor3 = []byte{
-	// 534 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0x5d, 0x6e, 0xd3, 0x40,
-	0x10, 0x80, 0x31, 0x41, 0x91, 0x32, 0xa1, 0x0d, 0x6c, 0x85, 0x68, 0x0c, 0x4d, 0xda, 0x0a, 0x24,
-	0x5e, 0x88, 0xaa, 0x70, 0x82, 0x42, 0x00, 0x17, 0xaa, 0x2a, 0xb2, 0x13, 0x7e, 0x24, 0x24, 0xb4,
-	0x38, 0xb3, 0x8d, 0x85, 0xe3, 0x0d, 0xde, 0x6d, 0xa5, 0x9e, 0x85, 0x03, 0xf0, 0xca, 0x49, 0x78,
-	0xe5, 0x3a, 0xc8, 0x3f, 0x13, 0xaf, 0x13, 0xbb, 0x3c, 0xf4, 0x6d, 0x33, 0xdf, 0xcc, 0xb7, 0x93,
-	0xf1, 0xd8, 0xd0, 0x9d, 0xe1, 0x32, 0x46, 0x9f, 0x6b, 0x9c, 0x3d, 0x57, 0x18, 0x5f, 0x06, 0x3e,
-	0xaa, 0xc1, 0x32, 0x96, 0x5a, 0xb2, 0xe6, 0x79, 0xa0, 0x79, 0x78, 0x65, 0xdf, 0xf5, 0xe5, 0x62,
-	0x11, 0xe8, 0x2c, 0x6a, 0xc3, 0x2c, 0x10, 0x22, 0x3f, 0xef, 0x44, 0x52, 0x07, 0x22, 0xf0, 0xb9,
-	0x0e, 0x64, 0x94, 0x97, 0xd9, 0xad, 0x18, 0x89, 0x77, 0xd4, 0x82, 0xc7, 0x7a, 0xae, 0xf5, 0x92,
-	0x98, 0x52, 0xf3, 0xec, 0x38, 0xfc, 0x65, 0x41, 0xf3, 0x55, 0x2a, 0x66, 0x1f, 0xe1, 0x5e, 0x76,
-	0x3a, 0x51, 0xc7, 0x91, 0x8f, 0x4a, 0xcb, 0x98, 0xf5, 0x07, 0xd9, 0xed, 0x83, 0x75, 0xe2, 0xe2,
-	0x8f, 0x0b, 0x54, 0xda, 0xde, 0xaf, 0x4f, 0x50, 0x4b, 0x19, 0x29, 0x3c, 0xbc, 0xc5, 0x46, 0xd0,
-	0x9a, 0xc4, 0x88, 0xaf, 0x23, 0x1d, 0x5f, 0xb1, 0x5d, 0x2a, 0x58, 0x85, 0x48, 0xd5, 0xad, 0x20,
-	0xe4, 0x38, 0xb2, 0x86, 0x3f, 0x2d, 0xb8, 0x33, 0x0a, 0x84, 0x60, 0x6f, 0x01, 0xb2, 0xcb, 0xd2,
-	0x5f, 0xdd, 0x72, 0x03, 0x49, 0x8c, 0x84, 0x76, 0x15, 0x2a, 0x8c, 0xec, 0x1d, 0xb4, 0x73, 0x82,
-	0xa1, 0xe6, 0x6c, 0x3d, 0x3d, 0x09, 0x92, 0xea, 0x51, 0x25, 0x33, 0xba, 0xfb, 0x0c, 0x5b, 0x67,
-	0xe6, 0x53, 0x60, 0x0e, 0xb4, 0xc7, 0x52, 0x69, 0x17, 0x7d, 0x0c, 0x2e, 0xb1, 0x90, 0x1b, 0xc1,
-	0x0d, 0x79, 0x89, 0x91, 0x7c, 0xf8, 0xa7, 0x01, 0x0d, 0x17, 0x05, 0x13, 0xf0, 0xe0, 0x4d, 0x10,
-	0xcd, 0x46, 0x28, 0xf8, 0x45, 0xa8, 0x5f, 0xc6, 0x3c, 0xf2, 0xe7, 0x67, 0x7c, 0x81, 0xec, 0x09,
-	0xd5, 0x57, 0x62, 0xba, 0xe5, 0xe9, 0x7f, 0xb2, 0x56, 0x8f, 0xeb, 0x2b, 0xb0, 0x24, 0xe5, 0x38,
-	0x0c, 0x0b, 0xac, 0xd8, 0x81, 0x59, 0x5e, 0x66, 0x74, 0xc3, 0xe1, 0x75, 0x29, 0xc6, 0xdc, 0x3f,
-	0x40, 0x27, 0xcf, 0x98, 0xf0, 0xf3, 0xcc, 0xde, 0x5b, 0x2b, 0x25, 0x40, 0xea, 0x7e, 0x2d, 0x37,
-	0xbc, 0x0e, 0xb4, 0x13, 0xec, 0xa2, 0x48, 0xc7, 0x62, 0x9b, 0x35, 0x79, 0x70, 0x63, 0xe4, 0x25,
-	0xb6, 0x1a, 0xc1, 0x17, 0xb8, 0x9f, 0x80, 0x53, 0xe9, 0xf3, 0xfc, 0x5f, 0xa0, 0x62, 0xfb, 0x66,
-	0x4d, 0x09, 0x91, 0xf5, 0xe0, 0x9a, 0x0c, 0x63, 0x57, 0xfe, 0xde, 0x86, 0x96, 0x97, 0xbc, 0x92,
-	0xce, 0x64, 0x32, 0x66, 0xef, 0x81, 0x9d, 0x44, 0x42, 0xba, 0x28, 0xd4, 0x74, 0x19, 0x4a, 0x3e,
-	0x1b, 0x73, 0xff, 0x3b, 0x7b, 0x48, 0x2a, 0x62, 0x74, 0xc7, 0xee, 0x26, 0x30, 0x46, 0x70, 0x0a,
-	0x3b, 0x45, 0x3c, 0x5d, 0xa4, 0x9b, 0xd8, 0xa6, 0xb0, 0x9d, 0xac, 0xa4, 0xd1, 0xd6, 0x9e, 0xb9,
-	0xaa, 0x45, 0x9c, 0x74, 0xbd, 0x3a, 0x4c, 0xd2, 0x67, 0xd6, 0x91, 0xc5, 0x3e, 0x41, 0xc7, 0xd8,
-	0xf4, 0xd4, 0xdb, 0xab, 0x78, 0x05, 0x4c, 0x71, 0xbf, 0x96, 0x9b, 0xe6, 0xe1, 0x6f, 0x0b, 0x1a,
-	0x9e, 0xe7, 0x30, 0x17, 0xb6, 0x3c, 0xcf, 0x31, 0xfa, 0x7e, 0x4c, 0xf5, 0xa5, 0x30, 0xd9, 0xf7,
-	0x6a, 0x68, 0xa9, 0xeb, 0x29, 0x6c, 0x7b, 0x9e, 0x63, 0x36, 0x6d, 0x96, 0x55, 0xf4, 0xdc, 0xab,
-	0xc3, 0xa6, 0xf6, 0x5b, 0x33, 0xfd, 0x0e, 0xbf, 0xf8, 0x17, 0x00, 0x00, 0xff, 0xff, 0x79, 0x83,
-	0xb6, 0xb0, 0x02, 0x06, 0x00, 0x00,
-}
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/diff.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/diff.pb.go
index ddd573473..a4ae94db6 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/diff.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/diff.pb.go
@@ -39,7 +39,7 @@ type CommitDiffRequest struct {
 func (m *CommitDiffRequest) Reset()                    { *m = CommitDiffRequest{} }
 func (m *CommitDiffRequest) String() string            { return proto.CompactTextString(m) }
 func (*CommitDiffRequest) ProtoMessage()               {}
-func (*CommitDiffRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
+func (*CommitDiffRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
 
 func (m *CommitDiffRequest) GetRepository() *Repository {
 	if m != nil {
@@ -165,7 +165,7 @@ type CommitDiffResponse struct {
 func (m *CommitDiffResponse) Reset()                    { *m = CommitDiffResponse{} }
 func (m *CommitDiffResponse) String() string            { return proto.CompactTextString(m) }
 func (*CommitDiffResponse) ProtoMessage()               {}
-func (*CommitDiffResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} }
+func (*CommitDiffResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{1} }
 
 func (m *CommitDiffResponse) GetFromPath() []byte {
 	if m != nil {
@@ -261,7 +261,7 @@ type CommitDeltaRequest struct {
 func (m *CommitDeltaRequest) Reset()                    { *m = CommitDeltaRequest{} }
 func (m *CommitDeltaRequest) String() string            { return proto.CompactTextString(m) }
 func (*CommitDeltaRequest) ProtoMessage()               {}
-func (*CommitDeltaRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{2} }
+func (*CommitDeltaRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{2} }
 
 func (m *CommitDeltaRequest) GetRepository() *Repository {
 	if m != nil {
@@ -304,7 +304,7 @@ type CommitDelta struct {
 func (m *CommitDelta) Reset()                    { *m = CommitDelta{} }
 func (m *CommitDelta) String() string            { return proto.CompactTextString(m) }
 func (*CommitDelta) ProtoMessage()               {}
-func (*CommitDelta) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{3} }
+func (*CommitDelta) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{3} }
 
 func (m *CommitDelta) GetFromPath() []byte {
 	if m != nil {
@@ -355,7 +355,7 @@ type CommitDeltaResponse struct {
 func (m *CommitDeltaResponse) Reset()                    { *m = CommitDeltaResponse{} }
 func (m *CommitDeltaResponse) String() string            { return proto.CompactTextString(m) }
 func (*CommitDeltaResponse) ProtoMessage()               {}
-func (*CommitDeltaResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{4} }
+func (*CommitDeltaResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{4} }
 
 func (m *CommitDeltaResponse) GetDeltas() []*CommitDelta {
 	if m != nil {
@@ -372,7 +372,7 @@ type CommitPatchRequest struct {
 func (m *CommitPatchRequest) Reset()                    { *m = CommitPatchRequest{} }
 func (m *CommitPatchRequest) String() string            { return proto.CompactTextString(m) }
 func (*CommitPatchRequest) ProtoMessage()               {}
-func (*CommitPatchRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{5} }
+func (*CommitPatchRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{5} }
 
 func (m *CommitPatchRequest) GetRepository() *Repository {
 	if m != nil {
@@ -395,7 +395,7 @@ type CommitPatchResponse struct {
 func (m *CommitPatchResponse) Reset()                    { *m = CommitPatchResponse{} }
 func (m *CommitPatchResponse) String() string            { return proto.CompactTextString(m) }
 func (*CommitPatchResponse) ProtoMessage()               {}
-func (*CommitPatchResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{6} }
+func (*CommitPatchResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{6} }
 
 func (m *CommitPatchResponse) GetData() []byte {
 	if m != nil {
@@ -413,7 +413,7 @@ type RawDiffRequest struct {
 func (m *RawDiffRequest) Reset()                    { *m = RawDiffRequest{} }
 func (m *RawDiffRequest) String() string            { return proto.CompactTextString(m) }
 func (*RawDiffRequest) ProtoMessage()               {}
-func (*RawDiffRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{7} }
+func (*RawDiffRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{7} }
 
 func (m *RawDiffRequest) GetRepository() *Repository {
 	if m != nil {
@@ -443,7 +443,7 @@ type RawDiffResponse struct {
 func (m *RawDiffResponse) Reset()                    { *m = RawDiffResponse{} }
 func (m *RawDiffResponse) String() string            { return proto.CompactTextString(m) }
 func (*RawDiffResponse) ProtoMessage()               {}
-func (*RawDiffResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{8} }
+func (*RawDiffResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{8} }
 
 func (m *RawDiffResponse) GetData() []byte {
 	if m != nil {
@@ -461,7 +461,7 @@ type RawPatchRequest struct {
 func (m *RawPatchRequest) Reset()                    { *m = RawPatchRequest{} }
 func (m *RawPatchRequest) String() string            { return proto.CompactTextString(m) }
 func (*RawPatchRequest) ProtoMessage()               {}
-func (*RawPatchRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{9} }
+func (*RawPatchRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{9} }
 
 func (m *RawPatchRequest) GetRepository() *Repository {
 	if m != nil {
@@ -491,7 +491,7 @@ type RawPatchResponse struct {
 func (m *RawPatchResponse) Reset()                    { *m = RawPatchResponse{} }
 func (m *RawPatchResponse) String() string            { return proto.CompactTextString(m) }
 func (*RawPatchResponse) ProtoMessage()               {}
-func (*RawPatchResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{10} }
+func (*RawPatchResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{10} }
 
 func (m *RawPatchResponse) GetData() []byte {
 	if m != nil {
@@ -509,7 +509,7 @@ type DiffStatsRequest struct {
 func (m *DiffStatsRequest) Reset()                    { *m = DiffStatsRequest{} }
 func (m *DiffStatsRequest) String() string            { return proto.CompactTextString(m) }
 func (*DiffStatsRequest) ProtoMessage()               {}
-func (*DiffStatsRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{11} }
+func (*DiffStatsRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{11} }
 
 func (m *DiffStatsRequest) GetRepository() *Repository {
 	if m != nil {
@@ -541,7 +541,7 @@ type DiffStats struct {
 func (m *DiffStats) Reset()                    { *m = DiffStats{} }
 func (m *DiffStats) String() string            { return proto.CompactTextString(m) }
 func (*DiffStats) ProtoMessage()               {}
-func (*DiffStats) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{12} }
+func (*DiffStats) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{12} }
 
 func (m *DiffStats) GetPath() []byte {
 	if m != nil {
@@ -571,7 +571,7 @@ type DiffStatsResponse struct {
 func (m *DiffStatsResponse) Reset()                    { *m = DiffStatsResponse{} }
 func (m *DiffStatsResponse) String() string            { return proto.CompactTextString(m) }
 func (*DiffStatsResponse) ProtoMessage()               {}
-func (*DiffStatsResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{13} }
+func (*DiffStatsResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{13} }
 
 func (m *DiffStatsResponse) GetStats() []*DiffStats {
 	if m != nil {
@@ -1000,9 +1000,9 @@ var _DiffService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "diff.proto",
 }
 
-func init() { proto.RegisterFile("diff.proto", fileDescriptor4) }
+func init() { proto.RegisterFile("diff.proto", fileDescriptor3) }
 
-var fileDescriptor4 = []byte{
+var fileDescriptor3 = []byte{
 	// 864 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0x4d, 0x6f, 0xe3, 0x44,
 	0x18, 0xc6, 0xcd, 0x47, 0x9d, 0x37, 0x6e, 0xda, 0x4e, 0x51, 0xd7, 0xcd, 0x72, 0x88, 0x2c, 0xb6,
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/namespace.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/namespace.pb.go
index 3976a4ce9..13655ce50 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/namespace.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/namespace.pb.go
@@ -25,7 +25,7 @@ type AddNamespaceRequest struct {
 func (m *AddNamespaceRequest) Reset()                    { *m = AddNamespaceRequest{} }
 func (m *AddNamespaceRequest) String() string            { return proto.CompactTextString(m) }
 func (*AddNamespaceRequest) ProtoMessage()               {}
-func (*AddNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} }
+func (*AddNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
 
 func (m *AddNamespaceRequest) GetStorageName() string {
 	if m != nil {
@@ -49,7 +49,7 @@ type RemoveNamespaceRequest struct {
 func (m *RemoveNamespaceRequest) Reset()                    { *m = RemoveNamespaceRequest{} }
 func (m *RemoveNamespaceRequest) String() string            { return proto.CompactTextString(m) }
 func (*RemoveNamespaceRequest) ProtoMessage()               {}
-func (*RemoveNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1} }
+func (*RemoveNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} }
 
 func (m *RemoveNamespaceRequest) GetStorageName() string {
 	if m != nil {
@@ -74,7 +74,7 @@ type RenameNamespaceRequest struct {
 func (m *RenameNamespaceRequest) Reset()                    { *m = RenameNamespaceRequest{} }
 func (m *RenameNamespaceRequest) String() string            { return proto.CompactTextString(m) }
 func (*RenameNamespaceRequest) ProtoMessage()               {}
-func (*RenameNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{2} }
+func (*RenameNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{2} }
 
 func (m *RenameNamespaceRequest) GetStorageName() string {
 	if m != nil {
@@ -105,7 +105,7 @@ type NamespaceExistsRequest struct {
 func (m *NamespaceExistsRequest) Reset()                    { *m = NamespaceExistsRequest{} }
 func (m *NamespaceExistsRequest) String() string            { return proto.CompactTextString(m) }
 func (*NamespaceExistsRequest) ProtoMessage()               {}
-func (*NamespaceExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{3} }
+func (*NamespaceExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{3} }
 
 func (m *NamespaceExistsRequest) GetStorageName() string {
 	if m != nil {
@@ -128,7 +128,7 @@ type NamespaceExistsResponse struct {
 func (m *NamespaceExistsResponse) Reset()                    { *m = NamespaceExistsResponse{} }
 func (m *NamespaceExistsResponse) String() string            { return proto.CompactTextString(m) }
 func (*NamespaceExistsResponse) ProtoMessage()               {}
-func (*NamespaceExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{4} }
+func (*NamespaceExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{4} }
 
 func (m *NamespaceExistsResponse) GetExists() bool {
 	if m != nil {
@@ -143,7 +143,7 @@ type AddNamespaceResponse struct {
 func (m *AddNamespaceResponse) Reset()                    { *m = AddNamespaceResponse{} }
 func (m *AddNamespaceResponse) String() string            { return proto.CompactTextString(m) }
 func (*AddNamespaceResponse) ProtoMessage()               {}
-func (*AddNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{5} }
+func (*AddNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{5} }
 
 type RemoveNamespaceResponse struct {
 }
@@ -151,7 +151,7 @@ type RemoveNamespaceResponse struct {
 func (m *RemoveNamespaceResponse) Reset()                    { *m = RemoveNamespaceResponse{} }
 func (m *RemoveNamespaceResponse) String() string            { return proto.CompactTextString(m) }
 func (*RemoveNamespaceResponse) ProtoMessage()               {}
-func (*RemoveNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{6} }
+func (*RemoveNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{6} }
 
 type RenameNamespaceResponse struct {
 }
@@ -159,7 +159,7 @@ type RenameNamespaceResponse struct {
 func (m *RenameNamespaceResponse) Reset()                    { *m = RenameNamespaceResponse{} }
 func (m *RenameNamespaceResponse) String() string            { return proto.CompactTextString(m) }
 func (*RenameNamespaceResponse) ProtoMessage()               {}
-func (*RenameNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{7} }
+func (*RenameNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{7} }
 
 func init() {
 	proto.RegisterType((*AddNamespaceRequest)(nil), "gitaly.AddNamespaceRequest")
@@ -343,9 +343,9 @@ var _NamespaceService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "namespace.proto",
 }
 
-func init() { proto.RegisterFile("namespace.proto", fileDescriptor5) }
+func init() { proto.RegisterFile("namespace.proto", fileDescriptor4) }
 
-var fileDescriptor5 = []byte{
+var fileDescriptor4 = []byte{
 	// 291 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xcf, 0x4b, 0xcc, 0x4d,
 	0x2d, 0x2e, 0x48, 0x4c, 0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x4b, 0xcf, 0x2c,
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/notifications.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/notifications.pb.go
index 56918cd44..381b9aec4 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/notifications.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/notifications.pb.go
@@ -24,7 +24,7 @@ type PostReceiveRequest struct {
 func (m *PostReceiveRequest) Reset()                    { *m = PostReceiveRequest{} }
 func (m *PostReceiveRequest) String() string            { return proto.CompactTextString(m) }
 func (*PostReceiveRequest) ProtoMessage()               {}
-func (*PostReceiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} }
+func (*PostReceiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} }
 
 func (m *PostReceiveRequest) GetRepository() *Repository {
 	if m != nil {
@@ -39,7 +39,7 @@ 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 fileDescriptor6, []int{1} }
+func (*PostReceiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1} }
 
 func init() {
 	proto.RegisterType((*PostReceiveRequest)(nil), "gitaly.PostReceiveRequest")
@@ -118,9 +118,9 @@ var _NotificationService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "notifications.proto",
 }
 
-func init() { proto.RegisterFile("notifications.proto", fileDescriptor6) }
+func init() { proto.RegisterFile("notifications.proto", fileDescriptor5) }
 
-var fileDescriptor6 = []byte{
+var fileDescriptor5 = []byte{
 	// 170 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,
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/operations.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/operations.pb.go
index 314d0191a..9890491d0 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/operations.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/operations.pb.go
@@ -49,7 +49,7 @@ func (x UserCommitFilesActionHeader_ActionType) String() string {
 	return proto.EnumName(UserCommitFilesActionHeader_ActionType_name, int32(x))
 }
 func (UserCommitFilesActionHeader_ActionType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor7, []int{19, 0}
+	return fileDescriptor6, []int{19, 0}
 }
 
 type UserCreateBranchRequest struct {
@@ -62,7 +62,7 @@ type UserCreateBranchRequest struct {
 func (m *UserCreateBranchRequest) Reset()                    { *m = UserCreateBranchRequest{} }
 func (m *UserCreateBranchRequest) String() string            { return proto.CompactTextString(m) }
 func (*UserCreateBranchRequest) ProtoMessage()               {}
-func (*UserCreateBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{0} }
+func (*UserCreateBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} }
 
 func (m *UserCreateBranchRequest) GetRepository() *Repository {
 	if m != nil {
@@ -102,7 +102,7 @@ type UserCreateBranchResponse struct {
 func (m *UserCreateBranchResponse) Reset()                    { *m = UserCreateBranchResponse{} }
 func (m *UserCreateBranchResponse) String() string            { return proto.CompactTextString(m) }
 func (*UserCreateBranchResponse) ProtoMessage()               {}
-func (*UserCreateBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{1} }
+func (*UserCreateBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1} }
 
 func (m *UserCreateBranchResponse) GetBranch() *Branch {
 	if m != nil {
@@ -129,7 +129,7 @@ type UserUpdateBranchRequest struct {
 func (m *UserUpdateBranchRequest) Reset()                    { *m = UserUpdateBranchRequest{} }
 func (m *UserUpdateBranchRequest) String() string            { return proto.CompactTextString(m) }
 func (*UserUpdateBranchRequest) ProtoMessage()               {}
-func (*UserUpdateBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{2} }
+func (*UserUpdateBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{2} }
 
 func (m *UserUpdateBranchRequest) GetRepository() *Repository {
 	if m != nil {
@@ -173,7 +173,7 @@ type UserUpdateBranchResponse struct {
 func (m *UserUpdateBranchResponse) Reset()                    { *m = UserUpdateBranchResponse{} }
 func (m *UserUpdateBranchResponse) String() string            { return proto.CompactTextString(m) }
 func (*UserUpdateBranchResponse) ProtoMessage()               {}
-func (*UserUpdateBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{3} }
+func (*UserUpdateBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{3} }
 
 func (m *UserUpdateBranchResponse) GetPreReceiveError() string {
 	if m != nil {
@@ -191,7 +191,7 @@ type UserDeleteBranchRequest struct {
 func (m *UserDeleteBranchRequest) Reset()                    { *m = UserDeleteBranchRequest{} }
 func (m *UserDeleteBranchRequest) String() string            { return proto.CompactTextString(m) }
 func (*UserDeleteBranchRequest) ProtoMessage()               {}
-func (*UserDeleteBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{4} }
+func (*UserDeleteBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{4} }
 
 func (m *UserDeleteBranchRequest) GetRepository() *Repository {
 	if m != nil {
@@ -221,7 +221,7 @@ type UserDeleteBranchResponse struct {
 func (m *UserDeleteBranchResponse) Reset()                    { *m = UserDeleteBranchResponse{} }
 func (m *UserDeleteBranchResponse) String() string            { return proto.CompactTextString(m) }
 func (*UserDeleteBranchResponse) ProtoMessage()               {}
-func (*UserDeleteBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{5} }
+func (*UserDeleteBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{5} }
 
 func (m *UserDeleteBranchResponse) GetPreReceiveError() string {
 	if m != nil {
@@ -239,7 +239,7 @@ type UserDeleteTagRequest struct {
 func (m *UserDeleteTagRequest) Reset()                    { *m = UserDeleteTagRequest{} }
 func (m *UserDeleteTagRequest) String() string            { return proto.CompactTextString(m) }
 func (*UserDeleteTagRequest) ProtoMessage()               {}
-func (*UserDeleteTagRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{6} }
+func (*UserDeleteTagRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{6} }
 
 func (m *UserDeleteTagRequest) GetRepository() *Repository {
 	if m != nil {
@@ -269,7 +269,7 @@ type UserDeleteTagResponse struct {
 func (m *UserDeleteTagResponse) Reset()                    { *m = UserDeleteTagResponse{} }
 func (m *UserDeleteTagResponse) String() string            { return proto.CompactTextString(m) }
 func (*UserDeleteTagResponse) ProtoMessage()               {}
-func (*UserDeleteTagResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{7} }
+func (*UserDeleteTagResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{7} }
 
 func (m *UserDeleteTagResponse) GetPreReceiveError() string {
 	if m != nil {
@@ -289,7 +289,7 @@ type UserCreateTagRequest struct {
 func (m *UserCreateTagRequest) Reset()                    { *m = UserCreateTagRequest{} }
 func (m *UserCreateTagRequest) String() string            { return proto.CompactTextString(m) }
 func (*UserCreateTagRequest) ProtoMessage()               {}
-func (*UserCreateTagRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{8} }
+func (*UserCreateTagRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{8} }
 
 func (m *UserCreateTagRequest) GetRepository() *Repository {
 	if m != nil {
@@ -335,7 +335,7 @@ type UserCreateTagResponse struct {
 func (m *UserCreateTagResponse) Reset()                    { *m = UserCreateTagResponse{} }
 func (m *UserCreateTagResponse) String() string            { return proto.CompactTextString(m) }
 func (*UserCreateTagResponse) ProtoMessage()               {}
-func (*UserCreateTagResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{9} }
+func (*UserCreateTagResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{9} }
 
 func (m *UserCreateTagResponse) GetTag() *Tag {
 	if m != nil {
@@ -373,7 +373,7 @@ type UserMergeBranchRequest struct {
 func (m *UserMergeBranchRequest) Reset()                    { *m = UserMergeBranchRequest{} }
 func (m *UserMergeBranchRequest) String() string            { return proto.CompactTextString(m) }
 func (*UserMergeBranchRequest) ProtoMessage()               {}
-func (*UserMergeBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{10} }
+func (*UserMergeBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{10} }
 
 func (m *UserMergeBranchRequest) GetRepository() *Repository {
 	if m != nil {
@@ -430,7 +430,7 @@ type UserMergeBranchResponse struct {
 func (m *UserMergeBranchResponse) Reset()                    { *m = UserMergeBranchResponse{} }
 func (m *UserMergeBranchResponse) String() string            { return proto.CompactTextString(m) }
 func (*UserMergeBranchResponse) ProtoMessage()               {}
-func (*UserMergeBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{11} }
+func (*UserMergeBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{11} }
 
 func (m *UserMergeBranchResponse) GetCommitId() string {
 	if m != nil {
@@ -465,7 +465,7 @@ type OperationBranchUpdate struct {
 func (m *OperationBranchUpdate) Reset()                    { *m = OperationBranchUpdate{} }
 func (m *OperationBranchUpdate) String() string            { return proto.CompactTextString(m) }
 func (*OperationBranchUpdate) ProtoMessage()               {}
-func (*OperationBranchUpdate) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{12} }
+func (*OperationBranchUpdate) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{12} }
 
 func (m *OperationBranchUpdate) GetCommitId() string {
 	if m != nil {
@@ -498,7 +498,7 @@ type UserFFBranchRequest struct {
 func (m *UserFFBranchRequest) Reset()                    { *m = UserFFBranchRequest{} }
 func (m *UserFFBranchRequest) String() string            { return proto.CompactTextString(m) }
 func (*UserFFBranchRequest) ProtoMessage()               {}
-func (*UserFFBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{13} }
+func (*UserFFBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{13} }
 
 func (m *UserFFBranchRequest) GetRepository() *Repository {
 	if m != nil {
@@ -536,7 +536,7 @@ type UserFFBranchResponse struct {
 func (m *UserFFBranchResponse) Reset()                    { *m = UserFFBranchResponse{} }
 func (m *UserFFBranchResponse) String() string            { return proto.CompactTextString(m) }
 func (*UserFFBranchResponse) ProtoMessage()               {}
-func (*UserFFBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{14} }
+func (*UserFFBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{14} }
 
 func (m *UserFFBranchResponse) GetBranchUpdate() *OperationBranchUpdate {
 	if m != nil {
@@ -565,7 +565,7 @@ type UserCherryPickRequest struct {
 func (m *UserCherryPickRequest) Reset()                    { *m = UserCherryPickRequest{} }
 func (m *UserCherryPickRequest) String() string            { return proto.CompactTextString(m) }
 func (*UserCherryPickRequest) ProtoMessage()               {}
-func (*UserCherryPickRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{15} }
+func (*UserCherryPickRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{15} }
 
 func (m *UserCherryPickRequest) GetRepository() *Repository {
 	if m != nil {
@@ -626,7 +626,7 @@ type UserCherryPickResponse struct {
 func (m *UserCherryPickResponse) Reset()                    { *m = UserCherryPickResponse{} }
 func (m *UserCherryPickResponse) String() string            { return proto.CompactTextString(m) }
 func (*UserCherryPickResponse) ProtoMessage()               {}
-func (*UserCherryPickResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{16} }
+func (*UserCherryPickResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{16} }
 
 func (m *UserCherryPickResponse) GetBranchUpdate() *OperationBranchUpdate {
 	if m != nil {
@@ -669,7 +669,7 @@ type UserRevertRequest struct {
 func (m *UserRevertRequest) Reset()                    { *m = UserRevertRequest{} }
 func (m *UserRevertRequest) String() string            { return proto.CompactTextString(m) }
 func (*UserRevertRequest) ProtoMessage()               {}
-func (*UserRevertRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{17} }
+func (*UserRevertRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{17} }
 
 func (m *UserRevertRequest) GetRepository() *Repository {
 	if m != nil {
@@ -730,7 +730,7 @@ type UserRevertResponse struct {
 func (m *UserRevertResponse) Reset()                    { *m = UserRevertResponse{} }
 func (m *UserRevertResponse) String() string            { return proto.CompactTextString(m) }
 func (*UserRevertResponse) ProtoMessage()               {}
-func (*UserRevertResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{18} }
+func (*UserRevertResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{18} }
 
 func (m *UserRevertResponse) GetBranchUpdate() *OperationBranchUpdate {
 	if m != nil {
@@ -771,7 +771,7 @@ type UserCommitFilesActionHeader struct {
 func (m *UserCommitFilesActionHeader) Reset()                    { *m = UserCommitFilesActionHeader{} }
 func (m *UserCommitFilesActionHeader) String() string            { return proto.CompactTextString(m) }
 func (*UserCommitFilesActionHeader) ProtoMessage()               {}
-func (*UserCommitFilesActionHeader) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{19} }
+func (*UserCommitFilesActionHeader) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{19} }
 
 func (m *UserCommitFilesActionHeader) GetAction() UserCommitFilesActionHeader_ActionType {
 	if m != nil {
@@ -818,7 +818,7 @@ type UserCommitFilesAction struct {
 func (m *UserCommitFilesAction) Reset()                    { *m = UserCommitFilesAction{} }
 func (m *UserCommitFilesAction) String() string            { return proto.CompactTextString(m) }
 func (*UserCommitFilesAction) ProtoMessage()               {}
-func (*UserCommitFilesAction) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{20} }
+func (*UserCommitFilesAction) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{20} }
 
 type isUserCommitFilesAction_UserCommitFilesActionPayload interface{ isUserCommitFilesAction_UserCommitFilesActionPayload() }
 
@@ -937,7 +937,7 @@ type UserCommitFilesRequestHeader struct {
 func (m *UserCommitFilesRequestHeader) Reset()                    { *m = UserCommitFilesRequestHeader{} }
 func (m *UserCommitFilesRequestHeader) String() string            { return proto.CompactTextString(m) }
 func (*UserCommitFilesRequestHeader) ProtoMessage()               {}
-func (*UserCommitFilesRequestHeader) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{21} }
+func (*UserCommitFilesRequestHeader) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{21} }
 
 func (m *UserCommitFilesRequestHeader) GetRepository() *Repository {
 	if m != nil {
@@ -1005,7 +1005,7 @@ type UserCommitFilesRequest struct {
 func (m *UserCommitFilesRequest) Reset()                    { *m = UserCommitFilesRequest{} }
 func (m *UserCommitFilesRequest) String() string            { return proto.CompactTextString(m) }
 func (*UserCommitFilesRequest) ProtoMessage()               {}
-func (*UserCommitFilesRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{22} }
+func (*UserCommitFilesRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{22} }
 
 type isUserCommitFilesRequest_UserCommitFilesRequestPayload interface{ isUserCommitFilesRequest_UserCommitFilesRequestPayload() }
 
@@ -1123,7 +1123,7 @@ type UserCommitFilesResponse struct {
 func (m *UserCommitFilesResponse) Reset()                    { *m = UserCommitFilesResponse{} }
 func (m *UserCommitFilesResponse) String() string            { return proto.CompactTextString(m) }
 func (*UserCommitFilesResponse) ProtoMessage()               {}
-func (*UserCommitFilesResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{23} }
+func (*UserCommitFilesResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{23} }
 
 func (m *UserCommitFilesResponse) GetBranchUpdate() *OperationBranchUpdate {
 	if m != nil {
@@ -1159,7 +1159,7 @@ type UserRebaseRequest struct {
 func (m *UserRebaseRequest) Reset()                    { *m = UserRebaseRequest{} }
 func (m *UserRebaseRequest) String() string            { return proto.CompactTextString(m) }
 func (*UserRebaseRequest) ProtoMessage()               {}
-func (*UserRebaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{24} }
+func (*UserRebaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{24} }
 
 func (m *UserRebaseRequest) GetRepository() *Repository {
 	if m != nil {
@@ -1219,7 +1219,7 @@ type UserRebaseResponse struct {
 func (m *UserRebaseResponse) Reset()                    { *m = UserRebaseResponse{} }
 func (m *UserRebaseResponse) String() string            { return proto.CompactTextString(m) }
 func (*UserRebaseResponse) ProtoMessage()               {}
-func (*UserRebaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{25} }
+func (*UserRebaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{25} }
 
 func (m *UserRebaseResponse) GetRebaseSha() string {
 	if m != nil {
@@ -1256,7 +1256,7 @@ type UserSquashRequest struct {
 func (m *UserSquashRequest) Reset()                    { *m = UserSquashRequest{} }
 func (m *UserSquashRequest) String() string            { return proto.CompactTextString(m) }
 func (*UserSquashRequest) ProtoMessage()               {}
-func (*UserSquashRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{26} }
+func (*UserSquashRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{26} }
 
 func (m *UserSquashRequest) GetRepository() *Repository {
 	if m != nil {
@@ -1322,7 +1322,7 @@ type UserSquashResponse struct {
 func (m *UserSquashResponse) Reset()                    { *m = UserSquashResponse{} }
 func (m *UserSquashResponse) String() string            { return proto.CompactTextString(m) }
 func (*UserSquashResponse) ProtoMessage()               {}
-func (*UserSquashResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{27} }
+func (*UserSquashResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{27} }
 
 func (m *UserSquashResponse) GetSquashSha() string {
 	if m != nil {
@@ -1872,9 +1872,9 @@ var _OperationService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "operations.proto",
 }
 
-func init() { proto.RegisterFile("operations.proto", fileDescriptor7) }
+func init() { proto.RegisterFile("operations.proto", fileDescriptor6) }
 
-var fileDescriptor7 = []byte{
+var fileDescriptor6 = []byte{
 	// 1545 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcd, 0x6f, 0x1b, 0xd5,
 	0x16, 0xf7, 0xd8, 0xce, 0xd8, 0x39, 0x71, 0x1c, 0xe7, 0xf6, 0xcb, 0x75, 0x9b, 0x26, 0x9d, 0xb6,
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/ref.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/ref.pb.go
index 3b5182b06..a775dceac 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/ref.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/ref.pb.go
@@ -41,7 +41,7 @@ func (x FindLocalBranchesRequest_SortBy) String() string {
 	return proto.EnumName(FindLocalBranchesRequest_SortBy_name, int32(x))
 }
 func (FindLocalBranchesRequest_SortBy) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor8, []int{10, 0}
+	return fileDescriptor7, []int{10, 0}
 }
 
 type CreateBranchResponse_Status int32
@@ -70,7 +70,7 @@ func (x CreateBranchResponse_Status) String() string {
 	return proto.EnumName(CreateBranchResponse_Status_name, int32(x))
 }
 func (CreateBranchResponse_Status) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor8, []int{21, 0}
+	return fileDescriptor7, []int{21, 0}
 }
 
 type ListNewBlobsRequest struct {
@@ -84,7 +84,7 @@ type ListNewBlobsRequest struct {
 func (m *ListNewBlobsRequest) Reset()                    { *m = ListNewBlobsRequest{} }
 func (m *ListNewBlobsRequest) String() string            { return proto.CompactTextString(m) }
 func (*ListNewBlobsRequest) ProtoMessage()               {}
-func (*ListNewBlobsRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{0} }
+func (*ListNewBlobsRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{0} }
 
 func (m *ListNewBlobsRequest) GetRepository() *Repository {
 	if m != nil {
@@ -114,7 +114,7 @@ type ListNewBlobsResponse struct {
 func (m *ListNewBlobsResponse) Reset()                    { *m = ListNewBlobsResponse{} }
 func (m *ListNewBlobsResponse) String() string            { return proto.CompactTextString(m) }
 func (*ListNewBlobsResponse) ProtoMessage()               {}
-func (*ListNewBlobsResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{1} }
+func (*ListNewBlobsResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{1} }
 
 func (m *ListNewBlobsResponse) GetNewBlobObjects() []*NewBlobObject {
 	if m != nil {
@@ -130,7 +130,7 @@ type FindDefaultBranchNameRequest struct {
 func (m *FindDefaultBranchNameRequest) Reset()                    { *m = FindDefaultBranchNameRequest{} }
 func (m *FindDefaultBranchNameRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindDefaultBranchNameRequest) ProtoMessage()               {}
-func (*FindDefaultBranchNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{2} }
+func (*FindDefaultBranchNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{2} }
 
 func (m *FindDefaultBranchNameRequest) GetRepository() *Repository {
 	if m != nil {
@@ -146,7 +146,7 @@ type FindDefaultBranchNameResponse struct {
 func (m *FindDefaultBranchNameResponse) Reset()                    { *m = FindDefaultBranchNameResponse{} }
 func (m *FindDefaultBranchNameResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindDefaultBranchNameResponse) ProtoMessage()               {}
-func (*FindDefaultBranchNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{3} }
+func (*FindDefaultBranchNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{3} }
 
 func (m *FindDefaultBranchNameResponse) GetName() []byte {
 	if m != nil {
@@ -162,7 +162,7 @@ type FindAllBranchNamesRequest struct {
 func (m *FindAllBranchNamesRequest) Reset()                    { *m = FindAllBranchNamesRequest{} }
 func (m *FindAllBranchNamesRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindAllBranchNamesRequest) ProtoMessage()               {}
-func (*FindAllBranchNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{4} }
+func (*FindAllBranchNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{4} }
 
 func (m *FindAllBranchNamesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -178,7 +178,7 @@ type FindAllBranchNamesResponse struct {
 func (m *FindAllBranchNamesResponse) Reset()                    { *m = FindAllBranchNamesResponse{} }
 func (m *FindAllBranchNamesResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindAllBranchNamesResponse) ProtoMessage()               {}
-func (*FindAllBranchNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{5} }
+func (*FindAllBranchNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{5} }
 
 func (m *FindAllBranchNamesResponse) GetNames() [][]byte {
 	if m != nil {
@@ -194,7 +194,7 @@ type FindAllTagNamesRequest struct {
 func (m *FindAllTagNamesRequest) Reset()                    { *m = FindAllTagNamesRequest{} }
 func (m *FindAllTagNamesRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindAllTagNamesRequest) ProtoMessage()               {}
-func (*FindAllTagNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{6} }
+func (*FindAllTagNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{6} }
 
 func (m *FindAllTagNamesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -210,7 +210,7 @@ type FindAllTagNamesResponse struct {
 func (m *FindAllTagNamesResponse) Reset()                    { *m = FindAllTagNamesResponse{} }
 func (m *FindAllTagNamesResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindAllTagNamesResponse) ProtoMessage()               {}
-func (*FindAllTagNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{7} }
+func (*FindAllTagNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{7} }
 
 func (m *FindAllTagNamesResponse) GetNames() [][]byte {
 	if m != nil {
@@ -230,7 +230,7 @@ type FindRefNameRequest struct {
 func (m *FindRefNameRequest) Reset()                    { *m = FindRefNameRequest{} }
 func (m *FindRefNameRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindRefNameRequest) ProtoMessage()               {}
-func (*FindRefNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{8} }
+func (*FindRefNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{8} }
 
 func (m *FindRefNameRequest) GetRepository() *Repository {
 	if m != nil {
@@ -261,7 +261,7 @@ type FindRefNameResponse struct {
 func (m *FindRefNameResponse) Reset()                    { *m = FindRefNameResponse{} }
 func (m *FindRefNameResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindRefNameResponse) ProtoMessage()               {}
-func (*FindRefNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{9} }
+func (*FindRefNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{9} }
 
 func (m *FindRefNameResponse) GetName() []byte {
 	if m != nil {
@@ -278,7 +278,7 @@ type FindLocalBranchesRequest struct {
 func (m *FindLocalBranchesRequest) Reset()                    { *m = FindLocalBranchesRequest{} }
 func (m *FindLocalBranchesRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindLocalBranchesRequest) ProtoMessage()               {}
-func (*FindLocalBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{10} }
+func (*FindLocalBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{10} }
 
 func (m *FindLocalBranchesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -301,7 +301,7 @@ type FindLocalBranchesResponse struct {
 func (m *FindLocalBranchesResponse) Reset()                    { *m = FindLocalBranchesResponse{} }
 func (m *FindLocalBranchesResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindLocalBranchesResponse) ProtoMessage()               {}
-func (*FindLocalBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{11} }
+func (*FindLocalBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{11} }
 
 func (m *FindLocalBranchesResponse) GetBranches() []*FindLocalBranchResponse {
 	if m != nil {
@@ -321,7 +321,7 @@ type FindLocalBranchResponse struct {
 func (m *FindLocalBranchResponse) Reset()                    { *m = FindLocalBranchResponse{} }
 func (m *FindLocalBranchResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindLocalBranchResponse) ProtoMessage()               {}
-func (*FindLocalBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{12} }
+func (*FindLocalBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{12} }
 
 func (m *FindLocalBranchResponse) GetName() []byte {
 	if m != nil {
@@ -367,7 +367,7 @@ type FindLocalBranchCommitAuthor struct {
 func (m *FindLocalBranchCommitAuthor) Reset()                    { *m = FindLocalBranchCommitAuthor{} }
 func (m *FindLocalBranchCommitAuthor) String() string            { return proto.CompactTextString(m) }
 func (*FindLocalBranchCommitAuthor) ProtoMessage()               {}
-func (*FindLocalBranchCommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{13} }
+func (*FindLocalBranchCommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{13} }
 
 func (m *FindLocalBranchCommitAuthor) GetName() []byte {
 	if m != nil {
@@ -402,7 +402,7 @@ type FindAllBranchesRequest struct {
 func (m *FindAllBranchesRequest) Reset()                    { *m = FindAllBranchesRequest{} }
 func (m *FindAllBranchesRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindAllBranchesRequest) ProtoMessage()               {}
-func (*FindAllBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{14} }
+func (*FindAllBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{14} }
 
 func (m *FindAllBranchesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -432,7 +432,7 @@ type FindAllBranchesResponse struct {
 func (m *FindAllBranchesResponse) Reset()                    { *m = FindAllBranchesResponse{} }
 func (m *FindAllBranchesResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindAllBranchesResponse) ProtoMessage()               {}
-func (*FindAllBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{15} }
+func (*FindAllBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{15} }
 
 func (m *FindAllBranchesResponse) GetBranches() []*FindAllBranchesResponse_Branch {
 	if m != nil {
@@ -450,7 +450,7 @@ func (m *FindAllBranchesResponse_Branch) Reset()         { *m = FindAllBranchesR
 func (m *FindAllBranchesResponse_Branch) String() string { return proto.CompactTextString(m) }
 func (*FindAllBranchesResponse_Branch) ProtoMessage()    {}
 func (*FindAllBranchesResponse_Branch) Descriptor() ([]byte, []int) {
-	return fileDescriptor8, []int{15, 0}
+	return fileDescriptor7, []int{15, 0}
 }
 
 func (m *FindAllBranchesResponse_Branch) GetName() []byte {
@@ -474,7 +474,7 @@ type FindAllTagsRequest struct {
 func (m *FindAllTagsRequest) Reset()                    { *m = FindAllTagsRequest{} }
 func (m *FindAllTagsRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindAllTagsRequest) ProtoMessage()               {}
-func (*FindAllTagsRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{16} }
+func (*FindAllTagsRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{16} }
 
 func (m *FindAllTagsRequest) GetRepository() *Repository {
 	if m != nil {
@@ -490,7 +490,7 @@ type FindAllTagsResponse struct {
 func (m *FindAllTagsResponse) Reset()                    { *m = FindAllTagsResponse{} }
 func (m *FindAllTagsResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindAllTagsResponse) ProtoMessage()               {}
-func (*FindAllTagsResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{17} }
+func (*FindAllTagsResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{17} }
 
 func (m *FindAllTagsResponse) GetTags() []*Tag {
 	if m != nil {
@@ -508,7 +508,7 @@ type RefExistsRequest struct {
 func (m *RefExistsRequest) Reset()                    { *m = RefExistsRequest{} }
 func (m *RefExistsRequest) String() string            { return proto.CompactTextString(m) }
 func (*RefExistsRequest) ProtoMessage()               {}
-func (*RefExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{18} }
+func (*RefExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{18} }
 
 func (m *RefExistsRequest) GetRepository() *Repository {
 	if m != nil {
@@ -531,7 +531,7 @@ type RefExistsResponse struct {
 func (m *RefExistsResponse) Reset()                    { *m = RefExistsResponse{} }
 func (m *RefExistsResponse) String() string            { return proto.CompactTextString(m) }
 func (*RefExistsResponse) ProtoMessage()               {}
-func (*RefExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{19} }
+func (*RefExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{19} }
 
 func (m *RefExistsResponse) GetValue() bool {
 	if m != nil {
@@ -549,7 +549,7 @@ type CreateBranchRequest struct {
 func (m *CreateBranchRequest) Reset()                    { *m = CreateBranchRequest{} }
 func (m *CreateBranchRequest) String() string            { return proto.CompactTextString(m) }
 func (*CreateBranchRequest) ProtoMessage()               {}
-func (*CreateBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{20} }
+func (*CreateBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{20} }
 
 func (m *CreateBranchRequest) GetRepository() *Repository {
 	if m != nil {
@@ -580,7 +580,7 @@ type CreateBranchResponse struct {
 func (m *CreateBranchResponse) Reset()                    { *m = CreateBranchResponse{} }
 func (m *CreateBranchResponse) String() string            { return proto.CompactTextString(m) }
 func (*CreateBranchResponse) ProtoMessage()               {}
-func (*CreateBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{21} }
+func (*CreateBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{21} }
 
 func (m *CreateBranchResponse) GetStatus() CreateBranchResponse_Status {
 	if m != nil {
@@ -604,7 +604,7 @@ type DeleteBranchRequest struct {
 func (m *DeleteBranchRequest) Reset()                    { *m = DeleteBranchRequest{} }
 func (m *DeleteBranchRequest) String() string            { return proto.CompactTextString(m) }
 func (*DeleteBranchRequest) ProtoMessage()               {}
-func (*DeleteBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{22} }
+func (*DeleteBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{22} }
 
 func (m *DeleteBranchRequest) GetRepository() *Repository {
 	if m != nil {
@@ -627,7 +627,7 @@ type DeleteBranchResponse struct {
 func (m *DeleteBranchResponse) Reset()                    { *m = DeleteBranchResponse{} }
 func (m *DeleteBranchResponse) String() string            { return proto.CompactTextString(m) }
 func (*DeleteBranchResponse) ProtoMessage()               {}
-func (*DeleteBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{23} }
+func (*DeleteBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{23} }
 
 type FindBranchRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -638,7 +638,7 @@ type FindBranchRequest struct {
 func (m *FindBranchRequest) Reset()                    { *m = FindBranchRequest{} }
 func (m *FindBranchRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindBranchRequest) ProtoMessage()               {}
-func (*FindBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{24} }
+func (*FindBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{24} }
 
 func (m *FindBranchRequest) GetRepository() *Repository {
 	if m != nil {
@@ -661,7 +661,7 @@ type FindBranchResponse struct {
 func (m *FindBranchResponse) Reset()                    { *m = FindBranchResponse{} }
 func (m *FindBranchResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindBranchResponse) ProtoMessage()               {}
-func (*FindBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{25} }
+func (*FindBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{25} }
 
 func (m *FindBranchResponse) GetBranch() *Branch {
 	if m != nil {
@@ -680,7 +680,7 @@ type DeleteRefsRequest struct {
 func (m *DeleteRefsRequest) Reset()                    { *m = DeleteRefsRequest{} }
 func (m *DeleteRefsRequest) String() string            { return proto.CompactTextString(m) }
 func (*DeleteRefsRequest) ProtoMessage()               {}
-func (*DeleteRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{26} }
+func (*DeleteRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{26} }
 
 func (m *DeleteRefsRequest) GetRepository() *Repository {
 	if m != nil {
@@ -710,7 +710,7 @@ type DeleteRefsResponse struct {
 func (m *DeleteRefsResponse) Reset()                    { *m = DeleteRefsResponse{} }
 func (m *DeleteRefsResponse) String() string            { return proto.CompactTextString(m) }
 func (*DeleteRefsResponse) ProtoMessage()               {}
-func (*DeleteRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{27} }
+func (*DeleteRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{27} }
 
 func (m *DeleteRefsResponse) GetGitError() string {
 	if m != nil {
@@ -733,7 +733,7 @@ func (m *ListBranchNamesContainingCommitRequest) Reset() {
 func (m *ListBranchNamesContainingCommitRequest) String() string { return proto.CompactTextString(m) }
 func (*ListBranchNamesContainingCommitRequest) ProtoMessage()    {}
 func (*ListBranchNamesContainingCommitRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor8, []int{28}
+	return fileDescriptor7, []int{28}
 }
 
 func (m *ListBranchNamesContainingCommitRequest) GetRepository() *Repository {
@@ -767,7 +767,7 @@ func (m *ListBranchNamesContainingCommitResponse) Reset() {
 func (m *ListBranchNamesContainingCommitResponse) String() string { return proto.CompactTextString(m) }
 func (*ListBranchNamesContainingCommitResponse) ProtoMessage()    {}
 func (*ListBranchNamesContainingCommitResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor8, []int{29}
+	return fileDescriptor7, []int{29}
 }
 
 func (m *ListBranchNamesContainingCommitResponse) GetBranchNames() [][]byte {
@@ -789,7 +789,7 @@ func (m *ListTagNamesContainingCommitRequest) Reset()         { *m = ListTagName
 func (m *ListTagNamesContainingCommitRequest) String() string { return proto.CompactTextString(m) }
 func (*ListTagNamesContainingCommitRequest) ProtoMessage()    {}
 func (*ListTagNamesContainingCommitRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor8, []int{30}
+	return fileDescriptor7, []int{30}
 }
 
 func (m *ListTagNamesContainingCommitRequest) GetRepository() *Repository {
@@ -821,7 +821,7 @@ func (m *ListTagNamesContainingCommitResponse) Reset()         { *m = ListTagNam
 func (m *ListTagNamesContainingCommitResponse) String() string { return proto.CompactTextString(m) }
 func (*ListTagNamesContainingCommitResponse) ProtoMessage()    {}
 func (*ListTagNamesContainingCommitResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor8, []int{31}
+	return fileDescriptor7, []int{31}
 }
 
 func (m *ListTagNamesContainingCommitResponse) GetTagNames() [][]byte {
@@ -839,7 +839,7 @@ type GetTagMessagesRequest struct {
 func (m *GetTagMessagesRequest) Reset()                    { *m = GetTagMessagesRequest{} }
 func (m *GetTagMessagesRequest) String() string            { return proto.CompactTextString(m) }
 func (*GetTagMessagesRequest) ProtoMessage()               {}
-func (*GetTagMessagesRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{32} }
+func (*GetTagMessagesRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{32} }
 
 func (m *GetTagMessagesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -864,7 +864,7 @@ type GetTagMessagesResponse struct {
 func (m *GetTagMessagesResponse) Reset()                    { *m = GetTagMessagesResponse{} }
 func (m *GetTagMessagesResponse) String() string            { return proto.CompactTextString(m) }
 func (*GetTagMessagesResponse) ProtoMessage()               {}
-func (*GetTagMessagesResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{33} }
+func (*GetTagMessagesResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{33} }
 
 func (m *GetTagMessagesResponse) GetMessage() []byte {
 	if m != nil {
@@ -888,7 +888,7 @@ type ListNewCommitsRequest struct {
 func (m *ListNewCommitsRequest) Reset()                    { *m = ListNewCommitsRequest{} }
 func (m *ListNewCommitsRequest) String() string            { return proto.CompactTextString(m) }
 func (*ListNewCommitsRequest) ProtoMessage()               {}
-func (*ListNewCommitsRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{34} }
+func (*ListNewCommitsRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{34} }
 
 func (m *ListNewCommitsRequest) GetRepository() *Repository {
 	if m != nil {
@@ -911,7 +911,7 @@ type ListNewCommitsResponse struct {
 func (m *ListNewCommitsResponse) Reset()                    { *m = ListNewCommitsResponse{} }
 func (m *ListNewCommitsResponse) String() string            { return proto.CompactTextString(m) }
 func (*ListNewCommitsResponse) ProtoMessage()               {}
-func (*ListNewCommitsResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{35} }
+func (*ListNewCommitsResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{35} }
 
 func (m *ListNewCommitsResponse) GetCommits() []*GitCommit {
 	if m != nil {
@@ -928,7 +928,7 @@ type FindAllRemoteBranchesRequest struct {
 func (m *FindAllRemoteBranchesRequest) Reset()                    { *m = FindAllRemoteBranchesRequest{} }
 func (m *FindAllRemoteBranchesRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindAllRemoteBranchesRequest) ProtoMessage()               {}
-func (*FindAllRemoteBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{36} }
+func (*FindAllRemoteBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{36} }
 
 func (m *FindAllRemoteBranchesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -951,7 +951,7 @@ type FindAllRemoteBranchesResponse struct {
 func (m *FindAllRemoteBranchesResponse) Reset()                    { *m = FindAllRemoteBranchesResponse{} }
 func (m *FindAllRemoteBranchesResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindAllRemoteBranchesResponse) ProtoMessage()               {}
-func (*FindAllRemoteBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{37} }
+func (*FindAllRemoteBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{37} }
 
 func (m *FindAllRemoteBranchesResponse) GetBranches() []*Branch {
 	if m != nil {
@@ -1941,9 +1941,9 @@ var _RefService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "ref.proto",
 }
 
-func init() { proto.RegisterFile("ref.proto", fileDescriptor8) }
+func init() { proto.RegisterFile("ref.proto", fileDescriptor7) }
 
-var fileDescriptor8 = []byte{
+var fileDescriptor7 = []byte{
 	// 1539 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0x5b, 0x6f, 0xdb, 0xc6,
 	0x12, 0x36, 0x65, 0x5b, 0x96, 0x46, 0x8a, 0x4c, 0xaf, 0x2f, 0x51, 0xe8, 0x24, 0x76, 0x36, 0x37,
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/remote.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/remote.pb.go
index 79183690a..9fc7440ca 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/remote.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/remote.pb.go
@@ -28,7 +28,7 @@ type AddRemoteRequest struct {
 func (m *AddRemoteRequest) Reset()                    { *m = AddRemoteRequest{} }
 func (m *AddRemoteRequest) String() string            { return proto.CompactTextString(m) }
 func (*AddRemoteRequest) ProtoMessage()               {}
-func (*AddRemoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{0} }
+func (*AddRemoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{0} }
 
 func (m *AddRemoteRequest) GetRepository() *Repository {
 	if m != nil {
@@ -64,7 +64,7 @@ type AddRemoteResponse struct {
 func (m *AddRemoteResponse) Reset()                    { *m = AddRemoteResponse{} }
 func (m *AddRemoteResponse) String() string            { return proto.CompactTextString(m) }
 func (*AddRemoteResponse) ProtoMessage()               {}
-func (*AddRemoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{1} }
+func (*AddRemoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{1} }
 
 type RemoveRemoteRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -74,7 +74,7 @@ type RemoveRemoteRequest struct {
 func (m *RemoveRemoteRequest) Reset()                    { *m = RemoveRemoteRequest{} }
 func (m *RemoveRemoteRequest) String() string            { return proto.CompactTextString(m) }
 func (*RemoveRemoteRequest) ProtoMessage()               {}
-func (*RemoveRemoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{2} }
+func (*RemoveRemoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{2} }
 
 func (m *RemoveRemoteRequest) GetRepository() *Repository {
 	if m != nil {
@@ -97,7 +97,7 @@ type RemoveRemoteResponse struct {
 func (m *RemoveRemoteResponse) Reset()                    { *m = RemoveRemoteResponse{} }
 func (m *RemoveRemoteResponse) String() string            { return proto.CompactTextString(m) }
 func (*RemoveRemoteResponse) ProtoMessage()               {}
-func (*RemoveRemoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{3} }
+func (*RemoveRemoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{3} }
 
 func (m *RemoveRemoteResponse) GetResult() bool {
 	if m != nil {
@@ -114,7 +114,7 @@ type FetchInternalRemoteRequest struct {
 func (m *FetchInternalRemoteRequest) Reset()                    { *m = FetchInternalRemoteRequest{} }
 func (m *FetchInternalRemoteRequest) String() string            { return proto.CompactTextString(m) }
 func (*FetchInternalRemoteRequest) ProtoMessage()               {}
-func (*FetchInternalRemoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{4} }
+func (*FetchInternalRemoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{4} }
 
 func (m *FetchInternalRemoteRequest) GetRepository() *Repository {
 	if m != nil {
@@ -137,7 +137,7 @@ type FetchInternalRemoteResponse struct {
 func (m *FetchInternalRemoteResponse) Reset()                    { *m = FetchInternalRemoteResponse{} }
 func (m *FetchInternalRemoteResponse) String() string            { return proto.CompactTextString(m) }
 func (*FetchInternalRemoteResponse) ProtoMessage()               {}
-func (*FetchInternalRemoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{5} }
+func (*FetchInternalRemoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{5} }
 
 func (m *FetchInternalRemoteResponse) GetResult() bool {
 	if m != nil {
@@ -155,7 +155,7 @@ type UpdateRemoteMirrorRequest struct {
 func (m *UpdateRemoteMirrorRequest) Reset()                    { *m = UpdateRemoteMirrorRequest{} }
 func (m *UpdateRemoteMirrorRequest) String() string            { return proto.CompactTextString(m) }
 func (*UpdateRemoteMirrorRequest) ProtoMessage()               {}
-func (*UpdateRemoteMirrorRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{6} }
+func (*UpdateRemoteMirrorRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{6} }
 
 func (m *UpdateRemoteMirrorRequest) GetRepository() *Repository {
 	if m != nil {
@@ -184,7 +184,7 @@ type UpdateRemoteMirrorResponse struct {
 func (m *UpdateRemoteMirrorResponse) Reset()                    { *m = UpdateRemoteMirrorResponse{} }
 func (m *UpdateRemoteMirrorResponse) String() string            { return proto.CompactTextString(m) }
 func (*UpdateRemoteMirrorResponse) ProtoMessage()               {}
-func (*UpdateRemoteMirrorResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{7} }
+func (*UpdateRemoteMirrorResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{7} }
 
 type FindRemoteRepositoryRequest struct {
 	Remote string `protobuf:"bytes,1,opt,name=remote" json:"remote,omitempty"`
@@ -193,7 +193,7 @@ type FindRemoteRepositoryRequest struct {
 func (m *FindRemoteRepositoryRequest) Reset()                    { *m = FindRemoteRepositoryRequest{} }
 func (m *FindRemoteRepositoryRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindRemoteRepositoryRequest) ProtoMessage()               {}
-func (*FindRemoteRepositoryRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{8} }
+func (*FindRemoteRepositoryRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{8} }
 
 func (m *FindRemoteRepositoryRequest) GetRemote() string {
 	if m != nil {
@@ -211,7 +211,7 @@ type FindRemoteRepositoryResponse struct {
 func (m *FindRemoteRepositoryResponse) Reset()                    { *m = FindRemoteRepositoryResponse{} }
 func (m *FindRemoteRepositoryResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindRemoteRepositoryResponse) ProtoMessage()               {}
-func (*FindRemoteRepositoryResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{9} }
+func (*FindRemoteRepositoryResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{9} }
 
 func (m *FindRemoteRepositoryResponse) GetExists() bool {
 	if m != nil {
@@ -228,7 +228,7 @@ type FindRemoteRootRefRequest struct {
 func (m *FindRemoteRootRefRequest) Reset()                    { *m = FindRemoteRootRefRequest{} }
 func (m *FindRemoteRootRefRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindRemoteRootRefRequest) ProtoMessage()               {}
-func (*FindRemoteRootRefRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{10} }
+func (*FindRemoteRootRefRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{10} }
 
 func (m *FindRemoteRootRefRequest) GetRepository() *Repository {
 	if m != nil {
@@ -251,7 +251,7 @@ type FindRemoteRootRefResponse struct {
 func (m *FindRemoteRootRefResponse) Reset()                    { *m = FindRemoteRootRefResponse{} }
 func (m *FindRemoteRootRefResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindRemoteRootRefResponse) ProtoMessage()               {}
-func (*FindRemoteRootRefResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{11} }
+func (*FindRemoteRootRefResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{11} }
 
 func (m *FindRemoteRootRefResponse) GetRef() string {
 	if m != nil {
@@ -547,9 +547,9 @@ var _RemoteService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "remote.proto",
 }
 
-func init() { proto.RegisterFile("remote.proto", fileDescriptor9) }
+func init() { proto.RegisterFile("remote.proto", fileDescriptor8) }
 
-var fileDescriptor9 = []byte{
+var fileDescriptor8 = []byte{
 	// 536 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0x4f, 0x8f, 0xd3, 0x3e,
 	0x10, 0xfd, 0xa5, 0xe9, 0xf6, 0xd7, 0x0e, 0x5d, 0xd4, 0xba, 0xd5, 0x2a, 0xcd, 0xf6, 0xd0, 0x35,
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/repository-service.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/repository-service.pb.go
index 1898547be..ca59fd580 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/repository-service.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/repository-service.pb.go
@@ -42,9 +42,7 @@ var GetArchiveRequest_Format_value = map[string]int32{
 func (x GetArchiveRequest_Format) String() string {
 	return proto.EnumName(GetArchiveRequest_Format_name, int32(x))
 }
-func (GetArchiveRequest_Format) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor10, []int{18, 0}
-}
+func (GetArchiveRequest_Format) EnumDescriptor() ([]byte, []int) { return fileDescriptor9, []int{18, 0} }
 
 type GetRawChangesResponse_RawChange_Operation int32
 
@@ -81,7 +79,7 @@ func (x GetRawChangesResponse_RawChange_Operation) String() string {
 	return proto.EnumName(GetRawChangesResponse_RawChange_Operation_name, int32(x))
 }
 func (GetRawChangesResponse_RawChange_Operation) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor10, []int{63, 0, 0}
+	return fileDescriptor9, []int{63, 0, 0}
 }
 
 type RepositoryExistsRequest struct {
@@ -91,7 +89,7 @@ type RepositoryExistsRequest struct {
 func (m *RepositoryExistsRequest) Reset()                    { *m = RepositoryExistsRequest{} }
 func (m *RepositoryExistsRequest) String() string            { return proto.CompactTextString(m) }
 func (*RepositoryExistsRequest) ProtoMessage()               {}
-func (*RepositoryExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{0} }
+func (*RepositoryExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{0} }
 
 func (m *RepositoryExistsRequest) GetRepository() *Repository {
 	if m != nil {
@@ -107,7 +105,7 @@ type RepositoryExistsResponse struct {
 func (m *RepositoryExistsResponse) Reset()                    { *m = RepositoryExistsResponse{} }
 func (m *RepositoryExistsResponse) String() string            { return proto.CompactTextString(m) }
 func (*RepositoryExistsResponse) ProtoMessage()               {}
-func (*RepositoryExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{1} }
+func (*RepositoryExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{1} }
 
 func (m *RepositoryExistsResponse) GetExists() bool {
 	if m != nil {
@@ -123,7 +121,7 @@ type RepackIncrementalRequest struct {
 func (m *RepackIncrementalRequest) Reset()                    { *m = RepackIncrementalRequest{} }
 func (m *RepackIncrementalRequest) String() string            { return proto.CompactTextString(m) }
 func (*RepackIncrementalRequest) ProtoMessage()               {}
-func (*RepackIncrementalRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{2} }
+func (*RepackIncrementalRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{2} }
 
 func (m *RepackIncrementalRequest) GetRepository() *Repository {
 	if m != nil {
@@ -138,7 +136,7 @@ type RepackIncrementalResponse struct {
 func (m *RepackIncrementalResponse) Reset()                    { *m = RepackIncrementalResponse{} }
 func (m *RepackIncrementalResponse) String() string            { return proto.CompactTextString(m) }
 func (*RepackIncrementalResponse) ProtoMessage()               {}
-func (*RepackIncrementalResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{3} }
+func (*RepackIncrementalResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{3} }
 
 type RepackFullRequest struct {
 	Repository   *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -148,7 +146,7 @@ type RepackFullRequest struct {
 func (m *RepackFullRequest) Reset()                    { *m = RepackFullRequest{} }
 func (m *RepackFullRequest) String() string            { return proto.CompactTextString(m) }
 func (*RepackFullRequest) ProtoMessage()               {}
-func (*RepackFullRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{4} }
+func (*RepackFullRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{4} }
 
 func (m *RepackFullRequest) GetRepository() *Repository {
 	if m != nil {
@@ -170,7 +168,7 @@ type RepackFullResponse struct {
 func (m *RepackFullResponse) Reset()                    { *m = RepackFullResponse{} }
 func (m *RepackFullResponse) String() string            { return proto.CompactTextString(m) }
 func (*RepackFullResponse) ProtoMessage()               {}
-func (*RepackFullResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{5} }
+func (*RepackFullResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{5} }
 
 type GarbageCollectRequest struct {
 	Repository   *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -180,7 +178,7 @@ type GarbageCollectRequest struct {
 func (m *GarbageCollectRequest) Reset()                    { *m = GarbageCollectRequest{} }
 func (m *GarbageCollectRequest) String() string            { return proto.CompactTextString(m) }
 func (*GarbageCollectRequest) ProtoMessage()               {}
-func (*GarbageCollectRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{6} }
+func (*GarbageCollectRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{6} }
 
 func (m *GarbageCollectRequest) GetRepository() *Repository {
 	if m != nil {
@@ -202,7 +200,7 @@ type GarbageCollectResponse struct {
 func (m *GarbageCollectResponse) Reset()                    { *m = GarbageCollectResponse{} }
 func (m *GarbageCollectResponse) String() string            { return proto.CompactTextString(m) }
 func (*GarbageCollectResponse) ProtoMessage()               {}
-func (*GarbageCollectResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{7} }
+func (*GarbageCollectResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{7} }
 
 type CleanupRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -211,7 +209,7 @@ type CleanupRequest struct {
 func (m *CleanupRequest) Reset()                    { *m = CleanupRequest{} }
 func (m *CleanupRequest) String() string            { return proto.CompactTextString(m) }
 func (*CleanupRequest) ProtoMessage()               {}
-func (*CleanupRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{8} }
+func (*CleanupRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{8} }
 
 func (m *CleanupRequest) GetRepository() *Repository {
 	if m != nil {
@@ -226,7 +224,7 @@ type CleanupResponse struct {
 func (m *CleanupResponse) Reset()                    { *m = CleanupResponse{} }
 func (m *CleanupResponse) String() string            { return proto.CompactTextString(m) }
 func (*CleanupResponse) ProtoMessage()               {}
-func (*CleanupResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{9} }
+func (*CleanupResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{9} }
 
 type RepositorySizeRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -235,7 +233,7 @@ type RepositorySizeRequest struct {
 func (m *RepositorySizeRequest) Reset()                    { *m = RepositorySizeRequest{} }
 func (m *RepositorySizeRequest) String() string            { return proto.CompactTextString(m) }
 func (*RepositorySizeRequest) ProtoMessage()               {}
-func (*RepositorySizeRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{10} }
+func (*RepositorySizeRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{10} }
 
 func (m *RepositorySizeRequest) GetRepository() *Repository {
 	if m != nil {
@@ -252,7 +250,7 @@ type RepositorySizeResponse struct {
 func (m *RepositorySizeResponse) Reset()                    { *m = RepositorySizeResponse{} }
 func (m *RepositorySizeResponse) String() string            { return proto.CompactTextString(m) }
 func (*RepositorySizeResponse) ProtoMessage()               {}
-func (*RepositorySizeResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{11} }
+func (*RepositorySizeResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{11} }
 
 func (m *RepositorySizeResponse) GetSize() int64 {
 	if m != nil {
@@ -269,7 +267,7 @@ type ApplyGitattributesRequest struct {
 func (m *ApplyGitattributesRequest) Reset()                    { *m = ApplyGitattributesRequest{} }
 func (m *ApplyGitattributesRequest) String() string            { return proto.CompactTextString(m) }
 func (*ApplyGitattributesRequest) ProtoMessage()               {}
-func (*ApplyGitattributesRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{12} }
+func (*ApplyGitattributesRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{12} }
 
 func (m *ApplyGitattributesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -291,7 +289,7 @@ type ApplyGitattributesResponse struct {
 func (m *ApplyGitattributesResponse) Reset()                    { *m = ApplyGitattributesResponse{} }
 func (m *ApplyGitattributesResponse) String() string            { return proto.CompactTextString(m) }
 func (*ApplyGitattributesResponse) ProtoMessage()               {}
-func (*ApplyGitattributesResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{13} }
+func (*ApplyGitattributesResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{13} }
 
 type FetchRemoteRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -307,7 +305,7 @@ type FetchRemoteRequest struct {
 func (m *FetchRemoteRequest) Reset()                    { *m = FetchRemoteRequest{} }
 func (m *FetchRemoteRequest) String() string            { return proto.CompactTextString(m) }
 func (*FetchRemoteRequest) ProtoMessage()               {}
-func (*FetchRemoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{14} }
+func (*FetchRemoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{14} }
 
 func (m *FetchRemoteRequest) GetRepository() *Repository {
 	if m != nil {
@@ -371,7 +369,7 @@ type FetchRemoteResponse struct {
 func (m *FetchRemoteResponse) Reset()                    { *m = FetchRemoteResponse{} }
 func (m *FetchRemoteResponse) String() string            { return proto.CompactTextString(m) }
 func (*FetchRemoteResponse) ProtoMessage()               {}
-func (*FetchRemoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{15} }
+func (*FetchRemoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{15} }
 
 type CreateRepositoryRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -380,7 +378,7 @@ type CreateRepositoryRequest struct {
 func (m *CreateRepositoryRequest) Reset()                    { *m = CreateRepositoryRequest{} }
 func (m *CreateRepositoryRequest) String() string            { return proto.CompactTextString(m) }
 func (*CreateRepositoryRequest) ProtoMessage()               {}
-func (*CreateRepositoryRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{16} }
+func (*CreateRepositoryRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{16} }
 
 func (m *CreateRepositoryRequest) GetRepository() *Repository {
 	if m != nil {
@@ -395,7 +393,7 @@ type CreateRepositoryResponse struct {
 func (m *CreateRepositoryResponse) Reset()                    { *m = CreateRepositoryResponse{} }
 func (m *CreateRepositoryResponse) String() string            { return proto.CompactTextString(m) }
 func (*CreateRepositoryResponse) ProtoMessage()               {}
-func (*CreateRepositoryResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{17} }
+func (*CreateRepositoryResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{17} }
 
 type GetArchiveRequest struct {
 	Repository *Repository              `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -407,7 +405,7 @@ type GetArchiveRequest struct {
 func (m *GetArchiveRequest) Reset()                    { *m = GetArchiveRequest{} }
 func (m *GetArchiveRequest) String() string            { return proto.CompactTextString(m) }
 func (*GetArchiveRequest) ProtoMessage()               {}
-func (*GetArchiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{18} }
+func (*GetArchiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{18} }
 
 func (m *GetArchiveRequest) GetRepository() *Repository {
 	if m != nil {
@@ -444,7 +442,7 @@ type GetArchiveResponse struct {
 func (m *GetArchiveResponse) Reset()                    { *m = GetArchiveResponse{} }
 func (m *GetArchiveResponse) String() string            { return proto.CompactTextString(m) }
 func (*GetArchiveResponse) ProtoMessage()               {}
-func (*GetArchiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{19} }
+func (*GetArchiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{19} }
 
 func (m *GetArchiveResponse) GetData() []byte {
 	if m != nil {
@@ -460,7 +458,7 @@ type HasLocalBranchesRequest struct {
 func (m *HasLocalBranchesRequest) Reset()                    { *m = HasLocalBranchesRequest{} }
 func (m *HasLocalBranchesRequest) String() string            { return proto.CompactTextString(m) }
 func (*HasLocalBranchesRequest) ProtoMessage()               {}
-func (*HasLocalBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{20} }
+func (*HasLocalBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{20} }
 
 func (m *HasLocalBranchesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -476,7 +474,7 @@ type HasLocalBranchesResponse struct {
 func (m *HasLocalBranchesResponse) Reset()                    { *m = HasLocalBranchesResponse{} }
 func (m *HasLocalBranchesResponse) String() string            { return proto.CompactTextString(m) }
 func (*HasLocalBranchesResponse) ProtoMessage()               {}
-func (*HasLocalBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{21} }
+func (*HasLocalBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{21} }
 
 func (m *HasLocalBranchesResponse) GetValue() bool {
 	if m != nil {
@@ -495,7 +493,7 @@ type FetchSourceBranchRequest struct {
 func (m *FetchSourceBranchRequest) Reset()                    { *m = FetchSourceBranchRequest{} }
 func (m *FetchSourceBranchRequest) String() string            { return proto.CompactTextString(m) }
 func (*FetchSourceBranchRequest) ProtoMessage()               {}
-func (*FetchSourceBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{22} }
+func (*FetchSourceBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{22} }
 
 func (m *FetchSourceBranchRequest) GetRepository() *Repository {
 	if m != nil {
@@ -532,7 +530,7 @@ type FetchSourceBranchResponse struct {
 func (m *FetchSourceBranchResponse) Reset()                    { *m = FetchSourceBranchResponse{} }
 func (m *FetchSourceBranchResponse) String() string            { return proto.CompactTextString(m) }
 func (*FetchSourceBranchResponse) ProtoMessage()               {}
-func (*FetchSourceBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{23} }
+func (*FetchSourceBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{23} }
 
 func (m *FetchSourceBranchResponse) GetResult() bool {
 	if m != nil {
@@ -548,7 +546,7 @@ type FsckRequest struct {
 func (m *FsckRequest) Reset()                    { *m = FsckRequest{} }
 func (m *FsckRequest) String() string            { return proto.CompactTextString(m) }
 func (*FsckRequest) ProtoMessage()               {}
-func (*FsckRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{24} }
+func (*FsckRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{24} }
 
 func (m *FsckRequest) GetRepository() *Repository {
 	if m != nil {
@@ -564,7 +562,7 @@ type FsckResponse struct {
 func (m *FsckResponse) Reset()                    { *m = FsckResponse{} }
 func (m *FsckResponse) String() string            { return proto.CompactTextString(m) }
 func (*FsckResponse) ProtoMessage()               {}
-func (*FsckResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{25} }
+func (*FsckResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{25} }
 
 func (m *FsckResponse) GetError() []byte {
 	if m != nil {
@@ -585,7 +583,7 @@ type WriteRefRequest struct {
 func (m *WriteRefRequest) Reset()                    { *m = WriteRefRequest{} }
 func (m *WriteRefRequest) String() string            { return proto.CompactTextString(m) }
 func (*WriteRefRequest) ProtoMessage()               {}
-func (*WriteRefRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{26} }
+func (*WriteRefRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{26} }
 
 func (m *WriteRefRequest) GetRepository() *Repository {
 	if m != nil {
@@ -636,7 +634,7 @@ type WriteRefResponse struct {
 func (m *WriteRefResponse) Reset()                    { *m = WriteRefResponse{} }
 func (m *WriteRefResponse) String() string            { return proto.CompactTextString(m) }
 func (*WriteRefResponse) ProtoMessage()               {}
-func (*WriteRefResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{27} }
+func (*WriteRefResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{27} }
 
 func (m *WriteRefResponse) GetError() []byte {
 	if m != nil {
@@ -656,7 +654,7 @@ type FindMergeBaseRequest struct {
 func (m *FindMergeBaseRequest) Reset()                    { *m = FindMergeBaseRequest{} }
 func (m *FindMergeBaseRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindMergeBaseRequest) ProtoMessage()               {}
-func (*FindMergeBaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{28} }
+func (*FindMergeBaseRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{28} }
 
 func (m *FindMergeBaseRequest) GetRepository() *Repository {
 	if m != nil {
@@ -679,7 +677,7 @@ type FindMergeBaseResponse struct {
 func (m *FindMergeBaseResponse) Reset()                    { *m = FindMergeBaseResponse{} }
 func (m *FindMergeBaseResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindMergeBaseResponse) ProtoMessage()               {}
-func (*FindMergeBaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{29} }
+func (*FindMergeBaseResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{29} }
 
 func (m *FindMergeBaseResponse) GetBase() string {
 	if m != nil {
@@ -696,7 +694,7 @@ type CreateForkRequest struct {
 func (m *CreateForkRequest) Reset()                    { *m = CreateForkRequest{} }
 func (m *CreateForkRequest) String() string            { return proto.CompactTextString(m) }
 func (*CreateForkRequest) ProtoMessage()               {}
-func (*CreateForkRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{30} }
+func (*CreateForkRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{30} }
 
 func (m *CreateForkRequest) GetRepository() *Repository {
 	if m != nil {
@@ -718,7 +716,7 @@ type CreateForkResponse struct {
 func (m *CreateForkResponse) Reset()                    { *m = CreateForkResponse{} }
 func (m *CreateForkResponse) String() string            { return proto.CompactTextString(m) }
 func (*CreateForkResponse) ProtoMessage()               {}
-func (*CreateForkResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{31} }
+func (*CreateForkResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{31} }
 
 type IsRebaseInProgressRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -728,7 +726,7 @@ type IsRebaseInProgressRequest struct {
 func (m *IsRebaseInProgressRequest) Reset()                    { *m = IsRebaseInProgressRequest{} }
 func (m *IsRebaseInProgressRequest) String() string            { return proto.CompactTextString(m) }
 func (*IsRebaseInProgressRequest) ProtoMessage()               {}
-func (*IsRebaseInProgressRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{32} }
+func (*IsRebaseInProgressRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{32} }
 
 func (m *IsRebaseInProgressRequest) GetRepository() *Repository {
 	if m != nil {
@@ -751,7 +749,7 @@ type IsRebaseInProgressResponse struct {
 func (m *IsRebaseInProgressResponse) Reset()                    { *m = IsRebaseInProgressResponse{} }
 func (m *IsRebaseInProgressResponse) String() string            { return proto.CompactTextString(m) }
 func (*IsRebaseInProgressResponse) ProtoMessage()               {}
-func (*IsRebaseInProgressResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{33} }
+func (*IsRebaseInProgressResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{33} }
 
 func (m *IsRebaseInProgressResponse) GetInProgress() bool {
 	if m != nil {
@@ -768,7 +766,7 @@ type IsSquashInProgressRequest struct {
 func (m *IsSquashInProgressRequest) Reset()                    { *m = IsSquashInProgressRequest{} }
 func (m *IsSquashInProgressRequest) String() string            { return proto.CompactTextString(m) }
 func (*IsSquashInProgressRequest) ProtoMessage()               {}
-func (*IsSquashInProgressRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{34} }
+func (*IsSquashInProgressRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{34} }
 
 func (m *IsSquashInProgressRequest) GetRepository() *Repository {
 	if m != nil {
@@ -791,7 +789,7 @@ type IsSquashInProgressResponse struct {
 func (m *IsSquashInProgressResponse) Reset()                    { *m = IsSquashInProgressResponse{} }
 func (m *IsSquashInProgressResponse) String() string            { return proto.CompactTextString(m) }
 func (*IsSquashInProgressResponse) ProtoMessage()               {}
-func (*IsSquashInProgressResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{35} }
+func (*IsSquashInProgressResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{35} }
 
 func (m *IsSquashInProgressResponse) GetInProgress() bool {
 	if m != nil {
@@ -805,12 +803,10 @@ type CreateRepositoryFromURLRequest struct {
 	Url        string      `protobuf:"bytes,2,opt,name=url" json:"url,omitempty"`
 }
 
-func (m *CreateRepositoryFromURLRequest) Reset()         { *m = CreateRepositoryFromURLRequest{} }
-func (m *CreateRepositoryFromURLRequest) String() string { return proto.CompactTextString(m) }
-func (*CreateRepositoryFromURLRequest) ProtoMessage()    {}
-func (*CreateRepositoryFromURLRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor10, []int{36}
-}
+func (m *CreateRepositoryFromURLRequest) Reset()                    { *m = CreateRepositoryFromURLRequest{} }
+func (m *CreateRepositoryFromURLRequest) String() string            { return proto.CompactTextString(m) }
+func (*CreateRepositoryFromURLRequest) ProtoMessage()               {}
+func (*CreateRepositoryFromURLRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{36} }
 
 func (m *CreateRepositoryFromURLRequest) GetRepository() *Repository {
 	if m != nil {
@@ -833,7 +829,7 @@ func (m *CreateRepositoryFromURLResponse) Reset()         { *m = CreateRepositor
 func (m *CreateRepositoryFromURLResponse) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryFromURLResponse) ProtoMessage()    {}
 func (*CreateRepositoryFromURLResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor10, []int{37}
+	return fileDescriptor9, []int{37}
 }
 
 type CreateBundleRequest struct {
@@ -843,7 +839,7 @@ type CreateBundleRequest struct {
 func (m *CreateBundleRequest) Reset()                    { *m = CreateBundleRequest{} }
 func (m *CreateBundleRequest) String() string            { return proto.CompactTextString(m) }
 func (*CreateBundleRequest) ProtoMessage()               {}
-func (*CreateBundleRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{38} }
+func (*CreateBundleRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{38} }
 
 func (m *CreateBundleRequest) GetRepository() *Repository {
 	if m != nil {
@@ -859,7 +855,7 @@ type CreateBundleResponse struct {
 func (m *CreateBundleResponse) Reset()                    { *m = CreateBundleResponse{} }
 func (m *CreateBundleResponse) String() string            { return proto.CompactTextString(m) }
 func (*CreateBundleResponse) ProtoMessage()               {}
-func (*CreateBundleResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{39} }
+func (*CreateBundleResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{39} }
 
 func (m *CreateBundleResponse) GetData() []byte {
 	if m != nil {
@@ -876,7 +872,7 @@ type WriteConfigRequest struct {
 func (m *WriteConfigRequest) Reset()                    { *m = WriteConfigRequest{} }
 func (m *WriteConfigRequest) String() string            { return proto.CompactTextString(m) }
 func (*WriteConfigRequest) ProtoMessage()               {}
-func (*WriteConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{40} }
+func (*WriteConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{40} }
 
 func (m *WriteConfigRequest) GetRepository() *Repository {
 	if m != nil {
@@ -899,7 +895,7 @@ type WriteConfigResponse struct {
 func (m *WriteConfigResponse) Reset()                    { *m = WriteConfigResponse{} }
 func (m *WriteConfigResponse) String() string            { return proto.CompactTextString(m) }
 func (*WriteConfigResponse) ProtoMessage()               {}
-func (*WriteConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{41} }
+func (*WriteConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{41} }
 
 func (m *WriteConfigResponse) GetError() []byte {
 	if m != nil {
@@ -916,7 +912,7 @@ type SetConfigRequest struct {
 func (m *SetConfigRequest) Reset()                    { *m = SetConfigRequest{} }
 func (m *SetConfigRequest) String() string            { return proto.CompactTextString(m) }
 func (*SetConfigRequest) ProtoMessage()               {}
-func (*SetConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{42} }
+func (*SetConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{42} }
 
 func (m *SetConfigRequest) GetRepository() *Repository {
 	if m != nil {
@@ -944,7 +940,7 @@ type SetConfigRequest_Entry struct {
 func (m *SetConfigRequest_Entry) Reset()                    { *m = SetConfigRequest_Entry{} }
 func (m *SetConfigRequest_Entry) String() string            { return proto.CompactTextString(m) }
 func (*SetConfigRequest_Entry) ProtoMessage()               {}
-func (*SetConfigRequest_Entry) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{42, 0} }
+func (*SetConfigRequest_Entry) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{42, 0} }
 
 type isSetConfigRequest_Entry_Value interface{ isSetConfigRequest_Entry_Value() }
 
@@ -1086,7 +1082,7 @@ type SetConfigResponse struct {
 func (m *SetConfigResponse) Reset()                    { *m = SetConfigResponse{} }
 func (m *SetConfigResponse) String() string            { return proto.CompactTextString(m) }
 func (*SetConfigResponse) ProtoMessage()               {}
-func (*SetConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{43} }
+func (*SetConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{43} }
 
 type DeleteConfigRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -1096,7 +1092,7 @@ type DeleteConfigRequest struct {
 func (m *DeleteConfigRequest) Reset()                    { *m = DeleteConfigRequest{} }
 func (m *DeleteConfigRequest) String() string            { return proto.CompactTextString(m) }
 func (*DeleteConfigRequest) ProtoMessage()               {}
-func (*DeleteConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{44} }
+func (*DeleteConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{44} }
 
 func (m *DeleteConfigRequest) GetRepository() *Repository {
 	if m != nil {
@@ -1118,7 +1114,7 @@ type DeleteConfigResponse struct {
 func (m *DeleteConfigResponse) Reset()                    { *m = DeleteConfigResponse{} }
 func (m *DeleteConfigResponse) String() string            { return proto.CompactTextString(m) }
 func (*DeleteConfigResponse) ProtoMessage()               {}
-func (*DeleteConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{45} }
+func (*DeleteConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{45} }
 
 type RestoreCustomHooksRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -1128,7 +1124,7 @@ type RestoreCustomHooksRequest struct {
 func (m *RestoreCustomHooksRequest) Reset()                    { *m = RestoreCustomHooksRequest{} }
 func (m *RestoreCustomHooksRequest) String() string            { return proto.CompactTextString(m) }
 func (*RestoreCustomHooksRequest) ProtoMessage()               {}
-func (*RestoreCustomHooksRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{46} }
+func (*RestoreCustomHooksRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{46} }
 
 func (m *RestoreCustomHooksRequest) GetRepository() *Repository {
 	if m != nil {
@@ -1150,7 +1146,7 @@ type RestoreCustomHooksResponse struct {
 func (m *RestoreCustomHooksResponse) Reset()                    { *m = RestoreCustomHooksResponse{} }
 func (m *RestoreCustomHooksResponse) String() string            { return proto.CompactTextString(m) }
 func (*RestoreCustomHooksResponse) ProtoMessage()               {}
-func (*RestoreCustomHooksResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{47} }
+func (*RestoreCustomHooksResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{47} }
 
 type BackupCustomHooksRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -1159,7 +1155,7 @@ type BackupCustomHooksRequest struct {
 func (m *BackupCustomHooksRequest) Reset()                    { *m = BackupCustomHooksRequest{} }
 func (m *BackupCustomHooksRequest) String() string            { return proto.CompactTextString(m) }
 func (*BackupCustomHooksRequest) ProtoMessage()               {}
-func (*BackupCustomHooksRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{48} }
+func (*BackupCustomHooksRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{48} }
 
 func (m *BackupCustomHooksRequest) GetRepository() *Repository {
 	if m != nil {
@@ -1175,7 +1171,7 @@ type BackupCustomHooksResponse struct {
 func (m *BackupCustomHooksResponse) Reset()                    { *m = BackupCustomHooksResponse{} }
 func (m *BackupCustomHooksResponse) String() string            { return proto.CompactTextString(m) }
 func (*BackupCustomHooksResponse) ProtoMessage()               {}
-func (*BackupCustomHooksResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{49} }
+func (*BackupCustomHooksResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{49} }
 
 func (m *BackupCustomHooksResponse) GetData() []byte {
 	if m != nil {
@@ -1194,7 +1190,7 @@ func (m *CreateRepositoryFromBundleRequest) Reset()         { *m = CreateReposit
 func (m *CreateRepositoryFromBundleRequest) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryFromBundleRequest) ProtoMessage()    {}
 func (*CreateRepositoryFromBundleRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor10, []int{50}
+	return fileDescriptor9, []int{50}
 }
 
 func (m *CreateRepositoryFromBundleRequest) GetRepository() *Repository {
@@ -1218,7 +1214,7 @@ func (m *CreateRepositoryFromBundleResponse) Reset()         { *m = CreateReposi
 func (m *CreateRepositoryFromBundleResponse) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryFromBundleResponse) ProtoMessage()    {}
 func (*CreateRepositoryFromBundleResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor10, []int{51}
+	return fileDescriptor9, []int{51}
 }
 
 type FindLicenseRequest struct {
@@ -1228,7 +1224,7 @@ type FindLicenseRequest struct {
 func (m *FindLicenseRequest) Reset()                    { *m = FindLicenseRequest{} }
 func (m *FindLicenseRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindLicenseRequest) ProtoMessage()               {}
-func (*FindLicenseRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{52} }
+func (*FindLicenseRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{52} }
 
 func (m *FindLicenseRequest) GetRepository() *Repository {
 	if m != nil {
@@ -1244,7 +1240,7 @@ type FindLicenseResponse struct {
 func (m *FindLicenseResponse) Reset()                    { *m = FindLicenseResponse{} }
 func (m *FindLicenseResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindLicenseResponse) ProtoMessage()               {}
-func (*FindLicenseResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{53} }
+func (*FindLicenseResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{53} }
 
 func (m *FindLicenseResponse) GetLicenseShortName() string {
 	if m != nil {
@@ -1260,7 +1256,7 @@ type GetInfoAttributesRequest struct {
 func (m *GetInfoAttributesRequest) Reset()                    { *m = GetInfoAttributesRequest{} }
 func (m *GetInfoAttributesRequest) String() string            { return proto.CompactTextString(m) }
 func (*GetInfoAttributesRequest) ProtoMessage()               {}
-func (*GetInfoAttributesRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{54} }
+func (*GetInfoAttributesRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{54} }
 
 func (m *GetInfoAttributesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -1276,7 +1272,7 @@ type GetInfoAttributesResponse struct {
 func (m *GetInfoAttributesResponse) Reset()                    { *m = GetInfoAttributesResponse{} }
 func (m *GetInfoAttributesResponse) String() string            { return proto.CompactTextString(m) }
 func (*GetInfoAttributesResponse) ProtoMessage()               {}
-func (*GetInfoAttributesResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{55} }
+func (*GetInfoAttributesResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{55} }
 
 func (m *GetInfoAttributesResponse) GetAttributes() []byte {
 	if m != nil {
@@ -1292,7 +1288,7 @@ type CalculateChecksumRequest struct {
 func (m *CalculateChecksumRequest) Reset()                    { *m = CalculateChecksumRequest{} }
 func (m *CalculateChecksumRequest) String() string            { return proto.CompactTextString(m) }
 func (*CalculateChecksumRequest) ProtoMessage()               {}
-func (*CalculateChecksumRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{56} }
+func (*CalculateChecksumRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{56} }
 
 func (m *CalculateChecksumRequest) GetRepository() *Repository {
 	if m != nil {
@@ -1308,7 +1304,7 @@ type CalculateChecksumResponse struct {
 func (m *CalculateChecksumResponse) Reset()                    { *m = CalculateChecksumResponse{} }
 func (m *CalculateChecksumResponse) String() string            { return proto.CompactTextString(m) }
 func (*CalculateChecksumResponse) ProtoMessage()               {}
-func (*CalculateChecksumResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{57} }
+func (*CalculateChecksumResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{57} }
 
 func (m *CalculateChecksumResponse) GetChecksum() string {
 	if m != nil {
@@ -1324,7 +1320,7 @@ type GetSnapshotRequest struct {
 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{58} }
+func (*GetSnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{58} }
 
 func (m *GetSnapshotRequest) GetRepository() *Repository {
 	if m != nil {
@@ -1340,7 +1336,7 @@ type GetSnapshotResponse struct {
 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{59} }
+func (*GetSnapshotResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{59} }
 
 func (m *GetSnapshotResponse) GetData() []byte {
 	if m != nil {
@@ -1359,7 +1355,7 @@ func (m *CreateRepositoryFromSnapshotRequest) Reset()         { *m = CreateRepos
 func (m *CreateRepositoryFromSnapshotRequest) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryFromSnapshotRequest) ProtoMessage()    {}
 func (*CreateRepositoryFromSnapshotRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor10, []int{60}
+	return fileDescriptor9, []int{60}
 }
 
 func (m *CreateRepositoryFromSnapshotRequest) GetRepository() *Repository {
@@ -1390,7 +1386,7 @@ func (m *CreateRepositoryFromSnapshotResponse) Reset()         { *m = CreateRepo
 func (m *CreateRepositoryFromSnapshotResponse) String() string { return proto.CompactTextString(m) }
 func (*CreateRepositoryFromSnapshotResponse) ProtoMessage()    {}
 func (*CreateRepositoryFromSnapshotResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor10, []int{61}
+	return fileDescriptor9, []int{61}
 }
 
 type GetRawChangesRequest struct {
@@ -1402,7 +1398,7 @@ type GetRawChangesRequest struct {
 func (m *GetRawChangesRequest) Reset()                    { *m = GetRawChangesRequest{} }
 func (m *GetRawChangesRequest) String() string            { return proto.CompactTextString(m) }
 func (*GetRawChangesRequest) ProtoMessage()               {}
-func (*GetRawChangesRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{62} }
+func (*GetRawChangesRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{62} }
 
 func (m *GetRawChangesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -1432,7 +1428,7 @@ type GetRawChangesResponse struct {
 func (m *GetRawChangesResponse) Reset()                    { *m = GetRawChangesResponse{} }
 func (m *GetRawChangesResponse) String() string            { return proto.CompactTextString(m) }
 func (*GetRawChangesResponse) ProtoMessage()               {}
-func (*GetRawChangesResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{63} }
+func (*GetRawChangesResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{63} }
 
 func (m *GetRawChangesResponse) GetRawChanges() []*GetRawChangesResponse_RawChange {
 	if m != nil {
@@ -1456,7 +1452,7 @@ func (m *GetRawChangesResponse_RawChange) Reset()         { *m = GetRawChangesRe
 func (m *GetRawChangesResponse_RawChange) String() string { return proto.CompactTextString(m) }
 func (*GetRawChangesResponse_RawChange) ProtoMessage()    {}
 func (*GetRawChangesResponse_RawChange) Descriptor() ([]byte, []int) {
-	return fileDescriptor10, []int{63, 0}
+	return fileDescriptor9, []int{63, 0}
 }
 
 func (m *GetRawChangesResponse_RawChange) GetBlobId() string {
@@ -1524,7 +1520,7 @@ type SearchFilesByNameRequest struct {
 func (m *SearchFilesByNameRequest) Reset()                    { *m = SearchFilesByNameRequest{} }
 func (m *SearchFilesByNameRequest) String() string            { return proto.CompactTextString(m) }
 func (*SearchFilesByNameRequest) ProtoMessage()               {}
-func (*SearchFilesByNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{64} }
+func (*SearchFilesByNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{64} }
 
 func (m *SearchFilesByNameRequest) GetRepository() *Repository {
 	if m != nil {
@@ -1554,7 +1550,7 @@ type SearchFilesByNameResponse struct {
 func (m *SearchFilesByNameResponse) Reset()                    { *m = SearchFilesByNameResponse{} }
 func (m *SearchFilesByNameResponse) String() string            { return proto.CompactTextString(m) }
 func (*SearchFilesByNameResponse) ProtoMessage()               {}
-func (*SearchFilesByNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{65} }
+func (*SearchFilesByNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{65} }
 
 func (m *SearchFilesByNameResponse) GetFiles() [][]byte {
 	if m != nil {
@@ -1572,7 +1568,7 @@ type SearchFilesByContentRequest struct {
 func (m *SearchFilesByContentRequest) Reset()                    { *m = SearchFilesByContentRequest{} }
 func (m *SearchFilesByContentRequest) String() string            { return proto.CompactTextString(m) }
 func (*SearchFilesByContentRequest) ProtoMessage()               {}
-func (*SearchFilesByContentRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{66} }
+func (*SearchFilesByContentRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{66} }
 
 func (m *SearchFilesByContentRequest) GetRepository() *Repository {
 	if m != nil {
@@ -1602,7 +1598,7 @@ type SearchFilesByContentResponse struct {
 func (m *SearchFilesByContentResponse) Reset()                    { *m = SearchFilesByContentResponse{} }
 func (m *SearchFilesByContentResponse) String() string            { return proto.CompactTextString(m) }
 func (*SearchFilesByContentResponse) ProtoMessage()               {}
-func (*SearchFilesByContentResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{67} }
+func (*SearchFilesByContentResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{67} }
 
 func (m *SearchFilesByContentResponse) GetMatches() [][]byte {
 	if m != nil {
@@ -3132,9 +3128,9 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "repository-service.proto",
 }
 
-func init() { proto.RegisterFile("repository-service.proto", fileDescriptor10) }
+func init() { proto.RegisterFile("repository-service.proto", fileDescriptor9) }
 
-var fileDescriptor10 = []byte{
+var fileDescriptor9 = []byte{
 	// 2364 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x51, 0x6f, 0xdb, 0xc8,
 	0x11, 0x96, 0x2c, 0xcb, 0x92, 0x46, 0xca, 0x9d, 0xbc, 0x56, 0x6c, 0x89, 0x71, 0xe2, 0x84, 0x09,
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/server.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/server.pb.go
index 1c488b564..f0f1b038f 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/server.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/server.pb.go
@@ -23,7 +23,7 @@ type ServerInfoRequest struct {
 func (m *ServerInfoRequest) Reset()                    { *m = ServerInfoRequest{} }
 func (m *ServerInfoRequest) String() string            { return proto.CompactTextString(m) }
 func (*ServerInfoRequest) ProtoMessage()               {}
-func (*ServerInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{0} }
+func (*ServerInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{0} }
 
 type ServerInfoResponse struct {
 	ServerVersion   string                              `protobuf:"bytes,1,opt,name=server_version,json=serverVersion" json:"server_version,omitempty"`
@@ -34,7 +34,7 @@ type ServerInfoResponse struct {
 func (m *ServerInfoResponse) Reset()                    { *m = ServerInfoResponse{} }
 func (m *ServerInfoResponse) String() string            { return proto.CompactTextString(m) }
 func (*ServerInfoResponse) ProtoMessage()               {}
-func (*ServerInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{1} }
+func (*ServerInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{1} }
 
 func (m *ServerInfoResponse) GetServerVersion() string {
 	if m != nil {
@@ -67,7 +67,7 @@ func (m *ServerInfoResponse_StorageStatus) Reset()         { *m = ServerInfoResp
 func (m *ServerInfoResponse_StorageStatus) String() string { return proto.CompactTextString(m) }
 func (*ServerInfoResponse_StorageStatus) ProtoMessage()    {}
 func (*ServerInfoResponse_StorageStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor11, []int{1, 0}
+	return fileDescriptor10, []int{1, 0}
 }
 
 func (m *ServerInfoResponse_StorageStatus) GetStorageName() string {
@@ -169,9 +169,9 @@ var _ServerService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "server.proto",
 }
 
-func init() { proto.RegisterFile("server.proto", fileDescriptor11) }
+func init() { proto.RegisterFile("server.proto", fileDescriptor10) }
 
-var fileDescriptor11 = []byte{
+var fileDescriptor10 = []byte{
 	// 258 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x91, 0xcf, 0x4a, 0xc3, 0x40,
 	0x10, 0xc6, 0x6d, 0x03, 0xa5, 0x9d, 0x34, 0xfe, 0x19, 0x2f, 0x35, 0x08, 0xd6, 0x80, 0x90, 0x53,
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/shared.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/shared.pb.go
index 654be4f93..ac8a17291 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/shared.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/shared.pb.go
@@ -30,7 +30,7 @@ type Repository struct {
 func (m *Repository) Reset()                    { *m = Repository{} }
 func (m *Repository) String() string            { return proto.CompactTextString(m) }
 func (*Repository) ProtoMessage()               {}
-func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{0} }
+func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{0} }
 
 func (m *Repository) GetStorageName() string {
 	if m != nil {
@@ -84,7 +84,7 @@ type GitCommit struct {
 func (m *GitCommit) Reset()                    { *m = GitCommit{} }
 func (m *GitCommit) String() string            { return proto.CompactTextString(m) }
 func (*GitCommit) ProtoMessage()               {}
-func (*GitCommit) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{1} }
+func (*GitCommit) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{1} }
 
 func (m *GitCommit) GetId() string {
 	if m != nil {
@@ -144,7 +144,7 @@ type CommitAuthor struct {
 func (m *CommitAuthor) Reset()                    { *m = CommitAuthor{} }
 func (m *CommitAuthor) String() string            { return proto.CompactTextString(m) }
 func (*CommitAuthor) ProtoMessage()               {}
-func (*CommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{2} }
+func (*CommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{2} }
 
 func (m *CommitAuthor) GetName() []byte {
 	if m != nil {
@@ -174,7 +174,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 fileDescriptor12, []int{3} }
+func (*ExitStatus) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{3} }
 
 func (m *ExitStatus) GetValue() int32 {
 	if m != nil {
@@ -192,7 +192,7 @@ type Branch struct {
 func (m *Branch) Reset()                    { *m = Branch{} }
 func (m *Branch) String() string            { return proto.CompactTextString(m) }
 func (*Branch) ProtoMessage()               {}
-func (*Branch) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{4} }
+func (*Branch) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{4} }
 
 func (m *Branch) GetName() []byte {
 	if m != nil {
@@ -223,7 +223,7 @@ type Tag struct {
 func (m *Tag) Reset()                    { *m = Tag{} }
 func (m *Tag) String() string            { return proto.CompactTextString(m) }
 func (*Tag) ProtoMessage()               {}
-func (*Tag) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{5} }
+func (*Tag) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{5} }
 
 func (m *Tag) GetName() []byte {
 	if m != nil {
@@ -277,7 +277,7 @@ type User struct {
 func (m *User) Reset()                    { *m = User{} }
 func (m *User) String() string            { return proto.CompactTextString(m) }
 func (*User) ProtoMessage()               {}
-func (*User) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{6} }
+func (*User) Descriptor() ([]byte, []int) { return fileDescriptor11, []int{6} }
 
 func (m *User) GetGlId() string {
 	if m != nil {
@@ -317,9 +317,9 @@ func init() {
 	proto.RegisterType((*User)(nil), "gitaly.User")
 }
 
-func init() { proto.RegisterFile("shared.proto", fileDescriptor12) }
+func init() { proto.RegisterFile("shared.proto", fileDescriptor11) }
 
-var fileDescriptor12 = []byte{
+var fileDescriptor11 = []byte{
 	// 576 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0x41, 0x6f, 0xd4, 0x3c,
 	0x10, 0x55, 0xb2, 0xd9, 0x6d, 0x77, 0x36, 0xfd, 0xf4, 0x61, 0x7a, 0x88, 0x8a, 0xaa, 0x2e, 0xe1,
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/smarthttp.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/smarthttp.pb.go
index 819b50e14..f4c8ebbf1 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/smarthttp.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/smarthttp.pb.go
@@ -28,7 +28,7 @@ type InfoRefsRequest struct {
 func (m *InfoRefsRequest) Reset()                    { *m = InfoRefsRequest{} }
 func (m *InfoRefsRequest) String() string            { return proto.CompactTextString(m) }
 func (*InfoRefsRequest) ProtoMessage()               {}
-func (*InfoRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{0} }
+func (*InfoRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{0} }
 
 func (m *InfoRefsRequest) GetRepository() *Repository {
 	if m != nil {
@@ -58,7 +58,7 @@ type InfoRefsResponse struct {
 func (m *InfoRefsResponse) Reset()                    { *m = InfoRefsResponse{} }
 func (m *InfoRefsResponse) String() string            { return proto.CompactTextString(m) }
 func (*InfoRefsResponse) ProtoMessage()               {}
-func (*InfoRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{1} }
+func (*InfoRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{1} }
 
 func (m *InfoRefsResponse) GetData() []byte {
 	if m != nil {
@@ -81,7 +81,7 @@ type PostUploadPackRequest struct {
 func (m *PostUploadPackRequest) Reset()                    { *m = PostUploadPackRequest{} }
 func (m *PostUploadPackRequest) String() string            { return proto.CompactTextString(m) }
 func (*PostUploadPackRequest) ProtoMessage()               {}
-func (*PostUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{2} }
+func (*PostUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{2} }
 
 func (m *PostUploadPackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -119,7 +119,7 @@ type PostUploadPackResponse struct {
 func (m *PostUploadPackResponse) Reset()                    { *m = PostUploadPackResponse{} }
 func (m *PostUploadPackResponse) String() string            { return proto.CompactTextString(m) }
 func (*PostUploadPackResponse) ProtoMessage()               {}
-func (*PostUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{3} }
+func (*PostUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{3} }
 
 func (m *PostUploadPackResponse) GetData() []byte {
 	if m != nil {
@@ -147,7 +147,7 @@ type PostReceivePackRequest struct {
 func (m *PostReceivePackRequest) Reset()                    { *m = PostReceivePackRequest{} }
 func (m *PostReceivePackRequest) String() string            { return proto.CompactTextString(m) }
 func (*PostReceivePackRequest) ProtoMessage()               {}
-func (*PostReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{4} }
+func (*PostReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{4} }
 
 func (m *PostReceivePackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -206,7 +206,7 @@ type PostReceivePackResponse struct {
 func (m *PostReceivePackResponse) Reset()                    { *m = PostReceivePackResponse{} }
 func (m *PostReceivePackResponse) String() string            { return proto.CompactTextString(m) }
 func (*PostReceivePackResponse) ProtoMessage()               {}
-func (*PostReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{5} }
+func (*PostReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor12, []int{5} }
 
 func (m *PostReceivePackResponse) GetData() []byte {
 	if m != nil {
@@ -521,9 +521,9 @@ var _SmartHTTPService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "smarthttp.proto",
 }
 
-func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor13) }
+func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor12) }
 
-var fileDescriptor13 = []byte{
+var fileDescriptor12 = []byte{
 	// 423 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x53, 0xd1, 0x8a, 0xd3, 0x40,
 	0x14, 0x75, 0xd2, 0x6e, 0x65, 0x6f, 0xa3, 0x2d, 0x77, 0xd1, 0x0d, 0x01, 0xdd, 0x1a, 0x41, 0xf2,
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/ssh.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/ssh.pb.go
index ae3c952a9..5b9bbe3ba 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/ssh.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/ssh.pb.go
@@ -31,7 +31,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 fileDescriptor14, []int{0} }
+func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{0} }
 
 func (m *SSHUploadPackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -74,7 +74,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 fileDescriptor14, []int{1} }
+func (*SSHUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{1} }
 
 func (m *SSHUploadPackResponse) GetStdout() []byte {
 	if m != nil {
@@ -116,7 +116,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 fileDescriptor14, []int{2} }
+func (*SSHReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{2} }
 
 func (m *SSHReceivePackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -180,7 +180,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 fileDescriptor14, []int{3} }
+func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{3} }
 
 func (m *SSHReceivePackResponse) GetStdout() []byte {
 	if m != nil {
@@ -213,7 +213,7 @@ type SSHUploadArchiveRequest struct {
 func (m *SSHUploadArchiveRequest) Reset()                    { *m = SSHUploadArchiveRequest{} }
 func (m *SSHUploadArchiveRequest) String() string            { return proto.CompactTextString(m) }
 func (*SSHUploadArchiveRequest) ProtoMessage()               {}
-func (*SSHUploadArchiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{4} }
+func (*SSHUploadArchiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{4} }
 
 func (m *SSHUploadArchiveRequest) GetRepository() *Repository {
 	if m != nil {
@@ -241,7 +241,7 @@ type SSHUploadArchiveResponse struct {
 func (m *SSHUploadArchiveResponse) Reset()                    { *m = SSHUploadArchiveResponse{} }
 func (m *SSHUploadArchiveResponse) String() string            { return proto.CompactTextString(m) }
 func (*SSHUploadArchiveResponse) ProtoMessage()               {}
-func (*SSHUploadArchiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{5} }
+func (*SSHUploadArchiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor13, []int{5} }
 
 func (m *SSHUploadArchiveResponse) GetStdout() []byte {
 	if m != nil {
@@ -513,9 +513,9 @@ var _SSHService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "ssh.proto",
 }
 
-func init() { proto.RegisterFile("ssh.proto", fileDescriptor14) }
+func init() { proto.RegisterFile("ssh.proto", fileDescriptor13) }
 
-var fileDescriptor14 = []byte{
+var fileDescriptor13 = []byte{
 	// 452 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x53, 0xc1, 0x6e, 0xd3, 0x40,
 	0x10, 0xc5, 0x89, 0x13, 0xc8, 0xc4, 0x45, 0xd1, 0xd2, 0x16, 0x2b, 0x02, 0x6a, 0xcc, 0xc5, 0x07,
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/storage.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/storage.pb.go
index bdaa741cf..14418f0de 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/storage.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/storage.pb.go
@@ -25,7 +25,7 @@ type ListDirectoriesRequest struct {
 func (m *ListDirectoriesRequest) Reset()                    { *m = ListDirectoriesRequest{} }
 func (m *ListDirectoriesRequest) String() string            { return proto.CompactTextString(m) }
 func (*ListDirectoriesRequest) ProtoMessage()               {}
-func (*ListDirectoriesRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{0} }
+func (*ListDirectoriesRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{0} }
 
 func (m *ListDirectoriesRequest) GetStorageName() string {
 	if m != nil {
@@ -48,7 +48,7 @@ type ListDirectoriesResponse struct {
 func (m *ListDirectoriesResponse) Reset()                    { *m = ListDirectoriesResponse{} }
 func (m *ListDirectoriesResponse) String() string            { return proto.CompactTextString(m) }
 func (*ListDirectoriesResponse) ProtoMessage()               {}
-func (*ListDirectoriesResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{1} }
+func (*ListDirectoriesResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{1} }
 
 func (m *ListDirectoriesResponse) GetPaths() []string {
 	if m != nil {
@@ -64,7 +64,7 @@ type DeleteAllRepositoriesRequest struct {
 func (m *DeleteAllRepositoriesRequest) Reset()                    { *m = DeleteAllRepositoriesRequest{} }
 func (m *DeleteAllRepositoriesRequest) String() string            { return proto.CompactTextString(m) }
 func (*DeleteAllRepositoriesRequest) ProtoMessage()               {}
-func (*DeleteAllRepositoriesRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{2} }
+func (*DeleteAllRepositoriesRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{2} }
 
 func (m *DeleteAllRepositoriesRequest) GetStorageName() string {
 	if m != nil {
@@ -79,7 +79,7 @@ type DeleteAllRepositoriesResponse struct {
 func (m *DeleteAllRepositoriesResponse) Reset()                    { *m = DeleteAllRepositoriesResponse{} }
 func (m *DeleteAllRepositoriesResponse) String() string            { return proto.CompactTextString(m) }
 func (*DeleteAllRepositoriesResponse) ProtoMessage()               {}
-func (*DeleteAllRepositoriesResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{3} }
+func (*DeleteAllRepositoriesResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{3} }
 
 func init() {
 	proto.RegisterType((*ListDirectoriesRequest)(nil), "gitaly.ListDirectoriesRequest")
@@ -221,9 +221,9 @@ var _StorageService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "storage.proto",
 }
 
-func init() { proto.RegisterFile("storage.proto", fileDescriptor15) }
+func init() { proto.RegisterFile("storage.proto", fileDescriptor14) }
 
-var fileDescriptor15 = []byte{
+var fileDescriptor14 = []byte{
 	// 238 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x2d, 0x2e, 0xc9, 0x2f,
 	0x4a, 0x4c, 0x4f, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x4b, 0xcf, 0x2c, 0x49, 0xcc,
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/wiki.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/wiki.pb.go
index 4dbaf5dab..a53fd0c8e 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/wiki.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/wiki.pb.go
@@ -28,7 +28,7 @@ type WikiCommitDetails struct {
 func (m *WikiCommitDetails) Reset()                    { *m = WikiCommitDetails{} }
 func (m *WikiCommitDetails) String() string            { return proto.CompactTextString(m) }
 func (*WikiCommitDetails) ProtoMessage()               {}
-func (*WikiCommitDetails) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{0} }
+func (*WikiCommitDetails) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{0} }
 
 func (m *WikiCommitDetails) GetName() []byte {
 	if m != nil {
@@ -73,7 +73,7 @@ type WikiPageVersion struct {
 func (m *WikiPageVersion) Reset()                    { *m = WikiPageVersion{} }
 func (m *WikiPageVersion) String() string            { return proto.CompactTextString(m) }
 func (*WikiPageVersion) ProtoMessage()               {}
-func (*WikiPageVersion) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{1} }
+func (*WikiPageVersion) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{1} }
 
 func (m *WikiPageVersion) GetCommit() *GitCommit {
 	if m != nil {
@@ -105,7 +105,7 @@ type WikiPage struct {
 func (m *WikiPage) Reset()                    { *m = WikiPage{} }
 func (m *WikiPage) String() string            { return proto.CompactTextString(m) }
 func (*WikiPage) ProtoMessage()               {}
-func (*WikiPage) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{2} }
+func (*WikiPage) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{2} }
 
 func (m *WikiPage) GetVersion() *WikiPageVersion {
 	if m != nil {
@@ -173,7 +173,7 @@ type WikiGetPageVersionsRequest struct {
 func (m *WikiGetPageVersionsRequest) Reset()                    { *m = WikiGetPageVersionsRequest{} }
 func (m *WikiGetPageVersionsRequest) String() string            { return proto.CompactTextString(m) }
 func (*WikiGetPageVersionsRequest) ProtoMessage()               {}
-func (*WikiGetPageVersionsRequest) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{3} }
+func (*WikiGetPageVersionsRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{3} }
 
 func (m *WikiGetPageVersionsRequest) GetRepository() *Repository {
 	if m != nil {
@@ -210,7 +210,7 @@ type WikiGetPageVersionsResponse struct {
 func (m *WikiGetPageVersionsResponse) Reset()                    { *m = WikiGetPageVersionsResponse{} }
 func (m *WikiGetPageVersionsResponse) String() string            { return proto.CompactTextString(m) }
 func (*WikiGetPageVersionsResponse) ProtoMessage()               {}
-func (*WikiGetPageVersionsResponse) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{4} }
+func (*WikiGetPageVersionsResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{4} }
 
 func (m *WikiGetPageVersionsResponse) GetVersions() []*WikiPageVersion {
 	if m != nil {
@@ -233,7 +233,7 @@ type WikiWritePageRequest struct {
 func (m *WikiWritePageRequest) Reset()                    { *m = WikiWritePageRequest{} }
 func (m *WikiWritePageRequest) String() string            { return proto.CompactTextString(m) }
 func (*WikiWritePageRequest) ProtoMessage()               {}
-func (*WikiWritePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{5} }
+func (*WikiWritePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{5} }
 
 func (m *WikiWritePageRequest) GetRepository() *Repository {
 	if m != nil {
@@ -277,7 +277,7 @@ type WikiWritePageResponse struct {
 func (m *WikiWritePageResponse) Reset()                    { *m = WikiWritePageResponse{} }
 func (m *WikiWritePageResponse) String() string            { return proto.CompactTextString(m) }
 func (*WikiWritePageResponse) ProtoMessage()               {}
-func (*WikiWritePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{6} }
+func (*WikiWritePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{6} }
 
 func (m *WikiWritePageResponse) GetDuplicateError() []byte {
 	if m != nil {
@@ -300,7 +300,7 @@ type WikiUpdatePageRequest struct {
 func (m *WikiUpdatePageRequest) Reset()                    { *m = WikiUpdatePageRequest{} }
 func (m *WikiUpdatePageRequest) String() string            { return proto.CompactTextString(m) }
 func (*WikiUpdatePageRequest) ProtoMessage()               {}
-func (*WikiUpdatePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{7} }
+func (*WikiUpdatePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{7} }
 
 func (m *WikiUpdatePageRequest) GetRepository() *Repository {
 	if m != nil {
@@ -351,7 +351,7 @@ type WikiUpdatePageResponse struct {
 func (m *WikiUpdatePageResponse) Reset()                    { *m = WikiUpdatePageResponse{} }
 func (m *WikiUpdatePageResponse) String() string            { return proto.CompactTextString(m) }
 func (*WikiUpdatePageResponse) ProtoMessage()               {}
-func (*WikiUpdatePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{8} }
+func (*WikiUpdatePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{8} }
 
 func (m *WikiUpdatePageResponse) GetError() []byte {
 	if m != nil {
@@ -369,7 +369,7 @@ type WikiDeletePageRequest struct {
 func (m *WikiDeletePageRequest) Reset()                    { *m = WikiDeletePageRequest{} }
 func (m *WikiDeletePageRequest) String() string            { return proto.CompactTextString(m) }
 func (*WikiDeletePageRequest) ProtoMessage()               {}
-func (*WikiDeletePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{9} }
+func (*WikiDeletePageRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{9} }
 
 func (m *WikiDeletePageRequest) GetRepository() *Repository {
 	if m != nil {
@@ -398,7 +398,7 @@ type WikiDeletePageResponse struct {
 func (m *WikiDeletePageResponse) Reset()                    { *m = WikiDeletePageResponse{} }
 func (m *WikiDeletePageResponse) String() string            { return proto.CompactTextString(m) }
 func (*WikiDeletePageResponse) ProtoMessage()               {}
-func (*WikiDeletePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{10} }
+func (*WikiDeletePageResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{10} }
 
 type WikiFindPageRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -410,7 +410,7 @@ type WikiFindPageRequest struct {
 func (m *WikiFindPageRequest) Reset()                    { *m = WikiFindPageRequest{} }
 func (m *WikiFindPageRequest) String() string            { return proto.CompactTextString(m) }
 func (*WikiFindPageRequest) ProtoMessage()               {}
-func (*WikiFindPageRequest) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{11} }
+func (*WikiFindPageRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{11} }
 
 func (m *WikiFindPageRequest) GetRepository() *Repository {
 	if m != nil {
@@ -449,7 +449,7 @@ type WikiFindPageResponse struct {
 func (m *WikiFindPageResponse) Reset()                    { *m = WikiFindPageResponse{} }
 func (m *WikiFindPageResponse) String() string            { return proto.CompactTextString(m) }
 func (*WikiFindPageResponse) ProtoMessage()               {}
-func (*WikiFindPageResponse) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{12} }
+func (*WikiFindPageResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{12} }
 
 func (m *WikiFindPageResponse) GetPage() *WikiPage {
 	if m != nil {
@@ -468,7 +468,7 @@ type WikiFindFileRequest struct {
 func (m *WikiFindFileRequest) Reset()                    { *m = WikiFindFileRequest{} }
 func (m *WikiFindFileRequest) String() string            { return proto.CompactTextString(m) }
 func (*WikiFindFileRequest) ProtoMessage()               {}
-func (*WikiFindFileRequest) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{13} }
+func (*WikiFindFileRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{13} }
 
 func (m *WikiFindFileRequest) GetRepository() *Repository {
 	if m != nil {
@@ -502,7 +502,7 @@ type WikiFindFileResponse struct {
 func (m *WikiFindFileResponse) Reset()                    { *m = WikiFindFileResponse{} }
 func (m *WikiFindFileResponse) String() string            { return proto.CompactTextString(m) }
 func (*WikiFindFileResponse) ProtoMessage()               {}
-func (*WikiFindFileResponse) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{14} }
+func (*WikiFindFileResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{14} }
 
 func (m *WikiFindFileResponse) GetName() []byte {
 	if m != nil {
@@ -541,7 +541,7 @@ type WikiGetAllPagesRequest struct {
 func (m *WikiGetAllPagesRequest) Reset()                    { *m = WikiGetAllPagesRequest{} }
 func (m *WikiGetAllPagesRequest) String() string            { return proto.CompactTextString(m) }
 func (*WikiGetAllPagesRequest) ProtoMessage()               {}
-func (*WikiGetAllPagesRequest) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{15} }
+func (*WikiGetAllPagesRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{15} }
 
 func (m *WikiGetAllPagesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -567,7 +567,7 @@ type WikiGetAllPagesResponse struct {
 func (m *WikiGetAllPagesResponse) Reset()                    { *m = WikiGetAllPagesResponse{} }
 func (m *WikiGetAllPagesResponse) String() string            { return proto.CompactTextString(m) }
 func (*WikiGetAllPagesResponse) ProtoMessage()               {}
-func (*WikiGetAllPagesResponse) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{16} }
+func (*WikiGetAllPagesResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{16} }
 
 func (m *WikiGetAllPagesResponse) GetPage() *WikiPage {
 	if m != nil {
@@ -593,7 +593,7 @@ type WikiGetFormattedDataRequest struct {
 func (m *WikiGetFormattedDataRequest) Reset()                    { *m = WikiGetFormattedDataRequest{} }
 func (m *WikiGetFormattedDataRequest) String() string            { return proto.CompactTextString(m) }
 func (*WikiGetFormattedDataRequest) ProtoMessage()               {}
-func (*WikiGetFormattedDataRequest) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{17} }
+func (*WikiGetFormattedDataRequest) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{17} }
 
 func (m *WikiGetFormattedDataRequest) GetRepository() *Repository {
 	if m != nil {
@@ -630,7 +630,7 @@ type WikiGetFormattedDataResponse struct {
 func (m *WikiGetFormattedDataResponse) Reset()                    { *m = WikiGetFormattedDataResponse{} }
 func (m *WikiGetFormattedDataResponse) String() string            { return proto.CompactTextString(m) }
 func (*WikiGetFormattedDataResponse) ProtoMessage()               {}
-func (*WikiGetFormattedDataResponse) Descriptor() ([]byte, []int) { return fileDescriptor16, []int{18} }
+func (*WikiGetFormattedDataResponse) Descriptor() ([]byte, []int) { return fileDescriptor15, []int{18} }
 
 func (m *WikiGetFormattedDataResponse) GetData() []byte {
 	if m != nil {
@@ -1170,9 +1170,9 @@ var _WikiService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "wiki.proto",
 }
 
-func init() { proto.RegisterFile("wiki.proto", fileDescriptor16) }
+func init() { proto.RegisterFile("wiki.proto", fileDescriptor15) }
 
-var fileDescriptor16 = []byte{
+var fileDescriptor15 = []byte{
 	// 937 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0xcd, 0x6e, 0xe4, 0x44,
 	0x10, 0x5e, 0x67, 0xfe, 0x3c, 0x95, 0x9f, 0x65, 0x9b, 0x65, 0xe3, 0x75, 0x42, 0x88, 0x9a, 0x95,
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 763d2f69c..75c18e689 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -201,12 +201,12 @@
 			"revisionTime": "2017-12-31T12:27:32Z"
 		},
 		{
-			"checksumSHA1": "KtPXpPuSNYehoMJYatJSK4j94OI=",
+			"checksumSHA1": "7DDyruoxYwkzwvNiWIqfw79gUqA=",
 			"path": "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb",
-			"revision": "38222414e1f612f789775f75d3228213fcaed7bf",
-			"revisionTime": "2018-10-04T06:49:09Z",
-			"version": "v0.119.0",
-			"versionExact": "v0.119.0"
+			"revision": "790a4f7603441ddc6d703c2eb9394212992114a3",
+			"revisionTime": "2018-10-04T12:44:29Z",
+			"version": "v0.120.0",
+			"versionExact": "v0.120.0"
 		},
 		{
 			"checksumSHA1": "nqWNlnMmVpt628zzvyo6Yv2CX5Q=",