Merge branch 'add-new-rebase' into 'master'

Add new two-phase Rebase RPC

See merge request gitlab-org/gitaly!1208

15 files changed, 1654 insertions, 377 deletions

diff --git a/changelogs/unreleased/add-new-rebase.yml b/changelogs/unreleased/add-new-rebase.yml
new file mode 100644
index 000000000..593b1477e
--- /dev/null
+++ b/changelogs/unreleased/add-new-rebase.yml
@@ -0,0 +1,5 @@
+---
+title: Add new two-step UserRebaseConfirmable RPC
+merge_request: 1208
+author:
+type: added
diff --git a/internal/service/cleanup/server.go b/internal/service/cleanup/server.go
index c5bcb6d8f..dcb16ae4e 100644
--- a/internal/service/cleanup/server.go
+++ b/internal/service/cleanup/server.go
@@ -1,7 +1,10 @@
 package cleanup
 
 import (
+	"context"
+
 	"gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
+	"gitlab.com/gitlab-org/gitaly/internal/helper"
 )
 
 type server struct{}
@@ -10,3 +13,11 @@ type server struct{}
 func NewServer() gitalypb.CleanupServiceServer {
 	return &server{}
 }
+
+func (s *server) CloseSession(context.Context, *gitalypb.CloseSessionRequest) (*gitalypb.CloseSessionResponse, error) {
+	return nil, helper.Unimplemented
+}
+
+func (s *server) ApplyBfgObjectMapStream(gitalypb.CleanupService_ApplyBfgObjectMapStreamServer) error {
+	return helper.Unimplemented
+}
diff --git a/internal/service/operations/merge_test.go b/internal/service/operations/merge_test.go
index a682e4ff3..44e875b65 100644
--- a/internal/service/operations/merge_test.go
+++ b/internal/service/operations/merge_test.go
@@ -2,7 +2,6 @@ package operations
 
 import (
 	"fmt"
-	"io"
 	"io/ioutil"
 	"os"
 	"os/exec"
@@ -77,7 +76,7 @@ func TestSuccessfulMerge(t *testing.T) {
 	secondResponse, err := mergeBidi.Recv()
 	require.NoError(t, err, "receive second response")
 
-	err = consumeEOF(func() error {
+	err = testhelper.ReceiveEOFWithTimeout(func() error {
 		_, err = mergeBidi.Recv()
 		return err
 	})
@@ -267,7 +266,7 @@ func TestFailedMergeDueToHooks(t *testing.T) {
 			require.NoError(t, err, "receive second response")
 			require.Contains(t, secondResponse.PreReceiveError, "failure")
 
-			err = consumeEOF(func() error {
+			err = testhelper.ReceiveEOFWithTimeout(func() error {
 				_, err = mergeBidi.Recv()
 				return err
 			})
@@ -693,26 +692,6 @@ func prepareMergeBranch(t *testing.T, testRepoPath string) {
 	require.NoError(t, err, "set up branch to merge into: %s", out)
 }
 
-func consumeEOF(errorFunc func() error) error {
-	errCh := make(chan error, 1)
-	go func() {
-		errCh <- errorFunc()
-	}()
-
-	var err error
-	select {
-	case err = <-errCh:
-	case <-time.After(1 * time.Second):
-		err = fmt.Errorf("timed out waiting for EOF")
-	}
-
-	if err == io.EOF {
-		err = nil
-	}
-
-	return err
-}
-
 func deleteBranch(testRepoPath, branchName string) {
 	exec.Command("git", "-C", testRepoPath, "branch", "-D", branchName).Run()
 }
diff --git a/internal/service/operations/rebase.go b/internal/service/operations/rebase.go
index abd012396..acc77b277 100644
--- a/internal/service/operations/rebase.go
+++ b/internal/service/operations/rebase.go
@@ -1,15 +1,115 @@
 package operations
 
+//lint:file-ignore SA1019 due to planned removal in issue https://gitlab.com/gitlab-org/gitaly/issues/1628
+
 import (
 	"context"
-	"fmt"
+	"errors"
 
 	"gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
+	"gitlab.com/gitlab-org/gitaly/internal/helper"
 	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
 
+func (s *server) UserRebaseConfirmable(stream gitalypb.OperationService_UserRebaseConfirmableServer) error {
+	firstRequest, err := stream.Recv()
+	if err != nil {
+		return err
+	}
+
+	header := firstRequest.GetHeader()
+	if header == nil {
+		return helper.ErrInvalidArgument(errors.New("UserRebaseConfirmable: empty UserRebaseConfirmableRequest.Header"))
+	}
+
+	if err := validateUserRebaseConfirmableHeader(header); err != nil {
+		return helper.ErrInvalidArgumentf("UserRebaseConfirmable: %v", err)
+	}
+
+	if err := s.userRebaseConfirmable(stream, firstRequest, header.GetRepository()); err != nil {
+		return helper.ErrInternal(err)
+	}
+
+	return nil
+}
+
+func (s *server) userRebaseConfirmable(stream gitalypb.OperationService_UserRebaseConfirmableServer, firstRequest *gitalypb.UserRebaseConfirmableRequest, repository *gitalypb.Repository) error {
+	ctx := stream.Context()
+	client, err := s.OperationServiceClient(ctx)
+	if err != nil {
+		return err
+	}
+
+	clientCtx, err := rubyserver.SetHeaders(ctx, repository)
+	if err != nil {
+		return err
+	}
+
+	rubyStream, err := client.UserRebaseConfirmable(clientCtx)
+	if err != nil {
+		return err
+	}
+
+	if err := rubyStream.Send(firstRequest); err != nil {
+		return err
+	}
+
+	return rubyserver.ProxyBidi(
+		func() error {
+			request, err := stream.Recv()
+			if err != nil {
+				return err
+			}
+
+			return rubyStream.Send(request)
+		},
+		rubyStream,
+		func() error {
+			response, err := rubyStream.Recv()
+			if err != nil {
+				return err
+			}
+
+			return stream.Send(response)
+		},
+	)
+}
+
+func validateUserRebaseConfirmableHeader(header *gitalypb.UserRebaseConfirmableRequest_Header) error {
+	if header.GetRepository() == nil {
+		return errors.New("empty Repository")
+	}
+
+	if header.GetUser() == nil {
+		return errors.New("empty User")
+	}
+
+	if header.GetRebaseId() == "" {
+		return errors.New("empty RebaseId")
+	}
+
+	if header.GetBranch() == nil {
+		return errors.New("empty Branch")
+	}
+
+	if header.GetBranchSha() == "" {
+		return errors.New("empty BranchSha")
+	}
+
+	if header.GetRemoteRepository() == nil {
+		return errors.New("empty RemoteRepository")
+	}
+
+	if header.GetRemoteBranch() == nil {
+		return errors.New("empty RemoteBranch")
+	}
+
+	return nil
+}
+
+// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
 func (s *server) UserRebase(ctx context.Context, req *gitalypb.UserRebaseRequest) (*gitalypb.UserRebaseResponse, error) {
 	if err := validateUserRebaseRequest(req); err != nil {
 		return nil, status.Errorf(codes.InvalidArgument, "UserRebase: %v", err)
@@ -28,33 +128,34 @@ func (s *server) UserRebase(ctx context.Context, req *gitalypb.UserRebaseRequest
 	return client.UserRebase(clientCtx, req)
 }
 
+// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
 func validateUserRebaseRequest(req *gitalypb.UserRebaseRequest) error {
 	if req.GetRepository() == nil {
-		return fmt.Errorf("empty Repository")
+		return errors.New("empty Repository")
 	}
 
 	if req.GetUser() == nil {
-		return fmt.Errorf("empty User")
+		return errors.New("empty User")
 	}
 
 	if req.GetRebaseId() == "" {
-		return fmt.Errorf("empty RebaseId")
+		return errors.New("empty RebaseId")
 	}
 
 	if req.GetBranch() == nil {
-		return fmt.Errorf("empty Branch")
+		return errors.New("empty Branch")
 	}
 
 	if req.GetBranchSha() == "" {
-		return fmt.Errorf("empty BranchSha")
+		return errors.New("empty BranchSha")
 	}
 
 	if req.GetRemoteRepository() == nil {
-		return fmt.Errorf("empty RemoteRepository")
+		return errors.New("empty RemoteRepository")
 	}
 
 	if req.GetRemoteBranch() == nil {
-		return fmt.Errorf("empty RemoteBranch")
+		return errors.New("empty RemoteBranch")
 	}
 
 	return nil
diff --git a/internal/service/operations/rebase_test.go b/internal/service/operations/rebase_test.go
index 0ac8eb44f..fc9f06f92 100644
--- a/internal/service/operations/rebase_test.go
+++ b/internal/service/operations/rebase_test.go
@@ -1,19 +1,34 @@
 package operations_test
 
+//lint:file-ignore SA1019 due to planned removal in issue https://gitlab.com/gitlab-org/gitaly/issues/1628
+
 import (
+	"errors"
 	"fmt"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/require"
 	"gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
+	gitlog "gitlab.com/gitlab-org/gitaly/internal/git/log"
 	"gitlab.com/gitlab-org/gitaly/internal/service/operations"
 	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
 )
 
-func TestSuccessfulUserRebaseRequest(t *testing.T) {
+var (
+	rebaseUser = &gitalypb.User{
+		Name:  []byte("Ahmad Sherif"),
+		Email: []byte("ahmad@gitlab.com"),
+		GlId:  "user-123",
+	}
+
+	branchName = "many_files"
+)
+
+func TestSuccessfulUserRebaseConfirmableRequest(t *testing.T) {
 	ctxOuter, cancel := testhelper.Context()
 	defer cancel()
 
@@ -29,19 +44,245 @@ func TestSuccessfulUserRebaseRequest(t *testing.T) {
 	testRepoCopy, _, cleanup := testhelper.NewTestRepo(t)
 	defer cleanup()
 
-	branchName := "many_files"
-	branchSha := string(testhelper.MustRunCommand(t, nil, "git", "-C", testRepoPath, "rev-parse", branchName))
-	branchSha = strings.TrimSpace(branchSha)
+	branchSha := getBranchSha(t, testRepoPath, branchName)
 
-	user := &gitalypb.User{
-		Name:  []byte("Ahmad Sherif"),
-		Email: []byte("ahmad@gitlab.com"),
-		GlId:  "user-123",
+	md := testhelper.GitalyServersMetadata(t, serverSocketPath)
+	ctx := metadata.NewOutgoingContext(ctxOuter, md)
+
+	rebaseStream, err := client.UserRebaseConfirmable(ctx)
+	require.NoError(t, err)
+
+	headerRequest := buildHeaderRequest(testRepo, rebaseUser, "1", branchName, branchSha, testRepoCopy, "master")
+	require.NoError(t, rebaseStream.Send(headerRequest), "send header")
+
+	firstResponse, err := rebaseStream.Recv()
+	require.NoError(t, err, "receive first response")
+
+	_, err = gitlog.GetCommit(ctx, testRepo, firstResponse.GetRebaseSha())
+	require.NoError(t, err, "look up git commit before rebase is applied")
+
+	applyRequest := buildApplyRequest(true)
+	require.NoError(t, rebaseStream.Send(applyRequest), "apply rebase")
+
+	secondResponse, err := rebaseStream.Recv()
+	require.NoError(t, err, "receive second response")
+
+	err = testhelper.ReceiveEOFWithTimeout(func() error {
+		_, err = rebaseStream.Recv()
+		return err
+	})
+	require.NoError(t, err, "consume EOF")
+
+	newBranchSha := getBranchSha(t, testRepoPath, branchName)
+
+	require.NotEqual(t, newBranchSha, branchSha)
+	require.Equal(t, newBranchSha, firstResponse.GetRebaseSha())
+
+	require.True(t, secondResponse.GetRebaseApplied(), "the second rebase is applied")
+}
+
+func TestFailedRebaseUserRebaseConfirmableRequestDueToInvalidHeader(t *testing.T) {
+	ctxOuter, cancel := testhelper.Context()
+	defer cancel()
+
+	server, serverSocketPath := runFullServer(t)
+	defer server.Stop()
+
+	client, conn := operations.NewOperationClient(t, serverSocketPath)
+	defer conn.Close()
+
+	testRepo, testRepoPath, cleanup := testhelper.NewTestRepo(t)
+	defer cleanup()
+
+	testRepoCopy, _, cleanup := testhelper.NewTestRepo(t)
+	defer cleanup()
+
+	branchSha := getBranchSha(t, testRepoPath, branchName)
+
+	md := testhelper.GitalyServersMetadata(t, serverSocketPath)
+	ctx := metadata.NewOutgoingContext(ctxOuter, md)
+
+	testCases := []struct {
+		desc string
+		req  *gitalypb.UserRebaseConfirmableRequest
+	}{
+		{
+			desc: "empty Repository",
+			req:  buildHeaderRequest(nil, rebaseUser, "1", branchName, branchSha, testRepoCopy, "master"),
+		},
+		{
+			desc: "empty User",
+			req:  buildHeaderRequest(testRepo, nil, "1", branchName, branchSha, testRepoCopy, "master"),
+		},
+		{
+			desc: "empty Branch",
+			req:  buildHeaderRequest(testRepo, rebaseUser, "1", "", branchSha, testRepoCopy, "master"),
+		},
+		{
+			desc: "empty BranchSha",
+			req:  buildHeaderRequest(testRepo, rebaseUser, "1", branchName, "", testRepoCopy, "master"),
+		},
+		{
+			desc: "empty RemoteRepository",
+			req:  buildHeaderRequest(testRepo, rebaseUser, "1", branchName, branchSha, nil, "master"),
+		},
+		{
+			desc: "empty RemoteBranch",
+			req:  buildHeaderRequest(testRepo, rebaseUser, "1", branchName, branchSha, testRepoCopy, ""),
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.desc, func(t *testing.T) {
+			rebaseStream, err := client.UserRebaseConfirmable(ctx)
+			require.NoError(t, err)
+
+			require.NoError(t, rebaseStream.Send(tc.req), "send request header")
+
+			firstResponse, err := rebaseStream.Recv()
+			testhelper.RequireGrpcError(t, err, codes.InvalidArgument)
+			require.Contains(t, err.Error(), tc.desc)
+			require.Empty(t, firstResponse.GetRebaseSha(), "rebase sha on first response")
+		})
+	}
+}
+
+func TestAbortedUserRebaseConfirmable(t *testing.T) {
+	ctxOuter, cancel := testhelper.Context()
+	defer cancel()
+
+	server, serverSocketPath := runFullServer(t)
+	defer server.Stop()
+
+	client, conn := operations.NewOperationClient(t, serverSocketPath)
+	defer conn.Close()
+
+	md := testhelper.GitalyServersMetadata(t, serverSocketPath)
+	ctx := metadata.NewOutgoingContext(ctxOuter, md)
+
+	testCases := []struct {
+		req       *gitalypb.UserRebaseConfirmableRequest
+		closeSend bool
+		desc      string
+		code      codes.Code
+	}{
+		{req: &gitalypb.UserRebaseConfirmableRequest{}, desc: "empty request, don't close", code: codes.FailedPrecondition},
+		{req: &gitalypb.UserRebaseConfirmableRequest{}, closeSend: true, desc: "empty request and close", code: codes.FailedPrecondition},
+		{closeSend: true, desc: "no request just close", code: codes.Internal},
+	}
+
+	for i, tc := range testCases {
+		t.Run(tc.desc, func(t *testing.T) {
+			testRepo, testRepoPath, cleanup := testhelper.NewTestRepo(t)
+			defer cleanup()
+
+			testRepoCopy, _, cleanup := testhelper.NewTestRepo(t)
+			defer cleanup()
+
+			branchSha := getBranchSha(t, testRepoPath, branchName)
+
+			headerRequest := buildHeaderRequest(testRepo, rebaseUser, fmt.Sprintf("%v", i), branchName, branchSha, testRepoCopy, "master")
+
+			rebaseStream, err := client.UserRebaseConfirmable(ctx)
+			require.NoError(t, err)
+
+			require.NoError(t, rebaseStream.Send(headerRequest), "send first request")
+
+			firstResponse, err := rebaseStream.Recv()
+			require.NoError(t, err, "receive first response")
+			require.NotEmpty(t, firstResponse.GetRebaseSha(), "rebase sha on first response")
+
+			if tc.req != nil {
+				require.NoError(t, rebaseStream.Send(tc.req), "send second request")
+			}
+
+			if tc.closeSend {
+				require.NoError(t, rebaseStream.CloseSend(), "close request stream from client")
+			}
+
+			secondResponse, err := recvTimeout(rebaseStream, 1*time.Second)
+			if err == errRecvTimeout {
+				t.Fatal(err)
+			}
+
+			require.False(t, secondResponse.GetRebaseApplied(), "rebase should not have been applied")
+			require.Error(t, err)
+			testhelper.RequireGrpcError(t, err, tc.code)
+
+			newBranchSha := getBranchSha(t, testRepoPath, branchName)
+			require.Equal(t, newBranchSha, branchSha, "branch should not change when the rebase is aborted")
+		})
 	}
+}
+
+func TestFailedUserRebaseConfirmableDueToApplyBeingFalse(t *testing.T) {
+	ctxOuter, cancel := testhelper.Context()
+	defer cancel()
+
+	server, serverSocketPath := runFullServer(t)
+	defer server.Stop()
+
+	client, conn := operations.NewOperationClient(t, serverSocketPath)
+	defer conn.Close()
+
+	testRepo, testRepoPath, cleanup := testhelper.NewTestRepo(t)
+	defer cleanup()
+
+	testRepoCopy, _, cleanup := testhelper.NewTestRepo(t)
+	defer cleanup()
+
+	branchSha := getBranchSha(t, testRepoPath, branchName)
+
+	md := testhelper.GitalyServersMetadata(t, serverSocketPath)
+	ctx := metadata.NewOutgoingContext(ctxOuter, md)
+
+	rebaseStream, err := client.UserRebaseConfirmable(ctx)
+	require.NoError(t, err)
+
+	headerRequest := buildHeaderRequest(testRepo, rebaseUser, "1", branchName, branchSha, testRepoCopy, "master")
+	require.NoError(t, rebaseStream.Send(headerRequest), "send header")
+
+	firstResponse, err := rebaseStream.Recv()
+	require.NoError(t, err, "receive first response")
+
+	_, err = gitlog.GetCommit(ctx, testRepo, firstResponse.GetRebaseSha())
+	require.NoError(t, err, "look up git commit before rebase is applied")
+
+	applyRequest := buildApplyRequest(false)
+	require.NoError(t, rebaseStream.Send(applyRequest), "apply rebase")
+
+	secondResponse, err := rebaseStream.Recv()
+	require.Error(t, err, "second response should have error")
+	testhelper.RequireGrpcError(t, err, codes.FailedPrecondition)
+	require.False(t, secondResponse.GetRebaseApplied(), "the second rebase is not applied")
+
+	newBranchSha := getBranchSha(t, testRepoPath, branchName)
+	require.Equal(t, branchSha, newBranchSha, "branch should not change when the rebase is not applied")
+	require.NotEqual(t, newBranchSha, firstResponse.GetRebaseSha(), "branch should not be the sha returned when the rebase is not applied")
+}
+
+// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
+func TestSuccessfulUserRebaseRequest(t *testing.T) {
+	ctxOuter, cancel := testhelper.Context()
+	defer cancel()
+
+	server, serverSocketPath := runFullServer(t)
+	defer server.Stop()
+
+	client, conn := operations.NewOperationClient(t, serverSocketPath)
+	defer conn.Close()
+
+	testRepo, testRepoPath, cleanup := testhelper.NewTestRepo(t)
+	defer cleanup()
+
+	testRepoCopy, _, cleanup := testhelper.NewTestRepo(t)
+	defer cleanup()
+
+	branchSha := getBranchSha(t, testRepoPath, branchName)
 
 	request := &gitalypb.UserRebaseRequest{
 		Repository:       testRepo,
-		User:             user,
+		User:             rebaseUser,
 		RebaseId:         "1",
 		Branch:           []byte(branchName),
 		BranchSha:        branchSha,
@@ -55,13 +296,13 @@ func TestSuccessfulUserRebaseRequest(t *testing.T) {
 	response, err := client.UserRebase(ctx, request)
 	require.NoError(t, err)
 
-	newBranchSha := string(testhelper.MustRunCommand(t, nil, "git", "-C", testRepoPath, "rev-parse", branchName))
-	newBranchSha = strings.TrimSpace(newBranchSha)
+	newBranchSha := getBranchSha(t, testRepoPath, branchName)
 
 	require.NotEqual(t, newBranchSha, branchSha)
 	require.Equal(t, newBranchSha, response.RebaseSha)
 }
 
+// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
 func TestFailedUserRebaseRequestDueToPreReceiveError(t *testing.T) {
 	ctxOuter, cancel := testhelper.Context()
 	defer cancel()
@@ -78,19 +319,11 @@ func TestFailedUserRebaseRequestDueToPreReceiveError(t *testing.T) {
 	testRepoCopy, _, cleanup := testhelper.NewTestRepo(t)
 	defer cleanup()
 
-	branchName := "many_files"
-	branchSha := string(testhelper.MustRunCommand(t, nil, "git", "-C", testRepoPath, "rev-parse", branchName))
-	branchSha = strings.TrimSpace(branchSha)
-
-	user := &gitalypb.User{
-		Name:  []byte("Ahmad Sherif"),
-		Email: []byte("ahmad@gitlab.com"),
-		GlId:  "user-123",
-	}
+	branchSha := getBranchSha(t, testRepoPath, branchName)
 
 	request := &gitalypb.UserRebaseRequest{
 		Repository:       testRepo,
-		User:             user,
+		User:             rebaseUser,
 		Branch:           []byte(branchName),
 		BranchSha:        branchSha,
 		RemoteRepository: testRepoCopy,
@@ -110,11 +343,12 @@ func TestFailedUserRebaseRequestDueToPreReceiveError(t *testing.T) {
 			request.RebaseId = fmt.Sprintf("%d", i+1)
 			response, err := client.UserRebase(ctx, request)
 			require.NoError(t, err)
-			require.Contains(t, response.PreReceiveError, "GL_ID="+user.GlId)
+			require.Contains(t, response.PreReceiveError, "GL_ID="+rebaseUser.GlId)
 		})
 	}
 }
 
+// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
 func TestFailedUserRebaseRequestDueToGitError(t *testing.T) {
 	ctxOuter, cancel := testhelper.Context()
 	defer cancel()
@@ -131,21 +365,14 @@ func TestFailedUserRebaseRequestDueToGitError(t *testing.T) {
 	testRepoCopy, _, cleanup := testhelper.NewTestRepo(t)
 	defer cleanup()
 
-	branchName := "rebase-encoding-failure-trigger"
-	branchSha := string(testhelper.MustRunCommand(t, nil, "git", "-C", testRepoPath, "rev-parse", branchName))
-	branchSha = strings.TrimSpace(branchSha)
-
-	user := &gitalypb.User{
-		Name:  []byte("Ahmad Sherif"),
-		Email: []byte("ahmad@gitlab.com"),
-		GlId:  "user-123",
-	}
+	failedBranchName := "rebase-encoding-failure-trigger"
+	branchSha := getBranchSha(t, testRepoPath, failedBranchName)
 
 	request := &gitalypb.UserRebaseRequest{
 		Repository:       testRepo,
-		User:             user,
+		User:             rebaseUser,
 		RebaseId:         "1",
-		Branch:           []byte(branchName),
+		Branch:           []byte(failedBranchName),
 		BranchSha:        branchSha,
 		RemoteRepository: testRepoCopy,
 		RemoteBranch:     []byte("master"),
@@ -159,6 +386,7 @@ func TestFailedUserRebaseRequestDueToGitError(t *testing.T) {
 	require.Contains(t, response.GitError, "error: Failed to merge in the changes.")
 }
 
+// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
 func TestFailedUserRebaseRequestDueToValidations(t *testing.T) {
 	ctxOuter, cancel := testhelper.Context()
 	defer cancel()
@@ -175,12 +403,6 @@ func TestFailedUserRebaseRequestDueToValidations(t *testing.T) {
 	testRepoCopy, _, cleanup := testhelper.NewTestRepo(t)
 	defer cleanup()
 
-	user := &gitalypb.User{
-		Name:  []byte("Ahmad Sherif"),
-		Email: []byte("ahmad@gitlab.com"),
-		GlId:  "user-123",
-	}
-
 	testCases := []struct {
 		desc    string
 		request *gitalypb.UserRebaseRequest
@@ -190,7 +412,7 @@ func TestFailedUserRebaseRequestDueToValidations(t *testing.T) {
 			desc: "empty repository",
 			request: &gitalypb.UserRebaseRequest{
 				Repository:       nil,
-				User:             user,
+				User:             rebaseUser,
 				RebaseId:         "1",
 				Branch:           []byte("some-branch"),
 				BranchSha:        "38008cb17ce1466d8fec2dfa6f6ab8dcfe5cf49e",
@@ -216,7 +438,7 @@ func TestFailedUserRebaseRequestDueToValidations(t *testing.T) {
 			desc: "empty rebase id",
 			request: &gitalypb.UserRebaseRequest{
 				Repository:       testRepo,
-				User:             user,
+				User:             rebaseUser,
 				RebaseId:         "",
 				Branch:           []byte("some-branch"),
 				BranchSha:        "38008cb17ce1466d8fec2dfa6f6ab8dcfe5cf49e",
@@ -229,7 +451,7 @@ func TestFailedUserRebaseRequestDueToValidations(t *testing.T) {
 			desc: "empty branch",
 			request: &gitalypb.UserRebaseRequest{
 				Repository:       testRepo,
-				User:             user,
+				User:             rebaseUser,
 				RebaseId:         "1",
 				Branch:           nil,
 				BranchSha:        "38008cb17ce1466d8fec2dfa6f6ab8dcfe5cf49e",
@@ -242,7 +464,7 @@ func TestFailedUserRebaseRequestDueToValidations(t *testing.T) {
 			desc: "empty branch sha",
 			request: &gitalypb.UserRebaseRequest{
 				Repository:       testRepo,
-				User:             user,
+				User:             rebaseUser,
 				RebaseId:         "1",
 				Branch:           []byte("some-branch"),
 				BranchSha:        "",
@@ -255,7 +477,7 @@ func TestFailedUserRebaseRequestDueToValidations(t *testing.T) {
 			desc: "empty remote repository",
 			request: &gitalypb.UserRebaseRequest{
 				Repository:       testRepo,
-				User:             user,
+				User:             rebaseUser,
 				RebaseId:         "1",
 				Branch:           []byte("some-branch"),
 				BranchSha:        "38008cb17ce1466d8fec2dfa6f6ab8dcfe5cf49e",
@@ -268,7 +490,7 @@ func TestFailedUserRebaseRequestDueToValidations(t *testing.T) {
 			desc: "empty remote branch",
 			request: &gitalypb.UserRebaseRequest{
 				Repository:       testRepo,
-				User:             user,
+				User:             rebaseUser,
 				RebaseId:         "1",
 				Branch:           []byte("some-branch"),
 				BranchSha:        "38008cb17ce1466d8fec2dfa6f6ab8dcfe5cf49e",
@@ -289,3 +511,55 @@ func TestFailedUserRebaseRequestDueToValidations(t *testing.T) {
 		})
 	}
 }
+
+func getBranchSha(t *testing.T, repoPath string, branchName string) string {
+	branchSha := string(testhelper.MustRunCommand(t, nil, "git", "-C", repoPath, "rev-parse", branchName))
+	return strings.TrimSpace(branchSha)
+}
+
+// This error is used as a sentinel value
+var errRecvTimeout = errors.New("timeout waiting for response")
+
+func recvTimeout(bidi gitalypb.OperationService_UserRebaseConfirmableClient, timeout time.Duration) (*gitalypb.UserRebaseConfirmableResponse, error) {
+	type responseError struct {
+		response *gitalypb.UserRebaseConfirmableResponse
+		err      error
+	}
+	responseCh := make(chan responseError, 1)
+
+	go func() {
+		resp, err := bidi.Recv()
+		responseCh <- responseError{resp, err}
+	}()
+
+	select {
+	case respErr := <-responseCh:
+		return respErr.response, respErr.err
+	case <-time.After(timeout):
+		return nil, errRecvTimeout
+	}
+}
+
+func buildHeaderRequest(repo *gitalypb.Repository, user *gitalypb.User, rebaseId string, branchName string, branchSha string, remoteRepo *gitalypb.Repository, remoteBranch string) *gitalypb.UserRebaseConfirmableRequest {
+	return &gitalypb.UserRebaseConfirmableRequest{
+		UserRebaseConfirmableRequestPayload: &gitalypb.UserRebaseConfirmableRequest_Header_{
+			&gitalypb.UserRebaseConfirmableRequest_Header{
+				Repository:       repo,
+				User:             user,
+				RebaseId:         rebaseId,
+				Branch:           []byte(branchName),
+				BranchSha:        branchSha,
+				RemoteRepository: remoteRepo,
+				RemoteBranch:     []byte(remoteBranch),
+			},
+		},
+	}
+}
+
+func buildApplyRequest(apply bool) *gitalypb.UserRebaseConfirmableRequest {
+	return &gitalypb.UserRebaseConfirmableRequest{
+		UserRebaseConfirmableRequestPayload: &gitalypb.UserRebaseConfirmableRequest_Apply{
+			Apply: apply,
+		},
+	}
+}
diff --git a/internal/testhelper/stream.go b/internal/testhelper/stream.go
new file mode 100644
index 000000000..7129f7d42
--- /dev/null
+++ b/internal/testhelper/stream.go
@@ -0,0 +1,29 @@
+package testhelper
+
+import (
+	"fmt"
+	"io"
+	"time"
+)
+
+// ReceiveEOFWithTimeout reads to the end of the stream and will throw an
+// error if a deadlock is suspected
+func ReceiveEOFWithTimeout(errorFunc func() error) error {
+	errCh := make(chan error, 1)
+	go func() {
+		errCh <- errorFunc()
+	}()
+
+	var err error
+	select {
+	case err = <-errCh:
+	case <-time.After(1 * time.Second):
+		err = fmt.Errorf("timed out waiting for EOF")
+	}
+
+	if err == io.EOF {
+		err = nil
+	}
+
+	return err
+}
diff --git a/ruby/Gemfile b/ruby/Gemfile
index af7b07384..7e2473502 100644
--- a/ruby/Gemfile
+++ b/ruby/Gemfile
@@ -6,8 +6,8 @@ gem 'bundler', '>= 1.17.3'
 gem 'rugged', '~> 0.28'
 gem 'github-linguist', '~> 6.1', require: 'linguist'
 gem 'gitlab-markup', '~> 1.7.0'
-gem 'gitaly-proto', '~> 1.22.0'
 gem 'activesupport', '~> 5.1.7'
+gem 'gitaly-proto', '~> 1.27.0'
 gem 'rdoc', '~> 4.2'
 gem 'gitlab-gollum-lib', '~> 4.2.7.7', require: false
 gem 'gitlab-gollum-rugged_adapter', '~> 0.4.4.2', require: false
diff --git a/ruby/Gemfile.lock b/ruby/Gemfile.lock
index a5da36d03..280d3c808 100644
--- a/ruby/Gemfile.lock
+++ b/ruby/Gemfile.lock
@@ -36,7 +36,7 @@ GEM
     ffi (1.10.0)
     gemojione (3.3.0)
       json
-    gitaly-proto (1.22.0)
+    gitaly-proto (1.27.0)
       grpc (~> 1.0)
     github-linguist (6.4.1)
       charlock_holmes (~> 0.7.6)
@@ -182,7 +182,7 @@ DEPENDENCIES
   bundler (>= 1.17.3)
   factory_bot
   faraday (~> 0.12)
-  gitaly-proto (~> 1.22.0)
+  gitaly-proto (~> 1.27.0)
   github-linguist (~> 6.1)
   gitlab-gollum-lib (~> 4.2.7.7)
   gitlab-gollum-rugged_adapter (~> 0.4.4.2)
diff --git a/ruby/lib/gitaly_server/operations_service.rb b/ruby/lib/gitaly_server/operations_service.rb
index 64b52f6fb..4a3478419 100644
--- a/ruby/lib/gitaly_server/operations_service.rb
+++ b/ruby/lib/gitaly_server/operations_service.rb
@@ -201,6 +201,40 @@ module GitalyServer
       Gitaly::UserRevertResponse.new(pre_receive_error: set_utf8!(e.message))
     end
 
+    def user_rebase_confirmable(session, call)
+      Enumerator.new do |y|
+        header = session.next.header
+
+        repo = Gitlab::Git::Repository.from_gitaly(header.repository, call)
+        user = Gitlab::Git::User.from_gitaly(header.user)
+        remote_repository = Gitlab::Git::GitalyRemoteRepository.new(header.remote_repository, call)
+
+        begin
+          repo.rebase(
+            user,
+            header.rebase_id,
+            branch: header.branch,
+            branch_sha: header.branch_sha,
+            remote_repository: remote_repository,
+            remote_branch: header.remote_branch
+          ) do |rebase_sha|
+            y << Gitaly::UserRebaseConfirmableResponse.new(rebase_sha: rebase_sha)
+
+            raise GRPC::FailedPrecondition.new('rebase aborted by client') unless session.next.apply
+          end
+
+          y << Gitaly::UserRebaseConfirmableResponse.new(rebase_applied: true)
+        rescue Gitlab::Git::PreReceiveError => e
+          Gitaly::UserRebaseConfirmableResponse.new(pre_receive_error: set_utf8!(e.message))
+        rescue Gitlab::Git::Repository::GitError => e
+          Gitaly::UserRebaseConfirmableResponse.new(git_error: set_utf8!(e.message))
+        rescue Gitlab::Git::CommitError => e
+          raise GRPC::FailedPrecondition.new(e.message)
+        end
+      end
+    end
+
+    # DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
     def user_rebase(request, call)
       repo = Gitlab::Git::Repository.from_gitaly(request.repository, call)
       user = Gitlab::Git::User.from_gitaly(request.user)
diff --git a/ruby/lib/gitlab/git/repository.rb b/ruby/lib/gitlab/git/repository.rb
index 123540ae9..534ad8a99 100644
--- a/ruby/lib/gitlab/git/repository.rb
+++ b/ruby/lib/gitlab/git/repository.rb
@@ -406,6 +406,8 @@ module Gitlab
 
           rebase_sha = run_git!(%w[rev-parse HEAD], chdir: rebase_path, env: env).strip
 
+          yield rebase_sha if block_given?
+
           update_branch(branch, user: user, newrev: rebase_sha, oldrev: branch_sha)
 
           rebase_sha
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/cleanup.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/cleanup.pb.go
index 05dcc5b7c..fd60ab3bf 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/cleanup.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/cleanup.pb.go
@@ -38,7 +38,7 @@ func (m *ApplyBfgObjectMapRequest) Reset()         { *m = ApplyBfgObjectMapReque
 func (m *ApplyBfgObjectMapRequest) String() string { return proto.CompactTextString(m) }
 func (*ApplyBfgObjectMapRequest) ProtoMessage()    {}
 func (*ApplyBfgObjectMapRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cleanup_cc4bfe54b51ce874, []int{0}
+	return fileDescriptor_cleanup_8db38bed7bd810df, []int{0}
 }
 func (m *ApplyBfgObjectMapRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ApplyBfgObjectMapRequest.Unmarshal(m, b)
@@ -82,7 +82,7 @@ func (m *ApplyBfgObjectMapResponse) Reset()         { *m = ApplyBfgObjectMapResp
 func (m *ApplyBfgObjectMapResponse) String() string { return proto.CompactTextString(m) }
 func (*ApplyBfgObjectMapResponse) ProtoMessage()    {}
 func (*ApplyBfgObjectMapResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cleanup_cc4bfe54b51ce874, []int{1}
+	return fileDescriptor_cleanup_8db38bed7bd810df, []int{1}
 }
 func (m *ApplyBfgObjectMapResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ApplyBfgObjectMapResponse.Unmarshal(m, b)
@@ -102,9 +102,226 @@ func (m *ApplyBfgObjectMapResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_ApplyBfgObjectMapResponse proto.InternalMessageInfo
 
+type ApplyBfgObjectMapStreamRequest struct {
+	// Only available on the first message
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
+	// A raw object-map file as generated by BFG: https://rtyley.github.io/bfg-repo-cleaner
+	// Each line in the file has two object SHAs, space-separated - the original
+	// SHA of the object, and the SHA after BFG has rewritten the object.
+	ObjectMap            []byte   `protobuf:"bytes,2,opt,name=object_map,json=objectMap,proto3" json:"object_map,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ApplyBfgObjectMapStreamRequest) Reset()         { *m = ApplyBfgObjectMapStreamRequest{} }
+func (m *ApplyBfgObjectMapStreamRequest) String() string { return proto.CompactTextString(m) }
+func (*ApplyBfgObjectMapStreamRequest) ProtoMessage()    {}
+func (*ApplyBfgObjectMapStreamRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cleanup_8db38bed7bd810df, []int{2}
+}
+func (m *ApplyBfgObjectMapStreamRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ApplyBfgObjectMapStreamRequest.Unmarshal(m, b)
+}
+func (m *ApplyBfgObjectMapStreamRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ApplyBfgObjectMapStreamRequest.Marshal(b, m, deterministic)
+}
+func (dst *ApplyBfgObjectMapStreamRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ApplyBfgObjectMapStreamRequest.Merge(dst, src)
+}
+func (m *ApplyBfgObjectMapStreamRequest) XXX_Size() int {
+	return xxx_messageInfo_ApplyBfgObjectMapStreamRequest.Size(m)
+}
+func (m *ApplyBfgObjectMapStreamRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_ApplyBfgObjectMapStreamRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ApplyBfgObjectMapStreamRequest proto.InternalMessageInfo
+
+func (m *ApplyBfgObjectMapStreamRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *ApplyBfgObjectMapStreamRequest) GetObjectMap() []byte {
+	if m != nil {
+		return m.ObjectMap
+	}
+	return nil
+}
+
+type ApplyBfgObjectMapStreamResponse struct {
+	Entries              []*ApplyBfgObjectMapStreamResponse_Entry `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                                 `json:"-"`
+	XXX_unrecognized     []byte                                   `json:"-"`
+	XXX_sizecache        int32                                    `json:"-"`
+}
+
+func (m *ApplyBfgObjectMapStreamResponse) Reset()         { *m = ApplyBfgObjectMapStreamResponse{} }
+func (m *ApplyBfgObjectMapStreamResponse) String() string { return proto.CompactTextString(m) }
+func (*ApplyBfgObjectMapStreamResponse) ProtoMessage()    {}
+func (*ApplyBfgObjectMapStreamResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cleanup_8db38bed7bd810df, []int{3}
+}
+func (m *ApplyBfgObjectMapStreamResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ApplyBfgObjectMapStreamResponse.Unmarshal(m, b)
+}
+func (m *ApplyBfgObjectMapStreamResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ApplyBfgObjectMapStreamResponse.Marshal(b, m, deterministic)
+}
+func (dst *ApplyBfgObjectMapStreamResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ApplyBfgObjectMapStreamResponse.Merge(dst, src)
+}
+func (m *ApplyBfgObjectMapStreamResponse) XXX_Size() int {
+	return xxx_messageInfo_ApplyBfgObjectMapStreamResponse.Size(m)
+}
+func (m *ApplyBfgObjectMapStreamResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_ApplyBfgObjectMapStreamResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ApplyBfgObjectMapStreamResponse proto.InternalMessageInfo
+
+func (m *ApplyBfgObjectMapStreamResponse) GetEntries() []*ApplyBfgObjectMapStreamResponse_Entry {
+	if m != nil {
+		return m.Entries
+	}
+	return nil
+}
+
+// We send back each parsed entry in the request's object map so the client
+// can take action
+type ApplyBfgObjectMapStreamResponse_Entry struct {
+	Type                 ObjectType `protobuf:"varint,1,opt,name=type,proto3,enum=gitaly.ObjectType" json:"type,omitempty"`
+	OldOid               string     `protobuf:"bytes,2,opt,name=old_oid,json=oldOid,proto3" json:"old_oid,omitempty"`
+	NewOid               string     `protobuf:"bytes,3,opt,name=new_oid,json=newOid,proto3" json:"new_oid,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
+	XXX_unrecognized     []byte     `json:"-"`
+	XXX_sizecache        int32      `json:"-"`
+}
+
+func (m *ApplyBfgObjectMapStreamResponse_Entry) Reset()         { *m = ApplyBfgObjectMapStreamResponse_Entry{} }
+func (m *ApplyBfgObjectMapStreamResponse_Entry) String() string { return proto.CompactTextString(m) }
+func (*ApplyBfgObjectMapStreamResponse_Entry) ProtoMessage()    {}
+func (*ApplyBfgObjectMapStreamResponse_Entry) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cleanup_8db38bed7bd810df, []int{3, 0}
+}
+func (m *ApplyBfgObjectMapStreamResponse_Entry) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ApplyBfgObjectMapStreamResponse_Entry.Unmarshal(m, b)
+}
+func (m *ApplyBfgObjectMapStreamResponse_Entry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ApplyBfgObjectMapStreamResponse_Entry.Marshal(b, m, deterministic)
+}
+func (dst *ApplyBfgObjectMapStreamResponse_Entry) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ApplyBfgObjectMapStreamResponse_Entry.Merge(dst, src)
+}
+func (m *ApplyBfgObjectMapStreamResponse_Entry) XXX_Size() int {
+	return xxx_messageInfo_ApplyBfgObjectMapStreamResponse_Entry.Size(m)
+}
+func (m *ApplyBfgObjectMapStreamResponse_Entry) XXX_DiscardUnknown() {
+	xxx_messageInfo_ApplyBfgObjectMapStreamResponse_Entry.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ApplyBfgObjectMapStreamResponse_Entry proto.InternalMessageInfo
+
+func (m *ApplyBfgObjectMapStreamResponse_Entry) GetType() ObjectType {
+	if m != nil {
+		return m.Type
+	}
+	return ObjectType_UNKNOWN
+}
+
+func (m *ApplyBfgObjectMapStreamResponse_Entry) GetOldOid() string {
+	if m != nil {
+		return m.OldOid
+	}
+	return ""
+}
+
+func (m *ApplyBfgObjectMapStreamResponse_Entry) GetNewOid() string {
+	if m != nil {
+		return m.NewOid
+	}
+	return ""
+}
+
+type CloseSessionRequest struct {
+	SessionId            string   `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *CloseSessionRequest) Reset()         { *m = CloseSessionRequest{} }
+func (m *CloseSessionRequest) String() string { return proto.CompactTextString(m) }
+func (*CloseSessionRequest) ProtoMessage()    {}
+func (*CloseSessionRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cleanup_8db38bed7bd810df, []int{4}
+}
+func (m *CloseSessionRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_CloseSessionRequest.Unmarshal(m, b)
+}
+func (m *CloseSessionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_CloseSessionRequest.Marshal(b, m, deterministic)
+}
+func (dst *CloseSessionRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CloseSessionRequest.Merge(dst, src)
+}
+func (m *CloseSessionRequest) XXX_Size() int {
+	return xxx_messageInfo_CloseSessionRequest.Size(m)
+}
+func (m *CloseSessionRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_CloseSessionRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CloseSessionRequest proto.InternalMessageInfo
+
+func (m *CloseSessionRequest) GetSessionId() string {
+	if m != nil {
+		return m.SessionId
+	}
+	return ""
+}
+
+type CloseSessionResponse struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *CloseSessionResponse) Reset()         { *m = CloseSessionResponse{} }
+func (m *CloseSessionResponse) String() string { return proto.CompactTextString(m) }
+func (*CloseSessionResponse) ProtoMessage()    {}
+func (*CloseSessionResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_cleanup_8db38bed7bd810df, []int{5}
+}
+func (m *CloseSessionResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_CloseSessionResponse.Unmarshal(m, b)
+}
+func (m *CloseSessionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_CloseSessionResponse.Marshal(b, m, deterministic)
+}
+func (dst *CloseSessionResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CloseSessionResponse.Merge(dst, src)
+}
+func (m *CloseSessionResponse) XXX_Size() int {
+	return xxx_messageInfo_CloseSessionResponse.Size(m)
+}
+func (m *CloseSessionResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_CloseSessionResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CloseSessionResponse proto.InternalMessageInfo
+
 func init() {
 	proto.RegisterType((*ApplyBfgObjectMapRequest)(nil), "gitaly.ApplyBfgObjectMapRequest")
 	proto.RegisterType((*ApplyBfgObjectMapResponse)(nil), "gitaly.ApplyBfgObjectMapResponse")
+	proto.RegisterType((*ApplyBfgObjectMapStreamRequest)(nil), "gitaly.ApplyBfgObjectMapStreamRequest")
+	proto.RegisterType((*ApplyBfgObjectMapStreamResponse)(nil), "gitaly.ApplyBfgObjectMapStreamResponse")
+	proto.RegisterType((*ApplyBfgObjectMapStreamResponse_Entry)(nil), "gitaly.ApplyBfgObjectMapStreamResponse.Entry")
+	proto.RegisterType((*CloseSessionRequest)(nil), "gitaly.CloseSessionRequest")
+	proto.RegisterType((*CloseSessionResponse)(nil), "gitaly.CloseSessionResponse")
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -119,7 +336,10 @@ const _ = grpc.SupportPackageIsVersion4
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
 type CleanupServiceClient interface {
+	// Deprecated in favour of ApplyBfgObjectMapStream
 	ApplyBfgObjectMap(ctx context.Context, opts ...grpc.CallOption) (CleanupService_ApplyBfgObjectMapClient, error)
+	ApplyBfgObjectMapStream(ctx context.Context, opts ...grpc.CallOption) (CleanupService_ApplyBfgObjectMapStreamClient, error)
+	CloseSession(ctx context.Context, in *CloseSessionRequest, opts ...grpc.CallOption) (*CloseSessionResponse, error)
 }
 
 type cleanupServiceClient struct {
@@ -164,9 +384,52 @@ func (x *cleanupServiceApplyBfgObjectMapClient) CloseAndRecv() (*ApplyBfgObjectM
 	return m, nil
 }
 
+func (c *cleanupServiceClient) ApplyBfgObjectMapStream(ctx context.Context, opts ...grpc.CallOption) (CleanupService_ApplyBfgObjectMapStreamClient, error) {
+	stream, err := c.cc.NewStream(ctx, &_CleanupService_serviceDesc.Streams[1], "/gitaly.CleanupService/ApplyBfgObjectMapStream", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &cleanupServiceApplyBfgObjectMapStreamClient{stream}
+	return x, nil
+}
+
+type CleanupService_ApplyBfgObjectMapStreamClient interface {
+	Send(*ApplyBfgObjectMapStreamRequest) error
+	Recv() (*ApplyBfgObjectMapStreamResponse, error)
+	grpc.ClientStream
+}
+
+type cleanupServiceApplyBfgObjectMapStreamClient struct {
+	grpc.ClientStream
+}
+
+func (x *cleanupServiceApplyBfgObjectMapStreamClient) Send(m *ApplyBfgObjectMapStreamRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *cleanupServiceApplyBfgObjectMapStreamClient) Recv() (*ApplyBfgObjectMapStreamResponse, error) {
+	m := new(ApplyBfgObjectMapStreamResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *cleanupServiceClient) CloseSession(ctx context.Context, in *CloseSessionRequest, opts ...grpc.CallOption) (*CloseSessionResponse, error) {
+	out := new(CloseSessionResponse)
+	err := c.cc.Invoke(ctx, "/gitaly.CleanupService/CloseSession", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // CleanupServiceServer is the server API for CleanupService service.
 type CleanupServiceServer interface {
+	// Deprecated in favour of ApplyBfgObjectMapStream
 	ApplyBfgObjectMap(CleanupService_ApplyBfgObjectMapServer) error
+	ApplyBfgObjectMapStream(CleanupService_ApplyBfgObjectMapStreamServer) error
+	CloseSession(context.Context, *CloseSessionRequest) (*CloseSessionResponse, error)
 }
 
 func RegisterCleanupServiceServer(s *grpc.Server, srv CleanupServiceServer) {
@@ -199,37 +462,104 @@ func (x *cleanupServiceApplyBfgObjectMapServer) Recv() (*ApplyBfgObjectMapReques
 	return m, nil
 }
 
+func _CleanupService_ApplyBfgObjectMapStream_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(CleanupServiceServer).ApplyBfgObjectMapStream(&cleanupServiceApplyBfgObjectMapStreamServer{stream})
+}
+
+type CleanupService_ApplyBfgObjectMapStreamServer interface {
+	Send(*ApplyBfgObjectMapStreamResponse) error
+	Recv() (*ApplyBfgObjectMapStreamRequest, error)
+	grpc.ServerStream
+}
+
+type cleanupServiceApplyBfgObjectMapStreamServer struct {
+	grpc.ServerStream
+}
+
+func (x *cleanupServiceApplyBfgObjectMapStreamServer) Send(m *ApplyBfgObjectMapStreamResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *cleanupServiceApplyBfgObjectMapStreamServer) Recv() (*ApplyBfgObjectMapStreamRequest, error) {
+	m := new(ApplyBfgObjectMapStreamRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func _CleanupService_CloseSession_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CloseSessionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(CleanupServiceServer).CloseSession(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.CleanupService/CloseSession",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(CleanupServiceServer).CloseSession(ctx, req.(*CloseSessionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _CleanupService_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "gitaly.CleanupService",
 	HandlerType: (*CleanupServiceServer)(nil),
-	Methods:     []grpc.MethodDesc{},
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "CloseSession",
+			Handler:    _CleanupService_CloseSession_Handler,
+		},
+	},
 	Streams: []grpc.StreamDesc{
 		{
 			StreamName:    "ApplyBfgObjectMap",
 			Handler:       _CleanupService_ApplyBfgObjectMap_Handler,
 			ClientStreams: true,
 		},
+		{
+			StreamName:    "ApplyBfgObjectMapStream",
+			Handler:       _CleanupService_ApplyBfgObjectMapStream_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
 	},
 	Metadata: "cleanup.proto",
 }
 
-func init() { proto.RegisterFile("cleanup.proto", fileDescriptor_cleanup_cc4bfe54b51ce874) }
-
-var fileDescriptor_cleanup_cc4bfe54b51ce874 = []byte{
-	// 232 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x4d, 0xce, 0x49, 0x4d,
-	0xcc, 0x2b, 0x2d, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x4b, 0xcf, 0x2c, 0x49, 0xcc,
-	0xa9, 0x94, 0xe2, 0x29, 0xce, 0x48, 0x2c, 0x4a, 0x4d, 0x81, 0x88, 0x2a, 0xe5, 0x72, 0x49, 0x38,
-	0x16, 0x14, 0xe4, 0x54, 0x3a, 0xa5, 0xa5, 0xfb, 0x27, 0x65, 0xa5, 0x26, 0x97, 0xf8, 0x26, 0x16,
-	0x04, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97, 0x08, 0x19, 0x71, 0x71, 0x15, 0xa5, 0x16, 0xe4, 0x17,
-	0x67, 0x96, 0xe4, 0x17, 0x55, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b, 0x09, 0xe9, 0x41, 0x8c,
-	0xd1, 0x0b, 0x82, 0xcb, 0x04, 0x21, 0xa9, 0x12, 0x92, 0xe5, 0xe2, 0xca, 0x07, 0x9b, 0x13, 0x9f,
-	0x9b, 0x58, 0x20, 0xc1, 0xa4, 0xc0, 0xa8, 0xc1, 0x13, 0xc4, 0x99, 0x0f, 0x33, 0x59, 0x49, 0x9a,
-	0x4b, 0x12, 0x8b, 0x75, 0xc5, 0x05, 0xf9, 0x79, 0xc5, 0xa9, 0x46, 0x25, 0x5c, 0x7c, 0xce, 0x10,
-	0x27, 0x07, 0xa7, 0x16, 0x95, 0x65, 0x26, 0xa7, 0x0a, 0x25, 0x71, 0x09, 0x62, 0x28, 0x17, 0x52,
-	0x80, 0x39, 0x01, 0x97, 0xc3, 0xa5, 0x14, 0xf1, 0xa8, 0x80, 0xd8, 0xa5, 0xc4, 0xf6, 0x6b, 0xba,
-	0x06, 0x13, 0x07, 0xa3, 0x06, 0xa3, 0x93, 0x41, 0x14, 0x48, 0x75, 0x4e, 0x62, 0x92, 0x5e, 0x72,
-	0x7e, 0xae, 0x3e, 0x84, 0xa9, 0x9b, 0x5f, 0x94, 0xae, 0x0f, 0x31, 0x43, 0x17, 0x1c, 0x4e, 0xfa,
-	0xe9, 0xf9, 0x50, 0x7e, 0x41, 0x52, 0x12, 0x1b, 0x58, 0xc8, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff,
-	0xb0, 0x11, 0x96, 0xf6, 0x61, 0x01, 0x00, 0x00,
+func init() { proto.RegisterFile("cleanup.proto", fileDescriptor_cleanup_8db38bed7bd810df) }
+
+var fileDescriptor_cleanup_8db38bed7bd810df = []byte{
+	// 421 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x53, 0xd1, 0x6e, 0xd3, 0x30,
+	0x14, 0x95, 0x3b, 0xe8, 0xe8, 0x5d, 0x99, 0x84, 0x41, 0xac, 0x74, 0x0c, 0x4a, 0x1e, 0x46, 0x5e,
+	0x9a, 0x4e, 0x81, 0x1f, 0x60, 0x13, 0x42, 0x3c, 0xa0, 0x0a, 0x97, 0x27, 0x5e, 0x2a, 0x27, 0xbe,
+	0x04, 0xa3, 0x24, 0x36, 0xb6, 0xb7, 0x29, 0x5f, 0xc2, 0xe7, 0xf0, 0x05, 0xfc, 0x10, 0x4f, 0x68,
+	0x76, 0xc2, 0x36, 0xad, 0xa5, 0xbc, 0xec, 0x2d, 0x39, 0xc7, 0xf7, 0x9c, 0x73, 0x8f, 0x13, 0xb8,
+	0x9f, 0x97, 0xc8, 0xeb, 0x53, 0x9d, 0x68, 0xa3, 0x9c, 0xa2, 0xfd, 0x42, 0x3a, 0x5e, 0x36, 0xe3,
+	0xa1, 0xfd, 0xca, 0x0d, 0x8a, 0x80, 0x46, 0x15, 0x8c, 0xde, 0x68, 0x5d, 0x36, 0xc7, 0x5f, 0x8a,
+	0x79, 0xf6, 0x0d, 0x73, 0xf7, 0x81, 0x6b, 0x86, 0xdf, 0x4f, 0xd1, 0x3a, 0x9a, 0x02, 0x18, 0xd4,
+	0xca, 0x4a, 0xa7, 0x4c, 0x33, 0x22, 0x13, 0x12, 0xef, 0xa4, 0x34, 0x09, 0x32, 0x09, 0xfb, 0xcb,
+	0xb0, 0x2b, 0xa7, 0xe8, 0x01, 0x80, 0xf2, 0x3a, 0xcb, 0x8a, 0xeb, 0x51, 0x6f, 0x42, 0xe2, 0x21,
+	0x1b, 0xa8, 0x4e, 0x39, 0xda, 0x87, 0x27, 0x2b, 0xec, 0xac, 0x56, 0xb5, 0xc5, 0xc8, 0xc2, 0xb3,
+	0x1b, 0xe4, 0xc2, 0x19, 0xe4, 0xd5, 0x2d, 0x26, 0xfa, 0x45, 0xe0, 0xf9, 0x5a, 0xd7, 0x10, 0x8c,
+	0xbe, 0x83, 0x6d, 0xac, 0x9d, 0x91, 0x68, 0x47, 0x64, 0xb2, 0x15, 0xef, 0xa4, 0xd3, 0xce, 0x73,
+	0xc3, 0x64, 0xf2, 0xb6, 0x76, 0xa6, 0x61, 0xdd, 0xf4, 0x98, 0xc3, 0x5d, 0x8f, 0xd0, 0x43, 0xb8,
+	0xe3, 0x1a, 0x8d, 0x7e, 0x85, 0xdd, 0xcb, 0x15, 0x82, 0xcc, 0xa7, 0x46, 0x23, 0xf3, 0x3c, 0xdd,
+	0x83, 0x6d, 0x55, 0x8a, 0xa5, 0x92, 0xc2, 0x27, 0x1f, 0xb0, 0xbe, 0x2a, 0xc5, 0x5c, 0x8a, 0x0b,
+	0xa2, 0xc6, 0x73, 0x4f, 0x6c, 0x05, 0xa2, 0xc6, 0xf3, 0xb9, 0x14, 0xd1, 0x6b, 0x78, 0x78, 0x52,
+	0x2a, 0x8b, 0x0b, 0xb4, 0x56, 0xaa, 0xba, 0x6b, 0xee, 0x00, 0xc0, 0x06, 0x64, 0x29, 0x85, 0xb7,
+	0x1d, 0xb0, 0x41, 0x8b, 0xbc, 0x17, 0xd1, 0x63, 0x78, 0x74, 0x7d, 0x2a, 0xe4, 0x4f, 0x7f, 0xf6,
+	0x60, 0xf7, 0x24, 0x7c, 0x46, 0x0b, 0x34, 0x67, 0x32, 0x47, 0x9a, 0xc1, 0x83, 0x1b, 0x5b, 0xd3,
+	0xc9, 0xda, 0x42, 0xda, 0x00, 0xe3, 0x17, 0xff, 0x38, 0xd1, 0xde, 0x7f, 0xff, 0xf7, 0x8f, 0xb8,
+	0x77, 0x8f, 0xc4, 0x84, 0x9e, 0xc1, 0xde, 0x9a, 0x66, 0xe9, 0xe1, 0xc6, 0xea, 0x83, 0xdf, 0xcb,
+	0xff, 0xbc, 0xa2, 0x4b, 0xd7, 0x23, 0x42, 0x3f, 0xc2, 0xf0, 0x6a, 0x0d, 0x74, 0xbf, 0x13, 0x59,
+	0x51, 0xe9, 0xf8, 0xe9, 0x6a, 0xf2, 0xba, 0xec, 0xf1, 0xd1, 0xe7, 0x8b, 0x63, 0x25, 0xcf, 0x92,
+	0x5c, 0x55, 0xb3, 0xf0, 0x38, 0x55, 0xa6, 0x98, 0x85, 0xe1, 0xa9, 0xff, 0x0d, 0x67, 0x85, 0x6a,
+	0xdf, 0x75, 0x96, 0xf5, 0x3d, 0xf4, 0xea, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x9e, 0xad, 0x67,
+	0x57, 0xc0, 0x03, 0x00, 0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/commit.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/commit.pb.go
index 27348d272..b95cc1e97 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/commit.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/commit.pb.go
@@ -24,6 +24,7 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
+// TODO: Replace this enum with ObjectType in shared.proto
 type TreeEntryResponse_ObjectType int32
 
 const (
@@ -50,9 +51,10 @@ func (x TreeEntryResponse_ObjectType) String() string {
 	return proto.EnumName(TreeEntryResponse_ObjectType_name, int32(x))
 }
 func (TreeEntryResponse_ObjectType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{5, 0}
+	return fileDescriptor_commit_85554cca4df16892, []int{5, 0}
 }
 
+// TODO: Replace this enum with ObjectType in shared.proto
 type TreeEntry_EntryType int32
 
 const (
@@ -76,7 +78,7 @@ func (x TreeEntry_EntryType) String() string {
 	return proto.EnumName(TreeEntry_EntryType_name, int32(x))
 }
 func (TreeEntry_EntryType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{12, 0}
+	return fileDescriptor_commit_85554cca4df16892, []int{12, 0}
 }
 
 type FindAllCommitsRequest_Order int32
@@ -102,7 +104,7 @@ func (x FindAllCommitsRequest_Order) String() string {
 	return proto.EnumName(FindAllCommitsRequest_Order_name, int32(x))
 }
 func (FindAllCommitsRequest_Order) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{21, 0}
+	return fileDescriptor_commit_85554cca4df16892, []int{21, 0}
 }
 
 type CommitStatsRequest struct {
@@ -117,7 +119,7 @@ func (m *CommitStatsRequest) Reset()         { *m = CommitStatsRequest{} }
 func (m *CommitStatsRequest) String() string { return proto.CompactTextString(m) }
 func (*CommitStatsRequest) ProtoMessage()    {}
 func (*CommitStatsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{0}
+	return fileDescriptor_commit_85554cca4df16892, []int{0}
 }
 func (m *CommitStatsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitStatsRequest.Unmarshal(m, b)
@@ -165,7 +167,7 @@ func (m *CommitStatsResponse) Reset()         { *m = CommitStatsResponse{} }
 func (m *CommitStatsResponse) String() string { return proto.CompactTextString(m) }
 func (*CommitStatsResponse) ProtoMessage()    {}
 func (*CommitStatsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{1}
+	return fileDescriptor_commit_85554cca4df16892, []int{1}
 }
 func (m *CommitStatsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitStatsResponse.Unmarshal(m, b)
@@ -219,7 +221,7 @@ func (m *CommitIsAncestorRequest) Reset()         { *m = CommitIsAncestorRequest
 func (m *CommitIsAncestorRequest) String() string { return proto.CompactTextString(m) }
 func (*CommitIsAncestorRequest) ProtoMessage()    {}
 func (*CommitIsAncestorRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{2}
+	return fileDescriptor_commit_85554cca4df16892, []int{2}
 }
 func (m *CommitIsAncestorRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitIsAncestorRequest.Unmarshal(m, b)
@@ -271,7 +273,7 @@ func (m *CommitIsAncestorResponse) Reset()         { *m = CommitIsAncestorRespon
 func (m *CommitIsAncestorResponse) String() string { return proto.CompactTextString(m) }
 func (*CommitIsAncestorResponse) ProtoMessage()    {}
 func (*CommitIsAncestorResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{3}
+	return fileDescriptor_commit_85554cca4df16892, []int{3}
 }
 func (m *CommitIsAncestorResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitIsAncestorResponse.Unmarshal(m, b)
@@ -314,7 +316,7 @@ func (m *TreeEntryRequest) Reset()         { *m = TreeEntryRequest{} }
 func (m *TreeEntryRequest) String() string { return proto.CompactTextString(m) }
 func (*TreeEntryRequest) ProtoMessage()    {}
 func (*TreeEntryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{4}
+	return fileDescriptor_commit_85554cca4df16892, []int{4}
 }
 func (m *TreeEntryRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TreeEntryRequest.Unmarshal(m, b)
@@ -380,7 +382,7 @@ func (m *TreeEntryResponse) Reset()         { *m = TreeEntryResponse{} }
 func (m *TreeEntryResponse) String() string { return proto.CompactTextString(m) }
 func (*TreeEntryResponse) ProtoMessage()    {}
 func (*TreeEntryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{5}
+	return fileDescriptor_commit_85554cca4df16892, []int{5}
 }
 func (m *TreeEntryResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TreeEntryResponse.Unmarshal(m, b)
@@ -448,7 +450,7 @@ func (m *CommitsBetweenRequest) Reset()         { *m = CommitsBetweenRequest{} }
 func (m *CommitsBetweenRequest) String() string { return proto.CompactTextString(m) }
 func (*CommitsBetweenRequest) ProtoMessage()    {}
 func (*CommitsBetweenRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{6}
+	return fileDescriptor_commit_85554cca4df16892, []int{6}
 }
 func (m *CommitsBetweenRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitsBetweenRequest.Unmarshal(m, b)
@@ -500,7 +502,7 @@ func (m *CommitsBetweenResponse) Reset()         { *m = CommitsBetweenResponse{}
 func (m *CommitsBetweenResponse) String() string { return proto.CompactTextString(m) }
 func (*CommitsBetweenResponse) ProtoMessage()    {}
 func (*CommitsBetweenResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{7}
+	return fileDescriptor_commit_85554cca4df16892, []int{7}
 }
 func (m *CommitsBetweenResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitsBetweenResponse.Unmarshal(m, b)
@@ -545,7 +547,7 @@ func (m *CountCommitsRequest) Reset()         { *m = CountCommitsRequest{} }
 func (m *CountCommitsRequest) String() string { return proto.CompactTextString(m) }
 func (*CountCommitsRequest) ProtoMessage()    {}
 func (*CountCommitsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{8}
+	return fileDescriptor_commit_85554cca4df16892, []int{8}
 }
 func (m *CountCommitsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CountCommitsRequest.Unmarshal(m, b)
@@ -625,7 +627,7 @@ func (m *CountCommitsResponse) Reset()         { *m = CountCommitsResponse{} }
 func (m *CountCommitsResponse) String() string { return proto.CompactTextString(m) }
 func (*CountCommitsResponse) ProtoMessage()    {}
 func (*CountCommitsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{9}
+	return fileDescriptor_commit_85554cca4df16892, []int{9}
 }
 func (m *CountCommitsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CountCommitsResponse.Unmarshal(m, b)
@@ -666,7 +668,7 @@ func (m *CountDivergingCommitsRequest) Reset()         { *m = CountDivergingComm
 func (m *CountDivergingCommitsRequest) String() string { return proto.CompactTextString(m) }
 func (*CountDivergingCommitsRequest) ProtoMessage()    {}
 func (*CountDivergingCommitsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{10}
+	return fileDescriptor_commit_85554cca4df16892, []int{10}
 }
 func (m *CountDivergingCommitsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CountDivergingCommitsRequest.Unmarshal(m, b)
@@ -726,7 +728,7 @@ func (m *CountDivergingCommitsResponse) Reset()         { *m = CountDivergingCom
 func (m *CountDivergingCommitsResponse) String() string { return proto.CompactTextString(m) }
 func (*CountDivergingCommitsResponse) ProtoMessage()    {}
 func (*CountDivergingCommitsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{11}
+	return fileDescriptor_commit_85554cca4df16892, []int{11}
 }
 func (m *CountDivergingCommitsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CountDivergingCommitsResponse.Unmarshal(m, b)
@@ -783,7 +785,7 @@ func (m *TreeEntry) Reset()         { *m = TreeEntry{} }
 func (m *TreeEntry) String() string { return proto.CompactTextString(m) }
 func (*TreeEntry) ProtoMessage()    {}
 func (*TreeEntry) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{12}
+	return fileDescriptor_commit_85554cca4df16892, []int{12}
 }
 func (m *TreeEntry) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_TreeEntry.Unmarshal(m, b)
@@ -866,7 +868,7 @@ func (m *GetTreeEntriesRequest) Reset()         { *m = GetTreeEntriesRequest{} }
 func (m *GetTreeEntriesRequest) String() string { return proto.CompactTextString(m) }
 func (*GetTreeEntriesRequest) ProtoMessage()    {}
 func (*GetTreeEntriesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{13}
+	return fileDescriptor_commit_85554cca4df16892, []int{13}
 }
 func (m *GetTreeEntriesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetTreeEntriesRequest.Unmarshal(m, b)
@@ -925,7 +927,7 @@ func (m *GetTreeEntriesResponse) Reset()         { *m = GetTreeEntriesResponse{}
 func (m *GetTreeEntriesResponse) String() string { return proto.CompactTextString(m) }
 func (*GetTreeEntriesResponse) ProtoMessage()    {}
 func (*GetTreeEntriesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{14}
+	return fileDescriptor_commit_85554cca4df16892, []int{14}
 }
 func (m *GetTreeEntriesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetTreeEntriesResponse.Unmarshal(m, b)
@@ -964,7 +966,7 @@ func (m *ListFilesRequest) Reset()         { *m = ListFilesRequest{} }
 func (m *ListFilesRequest) String() string { return proto.CompactTextString(m) }
 func (*ListFilesRequest) ProtoMessage()    {}
 func (*ListFilesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{15}
+	return fileDescriptor_commit_85554cca4df16892, []int{15}
 }
 func (m *ListFilesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListFilesRequest.Unmarshal(m, b)
@@ -1011,7 +1013,7 @@ func (m *ListFilesResponse) Reset()         { *m = ListFilesResponse{} }
 func (m *ListFilesResponse) String() string { return proto.CompactTextString(m) }
 func (*ListFilesResponse) ProtoMessage()    {}
 func (*ListFilesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{16}
+	return fileDescriptor_commit_85554cca4df16892, []int{16}
 }
 func (m *ListFilesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListFilesResponse.Unmarshal(m, b)
@@ -1050,7 +1052,7 @@ func (m *FindCommitRequest) Reset()         { *m = FindCommitRequest{} }
 func (m *FindCommitRequest) String() string { return proto.CompactTextString(m) }
 func (*FindCommitRequest) ProtoMessage()    {}
 func (*FindCommitRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{17}
+	return fileDescriptor_commit_85554cca4df16892, []int{17}
 }
 func (m *FindCommitRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindCommitRequest.Unmarshal(m, b)
@@ -1096,7 +1098,7 @@ func (m *FindCommitResponse) Reset()         { *m = FindCommitResponse{} }
 func (m *FindCommitResponse) String() string { return proto.CompactTextString(m) }
 func (*FindCommitResponse) ProtoMessage()    {}
 func (*FindCommitResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{18}
+	return fileDescriptor_commit_85554cca4df16892, []int{18}
 }
 func (m *FindCommitResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindCommitResponse.Unmarshal(m, b)
@@ -1135,7 +1137,7 @@ func (m *ListCommitsByOidRequest) Reset()         { *m = ListCommitsByOidRequest
 func (m *ListCommitsByOidRequest) String() string { return proto.CompactTextString(m) }
 func (*ListCommitsByOidRequest) ProtoMessage()    {}
 func (*ListCommitsByOidRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{19}
+	return fileDescriptor_commit_85554cca4df16892, []int{19}
 }
 func (m *ListCommitsByOidRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListCommitsByOidRequest.Unmarshal(m, b)
@@ -1180,7 +1182,7 @@ func (m *ListCommitsByOidResponse) Reset()         { *m = ListCommitsByOidRespon
 func (m *ListCommitsByOidResponse) String() string { return proto.CompactTextString(m) }
 func (*ListCommitsByOidResponse) ProtoMessage()    {}
 func (*ListCommitsByOidResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{20}
+	return fileDescriptor_commit_85554cca4df16892, []int{20}
 }
 func (m *ListCommitsByOidResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListCommitsByOidResponse.Unmarshal(m, b)
@@ -1223,7 +1225,7 @@ func (m *FindAllCommitsRequest) Reset()         { *m = FindAllCommitsRequest{} }
 func (m *FindAllCommitsRequest) String() string { return proto.CompactTextString(m) }
 func (*FindAllCommitsRequest) ProtoMessage()    {}
 func (*FindAllCommitsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{21}
+	return fileDescriptor_commit_85554cca4df16892, []int{21}
 }
 func (m *FindAllCommitsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindAllCommitsRequest.Unmarshal(m, b)
@@ -1290,7 +1292,7 @@ func (m *FindAllCommitsResponse) Reset()         { *m = FindAllCommitsResponse{}
 func (m *FindAllCommitsResponse) String() string { return proto.CompactTextString(m) }
 func (*FindAllCommitsResponse) ProtoMessage()    {}
 func (*FindAllCommitsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{22}
+	return fileDescriptor_commit_85554cca4df16892, []int{22}
 }
 func (m *FindAllCommitsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindAllCommitsResponse.Unmarshal(m, b)
@@ -1339,7 +1341,7 @@ func (m *FindCommitsRequest) Reset()         { *m = FindCommitsRequest{} }
 func (m *FindCommitsRequest) String() string { return proto.CompactTextString(m) }
 func (*FindCommitsRequest) ProtoMessage()    {}
 func (*FindCommitsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{23}
+	return fileDescriptor_commit_85554cca4df16892, []int{23}
 }
 func (m *FindCommitsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindCommitsRequest.Unmarshal(m, b)
@@ -1448,7 +1450,7 @@ func (m *FindCommitsResponse) Reset()         { *m = FindCommitsResponse{} }
 func (m *FindCommitsResponse) String() string { return proto.CompactTextString(m) }
 func (*FindCommitsResponse) ProtoMessage()    {}
 func (*FindCommitsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{24}
+	return fileDescriptor_commit_85554cca4df16892, []int{24}
 }
 func (m *FindCommitsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FindCommitsResponse.Unmarshal(m, b)
@@ -1487,7 +1489,7 @@ func (m *CommitLanguagesRequest) Reset()         { *m = CommitLanguagesRequest{}
 func (m *CommitLanguagesRequest) String() string { return proto.CompactTextString(m) }
 func (*CommitLanguagesRequest) ProtoMessage()    {}
 func (*CommitLanguagesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{25}
+	return fileDescriptor_commit_85554cca4df16892, []int{25}
 }
 func (m *CommitLanguagesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitLanguagesRequest.Unmarshal(m, b)
@@ -1532,7 +1534,7 @@ func (m *CommitLanguagesResponse) Reset()         { *m = CommitLanguagesResponse
 func (m *CommitLanguagesResponse) String() string { return proto.CompactTextString(m) }
 func (*CommitLanguagesResponse) ProtoMessage()    {}
 func (*CommitLanguagesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{26}
+	return fileDescriptor_commit_85554cca4df16892, []int{26}
 }
 func (m *CommitLanguagesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitLanguagesResponse.Unmarshal(m, b)
@@ -1572,7 +1574,7 @@ func (m *CommitLanguagesResponse_Language) Reset()         { *m = CommitLanguage
 func (m *CommitLanguagesResponse_Language) String() string { return proto.CompactTextString(m) }
 func (*CommitLanguagesResponse_Language) ProtoMessage()    {}
 func (*CommitLanguagesResponse_Language) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{26, 0}
+	return fileDescriptor_commit_85554cca4df16892, []int{26, 0}
 }
 func (m *CommitLanguagesResponse_Language) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitLanguagesResponse_Language.Unmarshal(m, b)
@@ -1626,7 +1628,7 @@ func (m *RawBlameRequest) Reset()         { *m = RawBlameRequest{} }
 func (m *RawBlameRequest) String() string { return proto.CompactTextString(m) }
 func (*RawBlameRequest) ProtoMessage()    {}
 func (*RawBlameRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{27}
+	return fileDescriptor_commit_85554cca4df16892, []int{27}
 }
 func (m *RawBlameRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RawBlameRequest.Unmarshal(m, b)
@@ -1678,7 +1680,7 @@ func (m *RawBlameResponse) Reset()         { *m = RawBlameResponse{} }
 func (m *RawBlameResponse) String() string { return proto.CompactTextString(m) }
 func (*RawBlameResponse) ProtoMessage()    {}
 func (*RawBlameResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{28}
+	return fileDescriptor_commit_85554cca4df16892, []int{28}
 }
 func (m *RawBlameResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RawBlameResponse.Unmarshal(m, b)
@@ -1718,7 +1720,7 @@ func (m *LastCommitForPathRequest) Reset()         { *m = LastCommitForPathReque
 func (m *LastCommitForPathRequest) String() string { return proto.CompactTextString(m) }
 func (*LastCommitForPathRequest) ProtoMessage()    {}
 func (*LastCommitForPathRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{29}
+	return fileDescriptor_commit_85554cca4df16892, []int{29}
 }
 func (m *LastCommitForPathRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_LastCommitForPathRequest.Unmarshal(m, b)
@@ -1771,7 +1773,7 @@ func (m *LastCommitForPathResponse) Reset()         { *m = LastCommitForPathResp
 func (m *LastCommitForPathResponse) String() string { return proto.CompactTextString(m) }
 func (*LastCommitForPathResponse) ProtoMessage()    {}
 func (*LastCommitForPathResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{30}
+	return fileDescriptor_commit_85554cca4df16892, []int{30}
 }
 func (m *LastCommitForPathResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_LastCommitForPathResponse.Unmarshal(m, b)
@@ -1814,7 +1816,7 @@ func (m *ListLastCommitsForTreeRequest) Reset()         { *m = ListLastCommitsFo
 func (m *ListLastCommitsForTreeRequest) String() string { return proto.CompactTextString(m) }
 func (*ListLastCommitsForTreeRequest) ProtoMessage()    {}
 func (*ListLastCommitsForTreeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{31}
+	return fileDescriptor_commit_85554cca4df16892, []int{31}
 }
 func (m *ListLastCommitsForTreeRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListLastCommitsForTreeRequest.Unmarshal(m, b)
@@ -1880,7 +1882,7 @@ func (m *ListLastCommitsForTreeResponse) Reset()         { *m = ListLastCommitsF
 func (m *ListLastCommitsForTreeResponse) String() string { return proto.CompactTextString(m) }
 func (*ListLastCommitsForTreeResponse) ProtoMessage()    {}
 func (*ListLastCommitsForTreeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{32}
+	return fileDescriptor_commit_85554cca4df16892, []int{32}
 }
 func (m *ListLastCommitsForTreeResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListLastCommitsForTreeResponse.Unmarshal(m, b)
@@ -1924,7 +1926,7 @@ func (m *ListLastCommitsForTreeResponse_CommitForTree) String() string {
 }
 func (*ListLastCommitsForTreeResponse_CommitForTree) ProtoMessage() {}
 func (*ListLastCommitsForTreeResponse_CommitForTree) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{32, 0}
+	return fileDescriptor_commit_85554cca4df16892, []int{32, 0}
 }
 func (m *ListLastCommitsForTreeResponse_CommitForTree) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ListLastCommitsForTreeResponse_CommitForTree.Unmarshal(m, b)
@@ -1982,7 +1984,7 @@ func (m *CommitsByMessageRequest) Reset()         { *m = CommitsByMessageRequest
 func (m *CommitsByMessageRequest) String() string { return proto.CompactTextString(m) }
 func (*CommitsByMessageRequest) ProtoMessage()    {}
 func (*CommitsByMessageRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{33}
+	return fileDescriptor_commit_85554cca4df16892, []int{33}
 }
 func (m *CommitsByMessageRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitsByMessageRequest.Unmarshal(m, b)
@@ -2056,7 +2058,7 @@ func (m *CommitsByMessageResponse) Reset()         { *m = CommitsByMessageRespon
 func (m *CommitsByMessageResponse) String() string { return proto.CompactTextString(m) }
 func (*CommitsByMessageResponse) ProtoMessage()    {}
 func (*CommitsByMessageResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{34}
+	return fileDescriptor_commit_85554cca4df16892, []int{34}
 }
 func (m *CommitsByMessageResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitsByMessageResponse.Unmarshal(m, b)
@@ -2095,7 +2097,7 @@ func (m *FilterShasWithSignaturesRequest) Reset()         { *m = FilterShasWithS
 func (m *FilterShasWithSignaturesRequest) String() string { return proto.CompactTextString(m) }
 func (*FilterShasWithSignaturesRequest) ProtoMessage()    {}
 func (*FilterShasWithSignaturesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{35}
+	return fileDescriptor_commit_85554cca4df16892, []int{35}
 }
 func (m *FilterShasWithSignaturesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FilterShasWithSignaturesRequest.Unmarshal(m, b)
@@ -2140,7 +2142,7 @@ func (m *FilterShasWithSignaturesResponse) Reset()         { *m = FilterShasWith
 func (m *FilterShasWithSignaturesResponse) String() string { return proto.CompactTextString(m) }
 func (*FilterShasWithSignaturesResponse) ProtoMessage()    {}
 func (*FilterShasWithSignaturesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{36}
+	return fileDescriptor_commit_85554cca4df16892, []int{36}
 }
 func (m *FilterShasWithSignaturesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_FilterShasWithSignaturesResponse.Unmarshal(m, b)
@@ -2179,7 +2181,7 @@ func (m *ExtractCommitSignatureRequest) Reset()         { *m = ExtractCommitSign
 func (m *ExtractCommitSignatureRequest) String() string { return proto.CompactTextString(m) }
 func (*ExtractCommitSignatureRequest) ProtoMessage()    {}
 func (*ExtractCommitSignatureRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{37}
+	return fileDescriptor_commit_85554cca4df16892, []int{37}
 }
 func (m *ExtractCommitSignatureRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExtractCommitSignatureRequest.Unmarshal(m, b)
@@ -2227,7 +2229,7 @@ func (m *ExtractCommitSignatureResponse) Reset()         { *m = ExtractCommitSig
 func (m *ExtractCommitSignatureResponse) String() string { return proto.CompactTextString(m) }
 func (*ExtractCommitSignatureResponse) ProtoMessage()    {}
 func (*ExtractCommitSignatureResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{38}
+	return fileDescriptor_commit_85554cca4df16892, []int{38}
 }
 func (m *ExtractCommitSignatureResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExtractCommitSignatureResponse.Unmarshal(m, b)
@@ -2273,7 +2275,7 @@ func (m *GetCommitSignaturesRequest) Reset()         { *m = GetCommitSignaturesR
 func (m *GetCommitSignaturesRequest) String() string { return proto.CompactTextString(m) }
 func (*GetCommitSignaturesRequest) ProtoMessage()    {}
 func (*GetCommitSignaturesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{39}
+	return fileDescriptor_commit_85554cca4df16892, []int{39}
 }
 func (m *GetCommitSignaturesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetCommitSignaturesRequest.Unmarshal(m, b)
@@ -2322,7 +2324,7 @@ func (m *GetCommitSignaturesResponse) Reset()         { *m = GetCommitSignatures
 func (m *GetCommitSignaturesResponse) String() string { return proto.CompactTextString(m) }
 func (*GetCommitSignaturesResponse) ProtoMessage()    {}
 func (*GetCommitSignaturesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{40}
+	return fileDescriptor_commit_85554cca4df16892, []int{40}
 }
 func (m *GetCommitSignaturesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetCommitSignaturesResponse.Unmarshal(m, b)
@@ -2375,7 +2377,7 @@ func (m *GetCommitMessagesRequest) Reset()         { *m = GetCommitMessagesReque
 func (m *GetCommitMessagesRequest) String() string { return proto.CompactTextString(m) }
 func (*GetCommitMessagesRequest) ProtoMessage()    {}
 func (*GetCommitMessagesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{41}
+	return fileDescriptor_commit_85554cca4df16892, []int{41}
 }
 func (m *GetCommitMessagesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetCommitMessagesRequest.Unmarshal(m, b)
@@ -2422,7 +2424,7 @@ func (m *GetCommitMessagesResponse) Reset()         { *m = GetCommitMessagesResp
 func (m *GetCommitMessagesResponse) String() string { return proto.CompactTextString(m) }
 func (*GetCommitMessagesResponse) ProtoMessage()    {}
 func (*GetCommitMessagesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_commit_da3ad637b9b57a6c, []int{42}
+	return fileDescriptor_commit_85554cca4df16892, []int{42}
 }
 func (m *GetCommitMessagesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetCommitMessagesResponse.Unmarshal(m, b)
@@ -3631,9 +3633,9 @@ var _CommitService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "commit.proto",
 }
 
-func init() { proto.RegisterFile("commit.proto", fileDescriptor_commit_da3ad637b9b57a6c) }
+func init() { proto.RegisterFile("commit.proto", fileDescriptor_commit_85554cca4df16892) }
 
-var fileDescriptor_commit_da3ad637b9b57a6c = []byte{
+var fileDescriptor_commit_85554cca4df16892 = []byte{
 	// 1942 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x5b, 0x6f, 0xdb, 0xc8,
 	0x15, 0x5e, 0xea, 0xce, 0x23, 0xd5, 0x91, 0x27, 0x37, 0x9a, 0xb6, 0x63, 0x2f, 0x77, 0xb3, 0xf5,
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 5cd97dd4b..e5cfe0f68 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
@@ -55,7 +55,7 @@ func (x UserCommitFilesActionHeader_ActionType) String() string {
 	return proto.EnumName(UserCommitFilesActionHeader_ActionType_name, int32(x))
 }
 func (UserCommitFilesActionHeader_ActionType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{21, 0}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{21, 0}
 }
 
 type UserCreateBranchRequest struct {
@@ -72,7 +72,7 @@ func (m *UserCreateBranchRequest) Reset()         { *m = UserCreateBranchRequest
 func (m *UserCreateBranchRequest) String() string { return proto.CompactTextString(m) }
 func (*UserCreateBranchRequest) ProtoMessage()    {}
 func (*UserCreateBranchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{0}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{0}
 }
 func (m *UserCreateBranchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCreateBranchRequest.Unmarshal(m, b)
@@ -134,7 +134,7 @@ func (m *UserCreateBranchResponse) Reset()         { *m = UserCreateBranchRespon
 func (m *UserCreateBranchResponse) String() string { return proto.CompactTextString(m) }
 func (*UserCreateBranchResponse) ProtoMessage()    {}
 func (*UserCreateBranchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{1}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{1}
 }
 func (m *UserCreateBranchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCreateBranchResponse.Unmarshal(m, b)
@@ -183,7 +183,7 @@ func (m *UserUpdateBranchRequest) Reset()         { *m = UserUpdateBranchRequest
 func (m *UserUpdateBranchRequest) String() string { return proto.CompactTextString(m) }
 func (*UserUpdateBranchRequest) ProtoMessage()    {}
 func (*UserUpdateBranchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{2}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{2}
 }
 func (m *UserUpdateBranchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserUpdateBranchRequest.Unmarshal(m, b)
@@ -249,7 +249,7 @@ func (m *UserUpdateBranchResponse) Reset()         { *m = UserUpdateBranchRespon
 func (m *UserUpdateBranchResponse) String() string { return proto.CompactTextString(m) }
 func (*UserUpdateBranchResponse) ProtoMessage()    {}
 func (*UserUpdateBranchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{3}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{3}
 }
 func (m *UserUpdateBranchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserUpdateBranchResponse.Unmarshal(m, b)
@@ -289,7 +289,7 @@ func (m *UserDeleteBranchRequest) Reset()         { *m = UserDeleteBranchRequest
 func (m *UserDeleteBranchRequest) String() string { return proto.CompactTextString(m) }
 func (*UserDeleteBranchRequest) ProtoMessage()    {}
 func (*UserDeleteBranchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{4}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{4}
 }
 func (m *UserDeleteBranchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserDeleteBranchRequest.Unmarshal(m, b)
@@ -341,7 +341,7 @@ func (m *UserDeleteBranchResponse) Reset()         { *m = UserDeleteBranchRespon
 func (m *UserDeleteBranchResponse) String() string { return proto.CompactTextString(m) }
 func (*UserDeleteBranchResponse) ProtoMessage()    {}
 func (*UserDeleteBranchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{5}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{5}
 }
 func (m *UserDeleteBranchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserDeleteBranchResponse.Unmarshal(m, b)
@@ -381,7 +381,7 @@ func (m *UserDeleteTagRequest) Reset()         { *m = UserDeleteTagRequest{} }
 func (m *UserDeleteTagRequest) String() string { return proto.CompactTextString(m) }
 func (*UserDeleteTagRequest) ProtoMessage()    {}
 func (*UserDeleteTagRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{6}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{6}
 }
 func (m *UserDeleteTagRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserDeleteTagRequest.Unmarshal(m, b)
@@ -433,7 +433,7 @@ func (m *UserDeleteTagResponse) Reset()         { *m = UserDeleteTagResponse{} }
 func (m *UserDeleteTagResponse) String() string { return proto.CompactTextString(m) }
 func (*UserDeleteTagResponse) ProtoMessage()    {}
 func (*UserDeleteTagResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{7}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{7}
 }
 func (m *UserDeleteTagResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserDeleteTagResponse.Unmarshal(m, b)
@@ -475,7 +475,7 @@ func (m *UserCreateTagRequest) Reset()         { *m = UserCreateTagRequest{} }
 func (m *UserCreateTagRequest) String() string { return proto.CompactTextString(m) }
 func (*UserCreateTagRequest) ProtoMessage()    {}
 func (*UserCreateTagRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{8}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{8}
 }
 func (m *UserCreateTagRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCreateTagRequest.Unmarshal(m, b)
@@ -543,7 +543,7 @@ func (m *UserCreateTagResponse) Reset()         { *m = UserCreateTagResponse{} }
 func (m *UserCreateTagResponse) String() string { return proto.CompactTextString(m) }
 func (*UserCreateTagResponse) ProtoMessage()    {}
 func (*UserCreateTagResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{9}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{9}
 }
 func (m *UserCreateTagResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCreateTagResponse.Unmarshal(m, b)
@@ -603,7 +603,7 @@ func (m *UserMergeBranchRequest) Reset()         { *m = UserMergeBranchRequest{}
 func (m *UserMergeBranchRequest) String() string { return proto.CompactTextString(m) }
 func (*UserMergeBranchRequest) ProtoMessage()    {}
 func (*UserMergeBranchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{10}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{10}
 }
 func (m *UserMergeBranchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserMergeBranchRequest.Unmarshal(m, b)
@@ -682,7 +682,7 @@ func (m *UserMergeBranchResponse) Reset()         { *m = UserMergeBranchResponse
 func (m *UserMergeBranchResponse) String() string { return proto.CompactTextString(m) }
 func (*UserMergeBranchResponse) ProtoMessage()    {}
 func (*UserMergeBranchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{11}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{11}
 }
 func (m *UserMergeBranchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserMergeBranchResponse.Unmarshal(m, b)
@@ -745,7 +745,7 @@ func (m *UserMergeToRefRequest) Reset()         { *m = UserMergeToRefRequest{} }
 func (m *UserMergeToRefRequest) String() string { return proto.CompactTextString(m) }
 func (*UserMergeToRefRequest) ProtoMessage()    {}
 func (*UserMergeToRefRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{12}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{12}
 }
 func (m *UserMergeToRefRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserMergeToRefRequest.Unmarshal(m, b)
@@ -819,7 +819,7 @@ func (m *UserMergeToRefResponse) Reset()         { *m = UserMergeToRefResponse{}
 func (m *UserMergeToRefResponse) String() string { return proto.CompactTextString(m) }
 func (*UserMergeToRefResponse) ProtoMessage()    {}
 func (*UserMergeToRefResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{13}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{13}
 }
 func (m *UserMergeToRefResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserMergeToRefResponse.Unmarshal(m, b)
@@ -869,7 +869,7 @@ func (m *OperationBranchUpdate) Reset()         { *m = OperationBranchUpdate{} }
 func (m *OperationBranchUpdate) String() string { return proto.CompactTextString(m) }
 func (*OperationBranchUpdate) ProtoMessage()    {}
 func (*OperationBranchUpdate) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{14}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{14}
 }
 func (m *OperationBranchUpdate) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OperationBranchUpdate.Unmarshal(m, b)
@@ -924,7 +924,7 @@ func (m *UserFFBranchRequest) Reset()         { *m = UserFFBranchRequest{} }
 func (m *UserFFBranchRequest) String() string { return proto.CompactTextString(m) }
 func (*UserFFBranchRequest) ProtoMessage()    {}
 func (*UserFFBranchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{15}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{15}
 }
 func (m *UserFFBranchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserFFBranchRequest.Unmarshal(m, b)
@@ -984,7 +984,7 @@ func (m *UserFFBranchResponse) Reset()         { *m = UserFFBranchResponse{} }
 func (m *UserFFBranchResponse) String() string { return proto.CompactTextString(m) }
 func (*UserFFBranchResponse) ProtoMessage()    {}
 func (*UserFFBranchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{16}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{16}
 }
 func (m *UserFFBranchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserFFBranchResponse.Unmarshal(m, b)
@@ -1035,7 +1035,7 @@ func (m *UserCherryPickRequest) Reset()         { *m = UserCherryPickRequest{} }
 func (m *UserCherryPickRequest) String() string { return proto.CompactTextString(m) }
 func (*UserCherryPickRequest) ProtoMessage()    {}
 func (*UserCherryPickRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{17}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{17}
 }
 func (m *UserCherryPickRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCherryPickRequest.Unmarshal(m, b)
@@ -1118,7 +1118,7 @@ func (m *UserCherryPickResponse) Reset()         { *m = UserCherryPickResponse{}
 func (m *UserCherryPickResponse) String() string { return proto.CompactTextString(m) }
 func (*UserCherryPickResponse) ProtoMessage()    {}
 func (*UserCherryPickResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{18}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{18}
 }
 func (m *UserCherryPickResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCherryPickResponse.Unmarshal(m, b)
@@ -1183,7 +1183,7 @@ func (m *UserRevertRequest) Reset()         { *m = UserRevertRequest{} }
 func (m *UserRevertRequest) String() string { return proto.CompactTextString(m) }
 func (*UserRevertRequest) ProtoMessage()    {}
 func (*UserRevertRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{19}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{19}
 }
 func (m *UserRevertRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserRevertRequest.Unmarshal(m, b)
@@ -1266,7 +1266,7 @@ func (m *UserRevertResponse) Reset()         { *m = UserRevertResponse{} }
 func (m *UserRevertResponse) String() string { return proto.CompactTextString(m) }
 func (*UserRevertResponse) ProtoMessage()    {}
 func (*UserRevertResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{20}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{20}
 }
 func (m *UserRevertResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserRevertResponse.Unmarshal(m, b)
@@ -1333,7 +1333,7 @@ func (m *UserCommitFilesActionHeader) Reset()         { *m = UserCommitFilesActi
 func (m *UserCommitFilesActionHeader) String() string { return proto.CompactTextString(m) }
 func (*UserCommitFilesActionHeader) ProtoMessage()    {}
 func (*UserCommitFilesActionHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{21}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{21}
 }
 func (m *UserCommitFilesActionHeader) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCommitFilesActionHeader.Unmarshal(m, b)
@@ -1409,7 +1409,7 @@ func (m *UserCommitFilesAction) Reset()         { *m = UserCommitFilesAction{} }
 func (m *UserCommitFilesAction) String() string { return proto.CompactTextString(m) }
 func (*UserCommitFilesAction) ProtoMessage()    {}
 func (*UserCommitFilesAction) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{22}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{22}
 }
 func (m *UserCommitFilesAction) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCommitFilesAction.Unmarshal(m, b)
@@ -1555,7 +1555,7 @@ func (m *UserCommitFilesRequestHeader) Reset()         { *m = UserCommitFilesReq
 func (m *UserCommitFilesRequestHeader) String() string { return proto.CompactTextString(m) }
 func (*UserCommitFilesRequestHeader) ProtoMessage()    {}
 func (*UserCommitFilesRequestHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{23}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{23}
 }
 func (m *UserCommitFilesRequestHeader) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCommitFilesRequestHeader.Unmarshal(m, b)
@@ -1652,7 +1652,7 @@ func (m *UserCommitFilesRequest) Reset()         { *m = UserCommitFilesRequest{}
 func (m *UserCommitFilesRequest) String() string { return proto.CompactTextString(m) }
 func (*UserCommitFilesRequest) ProtoMessage()    {}
 func (*UserCommitFilesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{24}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{24}
 }
 func (m *UserCommitFilesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCommitFilesRequest.Unmarshal(m, b)
@@ -1796,7 +1796,7 @@ func (m *UserCommitFilesResponse) Reset()         { *m = UserCommitFilesResponse
 func (m *UserCommitFilesResponse) String() string { return proto.CompactTextString(m) }
 func (*UserCommitFilesResponse) ProtoMessage()    {}
 func (*UserCommitFilesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{25}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{25}
 }
 func (m *UserCommitFilesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserCommitFilesResponse.Unmarshal(m, b)
@@ -1837,6 +1837,9 @@ func (m *UserCommitFilesResponse) GetPreReceiveError() string {
 	return ""
 }
 
+// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
+//
+// Deprecated: Do not use.
 type UserRebaseRequest struct {
 	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
 	User                 *User       `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
@@ -1854,7 +1857,7 @@ func (m *UserRebaseRequest) Reset()         { *m = UserRebaseRequest{} }
 func (m *UserRebaseRequest) String() string { return proto.CompactTextString(m) }
 func (*UserRebaseRequest) ProtoMessage()    {}
 func (*UserRebaseRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{26}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{26}
 }
 func (m *UserRebaseRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserRebaseRequest.Unmarshal(m, b)
@@ -1923,6 +1926,9 @@ func (m *UserRebaseRequest) GetRemoteBranch() []byte {
 	return nil
 }
 
+// DEPRECATED: https://gitlab.com/gitlab-org/gitaly/issues/1628
+//
+// Deprecated: Do not use.
 type UserRebaseResponse struct {
 	RebaseSha            string   `protobuf:"bytes,1,opt,name=rebase_sha,json=rebaseSha,proto3" json:"rebase_sha,omitempty"`
 	PreReceiveError      string   `protobuf:"bytes,2,opt,name=pre_receive_error,json=preReceiveError,proto3" json:"pre_receive_error,omitempty"`
@@ -1936,7 +1942,7 @@ func (m *UserRebaseResponse) Reset()         { *m = UserRebaseResponse{} }
 func (m *UserRebaseResponse) String() string { return proto.CompactTextString(m) }
 func (*UserRebaseResponse) ProtoMessage()    {}
 func (*UserRebaseResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{27}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{27}
 }
 func (m *UserRebaseResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserRebaseResponse.Unmarshal(m, b)
@@ -1977,6 +1983,396 @@ func (m *UserRebaseResponse) GetGitError() string {
 	return ""
 }
 
+type UserRebaseConfirmableRequest struct {
+	// Types that are valid to be assigned to UserRebaseConfirmableRequestPayload:
+	//	*UserRebaseConfirmableRequest_Header_
+	//	*UserRebaseConfirmableRequest_Apply
+	UserRebaseConfirmableRequestPayload isUserRebaseConfirmableRequest_UserRebaseConfirmableRequestPayload `protobuf_oneof:"user_rebase_confirmable_request_payload"`
+	XXX_NoUnkeyedLiteral                struct{}                                                           `json:"-"`
+	XXX_unrecognized                    []byte                                                             `json:"-"`
+	XXX_sizecache                       int32                                                              `json:"-"`
+}
+
+func (m *UserRebaseConfirmableRequest) Reset()         { *m = UserRebaseConfirmableRequest{} }
+func (m *UserRebaseConfirmableRequest) String() string { return proto.CompactTextString(m) }
+func (*UserRebaseConfirmableRequest) ProtoMessage()    {}
+func (*UserRebaseConfirmableRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{28}
+}
+func (m *UserRebaseConfirmableRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UserRebaseConfirmableRequest.Unmarshal(m, b)
+}
+func (m *UserRebaseConfirmableRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UserRebaseConfirmableRequest.Marshal(b, m, deterministic)
+}
+func (dst *UserRebaseConfirmableRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UserRebaseConfirmableRequest.Merge(dst, src)
+}
+func (m *UserRebaseConfirmableRequest) XXX_Size() int {
+	return xxx_messageInfo_UserRebaseConfirmableRequest.Size(m)
+}
+func (m *UserRebaseConfirmableRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_UserRebaseConfirmableRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UserRebaseConfirmableRequest proto.InternalMessageInfo
+
+type isUserRebaseConfirmableRequest_UserRebaseConfirmableRequestPayload interface {
+	isUserRebaseConfirmableRequest_UserRebaseConfirmableRequestPayload()
+}
+
+type UserRebaseConfirmableRequest_Header_ struct {
+	Header *UserRebaseConfirmableRequest_Header `protobuf:"bytes,1,opt,name=header,proto3,oneof"`
+}
+
+type UserRebaseConfirmableRequest_Apply struct {
+	Apply bool `protobuf:"varint,2,opt,name=apply,proto3,oneof"`
+}
+
+func (*UserRebaseConfirmableRequest_Header_) isUserRebaseConfirmableRequest_UserRebaseConfirmableRequestPayload() {
+}
+
+func (*UserRebaseConfirmableRequest_Apply) isUserRebaseConfirmableRequest_UserRebaseConfirmableRequestPayload() {
+}
+
+func (m *UserRebaseConfirmableRequest) GetUserRebaseConfirmableRequestPayload() isUserRebaseConfirmableRequest_UserRebaseConfirmableRequestPayload {
+	if m != nil {
+		return m.UserRebaseConfirmableRequestPayload
+	}
+	return nil
+}
+
+func (m *UserRebaseConfirmableRequest) GetHeader() *UserRebaseConfirmableRequest_Header {
+	if x, ok := m.GetUserRebaseConfirmableRequestPayload().(*UserRebaseConfirmableRequest_Header_); ok {
+		return x.Header
+	}
+	return nil
+}
+
+func (m *UserRebaseConfirmableRequest) GetApply() bool {
+	if x, ok := m.GetUserRebaseConfirmableRequestPayload().(*UserRebaseConfirmableRequest_Apply); ok {
+		return x.Apply
+	}
+	return false
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*UserRebaseConfirmableRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _UserRebaseConfirmableRequest_OneofMarshaler, _UserRebaseConfirmableRequest_OneofUnmarshaler, _UserRebaseConfirmableRequest_OneofSizer, []interface{}{
+		(*UserRebaseConfirmableRequest_Header_)(nil),
+		(*UserRebaseConfirmableRequest_Apply)(nil),
+	}
+}
+
+func _UserRebaseConfirmableRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*UserRebaseConfirmableRequest)
+	// user_rebase_confirmable_request_payload
+	switch x := m.UserRebaseConfirmableRequestPayload.(type) {
+	case *UserRebaseConfirmableRequest_Header_:
+		b.EncodeVarint(1<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Header); err != nil {
+			return err
+		}
+	case *UserRebaseConfirmableRequest_Apply:
+		t := uint64(0)
+		if x.Apply {
+			t = 1
+		}
+		b.EncodeVarint(2<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
+	case nil:
+	default:
+		return fmt.Errorf("UserRebaseConfirmableRequest.UserRebaseConfirmableRequestPayload has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _UserRebaseConfirmableRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*UserRebaseConfirmableRequest)
+	switch tag {
+	case 1: // user_rebase_confirmable_request_payload.header
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(UserRebaseConfirmableRequest_Header)
+		err := b.DecodeMessage(msg)
+		m.UserRebaseConfirmableRequestPayload = &UserRebaseConfirmableRequest_Header_{msg}
+		return true, err
+	case 2: // user_rebase_confirmable_request_payload.apply
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.UserRebaseConfirmableRequestPayload = &UserRebaseConfirmableRequest_Apply{x != 0}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _UserRebaseConfirmableRequest_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*UserRebaseConfirmableRequest)
+	// user_rebase_confirmable_request_payload
+	switch x := m.UserRebaseConfirmableRequestPayload.(type) {
+	case *UserRebaseConfirmableRequest_Header_:
+		s := proto.Size(x.Header)
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *UserRebaseConfirmableRequest_Apply:
+		n += 1 // tag and wire
+		n += 1
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+type UserRebaseConfirmableRequest_Header struct {
+	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
+	User                 *User       `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
+	RebaseId             string      `protobuf:"bytes,3,opt,name=rebase_id,json=rebaseId,proto3" json:"rebase_id,omitempty"`
+	Branch               []byte      `protobuf:"bytes,4,opt,name=branch,proto3" json:"branch,omitempty"`
+	BranchSha            string      `protobuf:"bytes,5,opt,name=branch_sha,json=branchSha,proto3" json:"branch_sha,omitempty"`
+	RemoteRepository     *Repository `protobuf:"bytes,6,opt,name=remote_repository,json=remoteRepository,proto3" json:"remote_repository,omitempty"`
+	RemoteBranch         []byte      `protobuf:"bytes,7,opt,name=remote_branch,json=remoteBranch,proto3" json:"remote_branch,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *UserRebaseConfirmableRequest_Header) Reset()         { *m = UserRebaseConfirmableRequest_Header{} }
+func (m *UserRebaseConfirmableRequest_Header) String() string { return proto.CompactTextString(m) }
+func (*UserRebaseConfirmableRequest_Header) ProtoMessage()    {}
+func (*UserRebaseConfirmableRequest_Header) Descriptor() ([]byte, []int) {
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{28, 0}
+}
+func (m *UserRebaseConfirmableRequest_Header) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UserRebaseConfirmableRequest_Header.Unmarshal(m, b)
+}
+func (m *UserRebaseConfirmableRequest_Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UserRebaseConfirmableRequest_Header.Marshal(b, m, deterministic)
+}
+func (dst *UserRebaseConfirmableRequest_Header) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UserRebaseConfirmableRequest_Header.Merge(dst, src)
+}
+func (m *UserRebaseConfirmableRequest_Header) XXX_Size() int {
+	return xxx_messageInfo_UserRebaseConfirmableRequest_Header.Size(m)
+}
+func (m *UserRebaseConfirmableRequest_Header) XXX_DiscardUnknown() {
+	xxx_messageInfo_UserRebaseConfirmableRequest_Header.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UserRebaseConfirmableRequest_Header proto.InternalMessageInfo
+
+func (m *UserRebaseConfirmableRequest_Header) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *UserRebaseConfirmableRequest_Header) GetUser() *User {
+	if m != nil {
+		return m.User
+	}
+	return nil
+}
+
+func (m *UserRebaseConfirmableRequest_Header) GetRebaseId() string {
+	if m != nil {
+		return m.RebaseId
+	}
+	return ""
+}
+
+func (m *UserRebaseConfirmableRequest_Header) GetBranch() []byte {
+	if m != nil {
+		return m.Branch
+	}
+	return nil
+}
+
+func (m *UserRebaseConfirmableRequest_Header) GetBranchSha() string {
+	if m != nil {
+		return m.BranchSha
+	}
+	return ""
+}
+
+func (m *UserRebaseConfirmableRequest_Header) GetRemoteRepository() *Repository {
+	if m != nil {
+		return m.RemoteRepository
+	}
+	return nil
+}
+
+func (m *UserRebaseConfirmableRequest_Header) GetRemoteBranch() []byte {
+	if m != nil {
+		return m.RemoteBranch
+	}
+	return nil
+}
+
+type UserRebaseConfirmableResponse struct {
+	// Types that are valid to be assigned to UserRebaseConfirmableResponsePayload:
+	//	*UserRebaseConfirmableResponse_RebaseSha
+	//	*UserRebaseConfirmableResponse_RebaseApplied
+	UserRebaseConfirmableResponsePayload isUserRebaseConfirmableResponse_UserRebaseConfirmableResponsePayload `protobuf_oneof:"user_rebase_confirmable_response_payload"`
+	PreReceiveError                      string                                                               `protobuf:"bytes,3,opt,name=pre_receive_error,json=preReceiveError,proto3" json:"pre_receive_error,omitempty"`
+	GitError                             string                                                               `protobuf:"bytes,4,opt,name=git_error,json=gitError,proto3" json:"git_error,omitempty"`
+	XXX_NoUnkeyedLiteral                 struct{}                                                             `json:"-"`
+	XXX_unrecognized                     []byte                                                               `json:"-"`
+	XXX_sizecache                        int32                                                                `json:"-"`
+}
+
+func (m *UserRebaseConfirmableResponse) Reset()         { *m = UserRebaseConfirmableResponse{} }
+func (m *UserRebaseConfirmableResponse) String() string { return proto.CompactTextString(m) }
+func (*UserRebaseConfirmableResponse) ProtoMessage()    {}
+func (*UserRebaseConfirmableResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{29}
+}
+func (m *UserRebaseConfirmableResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_UserRebaseConfirmableResponse.Unmarshal(m, b)
+}
+func (m *UserRebaseConfirmableResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_UserRebaseConfirmableResponse.Marshal(b, m, deterministic)
+}
+func (dst *UserRebaseConfirmableResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UserRebaseConfirmableResponse.Merge(dst, src)
+}
+func (m *UserRebaseConfirmableResponse) XXX_Size() int {
+	return xxx_messageInfo_UserRebaseConfirmableResponse.Size(m)
+}
+func (m *UserRebaseConfirmableResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_UserRebaseConfirmableResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UserRebaseConfirmableResponse proto.InternalMessageInfo
+
+type isUserRebaseConfirmableResponse_UserRebaseConfirmableResponsePayload interface {
+	isUserRebaseConfirmableResponse_UserRebaseConfirmableResponsePayload()
+}
+
+type UserRebaseConfirmableResponse_RebaseSha struct {
+	RebaseSha string `protobuf:"bytes,1,opt,name=rebase_sha,json=rebaseSha,proto3,oneof"`
+}
+
+type UserRebaseConfirmableResponse_RebaseApplied struct {
+	RebaseApplied bool `protobuf:"varint,2,opt,name=rebase_applied,json=rebaseApplied,proto3,oneof"`
+}
+
+func (*UserRebaseConfirmableResponse_RebaseSha) isUserRebaseConfirmableResponse_UserRebaseConfirmableResponsePayload() {
+}
+
+func (*UserRebaseConfirmableResponse_RebaseApplied) isUserRebaseConfirmableResponse_UserRebaseConfirmableResponsePayload() {
+}
+
+func (m *UserRebaseConfirmableResponse) GetUserRebaseConfirmableResponsePayload() isUserRebaseConfirmableResponse_UserRebaseConfirmableResponsePayload {
+	if m != nil {
+		return m.UserRebaseConfirmableResponsePayload
+	}
+	return nil
+}
+
+func (m *UserRebaseConfirmableResponse) GetRebaseSha() string {
+	if x, ok := m.GetUserRebaseConfirmableResponsePayload().(*UserRebaseConfirmableResponse_RebaseSha); ok {
+		return x.RebaseSha
+	}
+	return ""
+}
+
+func (m *UserRebaseConfirmableResponse) GetRebaseApplied() bool {
+	if x, ok := m.GetUserRebaseConfirmableResponsePayload().(*UserRebaseConfirmableResponse_RebaseApplied); ok {
+		return x.RebaseApplied
+	}
+	return false
+}
+
+func (m *UserRebaseConfirmableResponse) GetPreReceiveError() string {
+	if m != nil {
+		return m.PreReceiveError
+	}
+	return ""
+}
+
+func (m *UserRebaseConfirmableResponse) GetGitError() string {
+	if m != nil {
+		return m.GitError
+	}
+	return ""
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*UserRebaseConfirmableResponse) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _UserRebaseConfirmableResponse_OneofMarshaler, _UserRebaseConfirmableResponse_OneofUnmarshaler, _UserRebaseConfirmableResponse_OneofSizer, []interface{}{
+		(*UserRebaseConfirmableResponse_RebaseSha)(nil),
+		(*UserRebaseConfirmableResponse_RebaseApplied)(nil),
+	}
+}
+
+func _UserRebaseConfirmableResponse_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*UserRebaseConfirmableResponse)
+	// user_rebase_confirmable_response_payload
+	switch x := m.UserRebaseConfirmableResponsePayload.(type) {
+	case *UserRebaseConfirmableResponse_RebaseSha:
+		b.EncodeVarint(1<<3 | proto.WireBytes)
+		b.EncodeStringBytes(x.RebaseSha)
+	case *UserRebaseConfirmableResponse_RebaseApplied:
+		t := uint64(0)
+		if x.RebaseApplied {
+			t = 1
+		}
+		b.EncodeVarint(2<<3 | proto.WireVarint)
+		b.EncodeVarint(t)
+	case nil:
+	default:
+		return fmt.Errorf("UserRebaseConfirmableResponse.UserRebaseConfirmableResponsePayload has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _UserRebaseConfirmableResponse_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*UserRebaseConfirmableResponse)
+	switch tag {
+	case 1: // user_rebase_confirmable_response_payload.rebase_sha
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeStringBytes()
+		m.UserRebaseConfirmableResponsePayload = &UserRebaseConfirmableResponse_RebaseSha{x}
+		return true, err
+	case 2: // user_rebase_confirmable_response_payload.rebase_applied
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.UserRebaseConfirmableResponsePayload = &UserRebaseConfirmableResponse_RebaseApplied{x != 0}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _UserRebaseConfirmableResponse_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*UserRebaseConfirmableResponse)
+	// user_rebase_confirmable_response_payload
+	switch x := m.UserRebaseConfirmableResponsePayload.(type) {
+	case *UserRebaseConfirmableResponse_RebaseSha:
+		n += 1 // tag and wire
+		n += proto.SizeVarint(uint64(len(x.RebaseSha)))
+		n += len(x.RebaseSha)
+	case *UserRebaseConfirmableResponse_RebaseApplied:
+		n += 1 // tag and wire
+		n += 1
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
 type UserSquashRequest struct {
 	Repository           *Repository `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
 	User                 *User       `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"`
@@ -1995,7 +2391,7 @@ func (m *UserSquashRequest) Reset()         { *m = UserSquashRequest{} }
 func (m *UserSquashRequest) String() string { return proto.CompactTextString(m) }
 func (*UserSquashRequest) ProtoMessage()    {}
 func (*UserSquashRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{28}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{30}
 }
 func (m *UserSquashRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserSquashRequest.Unmarshal(m, b)
@@ -2083,7 +2479,7 @@ func (m *UserSquashResponse) Reset()         { *m = UserSquashResponse{} }
 func (m *UserSquashResponse) String() string { return proto.CompactTextString(m) }
 func (*UserSquashResponse) ProtoMessage()    {}
 func (*UserSquashResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{29}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{31}
 }
 func (m *UserSquashResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserSquashResponse.Unmarshal(m, b)
@@ -2131,7 +2527,7 @@ func (m *UserApplyPatchRequest) Reset()         { *m = UserApplyPatchRequest{} }
 func (m *UserApplyPatchRequest) String() string { return proto.CompactTextString(m) }
 func (*UserApplyPatchRequest) ProtoMessage()    {}
 func (*UserApplyPatchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{30}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{32}
 }
 func (m *UserApplyPatchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserApplyPatchRequest.Unmarshal(m, b)
@@ -2271,7 +2667,7 @@ func (m *UserApplyPatchRequest_Header) Reset()         { *m = UserApplyPatchRequ
 func (m *UserApplyPatchRequest_Header) String() string { return proto.CompactTextString(m) }
 func (*UserApplyPatchRequest_Header) ProtoMessage()    {}
 func (*UserApplyPatchRequest_Header) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{30, 0}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{32, 0}
 }
 func (m *UserApplyPatchRequest_Header) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserApplyPatchRequest_Header.Unmarshal(m, b)
@@ -2323,7 +2719,7 @@ func (m *UserApplyPatchResponse) Reset()         { *m = UserApplyPatchResponse{}
 func (m *UserApplyPatchResponse) String() string { return proto.CompactTextString(m) }
 func (*UserApplyPatchResponse) ProtoMessage()    {}
 func (*UserApplyPatchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{31}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{33}
 }
 func (m *UserApplyPatchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserApplyPatchResponse.Unmarshal(m, b)
@@ -2366,7 +2762,7 @@ func (m *UserUpdateSubmoduleRequest) Reset()         { *m = UserUpdateSubmoduleR
 func (m *UserUpdateSubmoduleRequest) String() string { return proto.CompactTextString(m) }
 func (*UserUpdateSubmoduleRequest) ProtoMessage()    {}
 func (*UserUpdateSubmoduleRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{32}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{34}
 }
 func (m *UserUpdateSubmoduleRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserUpdateSubmoduleRequest.Unmarshal(m, b)
@@ -2441,7 +2837,7 @@ func (m *UserUpdateSubmoduleResponse) Reset()         { *m = UserUpdateSubmodule
 func (m *UserUpdateSubmoduleResponse) String() string { return proto.CompactTextString(m) }
 func (*UserUpdateSubmoduleResponse) ProtoMessage()    {}
 func (*UserUpdateSubmoduleResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_operations_b6cb0289e68eaeef, []int{33}
+	return fileDescriptor_operations_3ef7b709b3ba32d7, []int{35}
 }
 func (m *UserUpdateSubmoduleResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UserUpdateSubmoduleResponse.Unmarshal(m, b)
@@ -2511,6 +2907,9 @@ func init() {
 	proto.RegisterType((*UserCommitFilesResponse)(nil), "gitaly.UserCommitFilesResponse")
 	proto.RegisterType((*UserRebaseRequest)(nil), "gitaly.UserRebaseRequest")
 	proto.RegisterType((*UserRebaseResponse)(nil), "gitaly.UserRebaseResponse")
+	proto.RegisterType((*UserRebaseConfirmableRequest)(nil), "gitaly.UserRebaseConfirmableRequest")
+	proto.RegisterType((*UserRebaseConfirmableRequest_Header)(nil), "gitaly.UserRebaseConfirmableRequest.Header")
+	proto.RegisterType((*UserRebaseConfirmableResponse)(nil), "gitaly.UserRebaseConfirmableResponse")
 	proto.RegisterType((*UserSquashRequest)(nil), "gitaly.UserSquashRequest")
 	proto.RegisterType((*UserSquashResponse)(nil), "gitaly.UserSquashResponse")
 	proto.RegisterType((*UserApplyPatchRequest)(nil), "gitaly.UserApplyPatchRequest")
@@ -2544,6 +2943,7 @@ type OperationServiceClient interface {
 	UserCherryPick(ctx context.Context, in *UserCherryPickRequest, opts ...grpc.CallOption) (*UserCherryPickResponse, error)
 	UserCommitFiles(ctx context.Context, opts ...grpc.CallOption) (OperationService_UserCommitFilesClient, error)
 	UserRebase(ctx context.Context, in *UserRebaseRequest, opts ...grpc.CallOption) (*UserRebaseResponse, error)
+	UserRebaseConfirmable(ctx context.Context, opts ...grpc.CallOption) (OperationService_UserRebaseConfirmableClient, error)
 	UserRevert(ctx context.Context, in *UserRevertRequest, opts ...grpc.CallOption) (*UserRevertResponse, error)
 	UserSquash(ctx context.Context, in *UserSquashRequest, opts ...grpc.CallOption) (*UserSquashResponse, error)
 	UserApplyPatch(ctx context.Context, opts ...grpc.CallOption) (OperationService_UserApplyPatchClient, error)
@@ -2695,6 +3095,7 @@ func (x *operationServiceUserCommitFilesClient) CloseAndRecv() (*UserCommitFiles
 	return m, nil
 }
 
+// Deprecated: Do not use.
 func (c *operationServiceClient) UserRebase(ctx context.Context, in *UserRebaseRequest, opts ...grpc.CallOption) (*UserRebaseResponse, error) {
 	out := new(UserRebaseResponse)
 	err := c.cc.Invoke(ctx, "/gitaly.OperationService/UserRebase", in, out, opts...)
@@ -2704,6 +3105,37 @@ func (c *operationServiceClient) UserRebase(ctx context.Context, in *UserRebaseR
 	return out, nil
 }
 
+func (c *operationServiceClient) UserRebaseConfirmable(ctx context.Context, opts ...grpc.CallOption) (OperationService_UserRebaseConfirmableClient, error) {
+	stream, err := c.cc.NewStream(ctx, &_OperationService_serviceDesc.Streams[2], "/gitaly.OperationService/UserRebaseConfirmable", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &operationServiceUserRebaseConfirmableClient{stream}
+	return x, nil
+}
+
+type OperationService_UserRebaseConfirmableClient interface {
+	Send(*UserRebaseConfirmableRequest) error
+	Recv() (*UserRebaseConfirmableResponse, error)
+	grpc.ClientStream
+}
+
+type operationServiceUserRebaseConfirmableClient struct {
+	grpc.ClientStream
+}
+
+func (x *operationServiceUserRebaseConfirmableClient) Send(m *UserRebaseConfirmableRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *operationServiceUserRebaseConfirmableClient) Recv() (*UserRebaseConfirmableResponse, error) {
+	m := new(UserRebaseConfirmableResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 func (c *operationServiceClient) UserRevert(ctx context.Context, in *UserRevertRequest, opts ...grpc.CallOption) (*UserRevertResponse, error) {
 	out := new(UserRevertResponse)
 	err := c.cc.Invoke(ctx, "/gitaly.OperationService/UserRevert", in, out, opts...)
@@ -2723,7 +3155,7 @@ func (c *operationServiceClient) UserSquash(ctx context.Context, in *UserSquashR
 }
 
 func (c *operationServiceClient) UserApplyPatch(ctx context.Context, opts ...grpc.CallOption) (OperationService_UserApplyPatchClient, error) {
-	stream, err := c.cc.NewStream(ctx, &_OperationService_serviceDesc.Streams[2], "/gitaly.OperationService/UserApplyPatch", opts...)
+	stream, err := c.cc.NewStream(ctx, &_OperationService_serviceDesc.Streams[3], "/gitaly.OperationService/UserApplyPatch", opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -2778,6 +3210,7 @@ type OperationServiceServer interface {
 	UserCherryPick(context.Context, *UserCherryPickRequest) (*UserCherryPickResponse, error)
 	UserCommitFiles(OperationService_UserCommitFilesServer) error
 	UserRebase(context.Context, *UserRebaseRequest) (*UserRebaseResponse, error)
+	UserRebaseConfirmable(OperationService_UserRebaseConfirmableServer) error
 	UserRevert(context.Context, *UserRevertRequest) (*UserRevertResponse, error)
 	UserSquash(context.Context, *UserSquashRequest) (*UserSquashResponse, error)
 	UserApplyPatch(OperationService_UserApplyPatchServer) error
@@ -3002,6 +3435,32 @@ func _OperationService_UserRebase_Handler(srv interface{}, ctx context.Context,
 	return interceptor(ctx, in, info, handler)
 }
 
+func _OperationService_UserRebaseConfirmable_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(OperationServiceServer).UserRebaseConfirmable(&operationServiceUserRebaseConfirmableServer{stream})
+}
+
+type OperationService_UserRebaseConfirmableServer interface {
+	Send(*UserRebaseConfirmableResponse) error
+	Recv() (*UserRebaseConfirmableRequest, error)
+	grpc.ServerStream
+}
+
+type operationServiceUserRebaseConfirmableServer struct {
+	grpc.ServerStream
+}
+
+func (x *operationServiceUserRebaseConfirmableServer) Send(m *UserRebaseConfirmableResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *operationServiceUserRebaseConfirmableServer) Recv() (*UserRebaseConfirmableRequest, error) {
+	m := new(UserRebaseConfirmableRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 func _OperationService_UserRevert_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(UserRevertRequest)
 	if err := dec(in); err != nil {
@@ -3148,6 +3607,12 @@ var _OperationService_serviceDesc = grpc.ServiceDesc{
 			ClientStreams: true,
 		},
 		{
+			StreamName:    "UserRebaseConfirmable",
+			Handler:       _OperationService_UserRebaseConfirmable_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
+		{
 			StreamName:    "UserApplyPatch",
 			Handler:       _OperationService_UserApplyPatch_Handler,
 			ClientStreams: true,
@@ -3156,125 +3621,135 @@ var _OperationService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "operations.proto",
 }
 
-func init() { proto.RegisterFile("operations.proto", fileDescriptor_operations_b6cb0289e68eaeef) }
-
-var fileDescriptor_operations_b6cb0289e68eaeef = []byte{
-	// 1863 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcd, 0x6f, 0x2b, 0x49,
-	0x11, 0xcf, 0xd8, 0xce, 0xc4, 0xa9, 0x38, 0x89, 0xd3, 0xfb, 0xe5, 0xf5, 0x4b, 0x48, 0x76, 0xb2,
-	0x0b, 0xd9, 0x15, 0xeb, 0xb7, 0x0a, 0x08, 0x4e, 0x0b, 0xca, 0x87, 0x43, 0x76, 0x21, 0xbc, 0x30,
-	0x49, 0x40, 0xa0, 0x85, 0xd1, 0xc4, 0xee, 0xd8, 0x23, 0x6c, 0xcf, 0x6c, 0xcf, 0x38, 0xbc, 0x20,
-	0xc4, 0x05, 0x09, 0xae, 0x9c, 0xe0, 0x80, 0x90, 0x40, 0xdc, 0x10, 0x17, 0x2e, 0x1c, 0x38, 0x20,
-	0x8e, 0xc0, 0x75, 0x0f, 0x9c, 0xf8, 0x17, 0xb8, 0x71, 0xe1, 0x84, 0xba, 0xab, 0x66, 0x3c, 0x3d,
-	0x33, 0xb6, 0x92, 0x25, 0xd1, 0x7b, 0x42, 0xdc, 0xdc, 0xd5, 0x35, 0xd5, 0x55, 0xbf, 0xaa, 0xae,
-	0xaa, 0x2e, 0x43, 0xdd, 0x0f, 0xb8, 0x70, 0x23, 0xcf, 0x1f, 0x85, 0xad, 0x40, 0xf8, 0x91, 0xcf,
-	0xcc, 0x9e, 0x17, 0xb9, 0x83, 0x9b, 0x66, 0x2d, 0xec, 0xbb, 0x82, 0x77, 0x91, 0x6a, 0xfd, 0xde,
-	0x80, 0x57, 0x2e, 0x42, 0x2e, 0x0e, 0x04, 0x77, 0x23, 0xbe, 0x2f, 0xdc, 0x51, 0xa7, 0x6f, 0xf3,
-	0x0f, 0xc7, 0x3c, 0x8c, 0xd8, 0x2e, 0x80, 0xe0, 0x81, 0x1f, 0x7a, 0x91, 0x2f, 0x6e, 0x1a, 0xc6,
-	0x96, 0xb1, 0xb3, 0xb4, 0xcb, 0x5a, 0x28, 0xa6, 0x65, 0x27, 0x3b, 0x76, 0x8a, 0x8b, 0x6d, 0xc2,
-	0xd2, 0xa5, 0x12, 0xe2, 0x8c, 0xdc, 0x21, 0x6f, 0x94, 0xb6, 0x8c, 0x9d, 0x9a, 0x0d, 0x48, 0xfa,
-	0xaa, 0x3b, 0xe4, 0x6c, 0x0b, 0x2a, 0xe3, 0x90, 0x8b, 0x46, 0x59, 0x89, 0xab, 0xc5, 0xe2, 0xa4,
-	0x0e, 0xb6, 0xda, 0x91, 0x22, 0xc2, 0xc8, 0x15, 0x91, 0x13, 0xf8, 0xde, 0x28, 0x6a, 0x54, 0x50,
-	0x84, 0x22, 0x9d, 0x4a, 0x8a, 0x35, 0x82, 0x46, 0x5e, 0xe5, 0x30, 0xf0, 0x47, 0x21, 0x67, 0x9f,
-	0x04, 0x13, 0x0f, 0x23, 0x7d, 0x57, 0xe2, 0x03, 0x88, 0x8f, 0x76, 0xd9, 0x5b, 0xb0, 0x16, 0x08,
-	0xee, 0x08, 0xde, 0xe1, 0xde, 0x35, 0x77, 0xb8, 0x10, 0xbe, 0x50, 0xda, 0x2e, 0xda, 0xab, 0x81,
-	0xe0, 0x36, 0xd2, 0xdb, 0x92, 0x6c, 0xfd, 0x99, 0x30, 0xba, 0x08, 0xba, 0xcf, 0x0b, 0x46, 0x2f,
-	0x83, 0x39, 0xe2, 0xdf, 0x13, 0xfc, 0x9a, 0xe0, 0xa1, 0x95, 0xa4, 0xfb, 0x83, 0xae, 0xa4, 0xcf,
-	0x23, 0x1d, 0x57, 0xd6, 0x11, 0x42, 0xa6, 0x5b, 0x40, 0x90, 0x15, 0x42, 0x61, 0x14, 0x43, 0xf1,
-	0x53, 0x82, 0xe2, 0x90, 0x0f, 0xf8, 0xf3, 0x01, 0x45, 0x6c, 0x9a, 0xae, 0xd1, 0xc7, 0x30, 0xed,
-	0x27, 0x06, 0xbc, 0x38, 0x11, 0x74, 0xee, 0xf6, 0xfe, 0x1b, 0xbb, 0x5e, 0x85, 0x6a, 0xe4, 0xf6,
-	0xd2, 0x46, 0x2d, 0x44, 0x6e, 0xef, 0x96, 0x16, 0x1d, 0xc0, 0x4b, 0x19, 0x45, 0x3e, 0x86, 0x39,
-	0x7f, 0x23, 0x73, 0xf0, 0x96, 0x3c, 0x43, 0x73, 0xd8, 0xa7, 0x60, 0x35, 0x72, 0x45, 0x8f, 0x47,
-	0x8e, 0xe0, 0xd7, 0x5e, 0xe8, 0xf9, 0x23, 0x0a, 0xda, 0x15, 0x24, 0xdb, 0x44, 0x65, 0x0d, 0x58,
-	0x18, 0xf2, 0x30, 0x74, 0x7b, 0x9c, 0xa2, 0x37, 0x5e, 0x5a, 0xdf, 0x47, 0x44, 0x52, 0xb6, 0x10,
-	0x22, 0x1b, 0x50, 0x8e, 0xdc, 0x1e, 0x59, 0xb1, 0x14, 0x1f, 0x2e, 0x39, 0x24, 0x5d, 0x5e, 0x07,
-	0xfe, 0xd4, 0x0b, 0xa3, 0x50, 0x69, 0x5d, 0xb5, 0x69, 0x55, 0x0c, 0x64, 0xb9, 0x18, 0xc8, 0x8f,
-	0x0c, 0x78, 0x59, 0x1e, 0x7e, 0xc2, 0x45, 0xef, 0x1e, 0x22, 0x3e, 0xc6, 0xab, 0x34, 0x15, 0xaf,
-	0x47, 0xb0, 0xd8, 0xf1, 0x87, 0x43, 0x2f, 0x72, 0xbc, 0x2e, 0x29, 0x55, 0x45, 0xc2, 0x7b, 0x5d,
-	0x69, 0x11, 0xe5, 0x37, 0xba, 0xf8, 0x94, 0xcf, 0xa6, 0x62, 0xc7, 0x5e, 0x84, 0x79, 0x37, 0x08,
-	0x06, 0x37, 0x0d, 0x53, 0x41, 0x80, 0x0b, 0xeb, 0x77, 0x74, 0x91, 0x35, 0xab, 0x08, 0x54, 0x4d,
-	0x01, 0x23, 0xa3, 0xc0, 0x3e, 0x2c, 0xd3, 0x8d, 0x1d, 0xab, 0x64, 0x42, 0x8e, 0xdf, 0x88, 0x0d,
-	0x79, 0x12, 0xd7, 0x1d, 0x14, 0x8a, 0x19, 0xc7, 0xae, 0x5d, 0xa6, 0x56, 0xc5, 0xf0, 0x57, 0x0a,
-	0xe1, 0x7f, 0xbf, 0x52, 0x2d, 0xd5, 0xcb, 0xd6, 0x3f, 0x0c, 0x8c, 0x00, 0xa5, 0xee, 0xb9, 0x6f,
-	0xf3, 0xab, 0x87, 0xf5, 0xc1, 0x06, 0x40, 0xe8, 0x8f, 0x45, 0x87, 0x3b, 0x61, 0xdf, 0x25, 0x27,
-	0x2c, 0x22, 0xe5, 0xac, 0xef, 0x4e, 0xf5, 0xc2, 0x06, 0x40, 0x12, 0xea, 0x57, 0xe4, 0x88, 0xc5,
-	0x38, 0xca, 0xaf, 0xd2, 0x4e, 0x32, 0xf5, 0x00, 0x77, 0x53, 0x31, 0x46, 0xe6, 0xdd, 0xc6, 0x19,
-	0x77, 0xa9, 0x62, 0x3f, 0x84, 0x97, 0x0a, 0x7d, 0x33, 0xfb, 0x84, 0xd7, 0xa0, 0x26, 0x81, 0x73,
-	0x3a, 0xea, 0xea, 0x75, 0xe9, 0x1e, 0x2d, 0x49, 0x1a, 0xde, 0xc6, 0x2e, 0x7b, 0x03, 0x56, 0x28,
-	0x22, 0x62, 0xa6, 0xb2, 0x62, 0xa2, 0x38, 0x21, 0x36, 0xeb, 0x57, 0x06, 0xbc, 0x20, 0x6d, 0x3c,
-	0x3a, 0x7a, 0x5e, 0x2f, 0x91, 0xf5, 0x63, 0xca, 0x99, 0x13, 0x15, 0xc9, 0x09, 0xb9, 0xa0, 0x37,
-	0xee, 0x29, 0xe8, 0xa7, 0xf8, 0xea, 0x4f, 0x25, 0x4a, 0x78, 0x7d, 0x2e, 0xc4, 0xcd, 0xa9, 0xd7,
-	0xf9, 0xee, 0xc3, 0xa2, 0xf5, 0x26, 0x98, 0x08, 0x0e, 0xdd, 0xe6, 0xb5, 0x98, 0xe7, 0x4b, 0x5e,
-	0x74, 0xa0, 0x36, 0x6c, 0x62, 0xc8, 0x56, 0xec, 0x4a, 0xae, 0x62, 0x4f, 0xcf, 0x44, 0x6f, 0xc1,
-	0x1a, 0x36, 0x76, 0x69, 0x01, 0x78, 0x11, 0x56, 0xd5, 0xc6, 0xfe, 0x44, 0xca, 0xbb, 0x50, 0x47,
-	0xde, 0x94, 0xb5, 0x0b, 0x53, 0xad, 0xc5, 0xcf, 0x27, 0x04, 0xeb, 0xef, 0x94, 0xb4, 0xd3, 0x00,
-	0xde, 0xaf, 0x2f, 0x31, 0xd6, 0x9d, 0x48, 0xf0, 0x8c, 0x2f, 0x71, 0xe3, 0x5c, 0x70, 0xf4, 0xa5,
-	0xbc, 0x41, 0x14, 0x89, 0xe9, 0x32, 0xb3, 0x84, 0x34, 0x64, 0xb9, 0x43, 0x3e, 0xb4, 0xfe, 0x58,
-	0x82, 0x35, 0xe5, 0x39, 0x7e, 0xcd, 0xa5, 0xc9, 0xff, 0x0f, 0x8b, 0x3b, 0x84, 0xc5, 0x47, 0x06,
-	0xb0, 0x34, 0x78, 0xff, 0x1b, 0x21, 0xf1, 0xaf, 0x12, 0x3c, 0x52, 0xc1, 0xae, 0xbe, 0x3f, 0xf2,
-	0x06, 0x3c, 0xdc, 0xeb, 0x48, 0x75, 0x8f, 0xb9, 0xdb, 0xe5, 0x82, 0x1d, 0x81, 0xe9, 0xaa, 0xb5,
-	0xb2, 0x6b, 0x65, 0xb7, 0x95, 0x76, 0xf5, 0x94, 0x8f, 0x5a, 0xb8, 0x38, 0xbf, 0x09, 0xb8, 0x4d,
-	0x5f, 0xcb, 0x9c, 0x7a, 0xe5, 0x0d, 0xb8, 0x13, 0xb8, 0x51, 0x9f, 0xda, 0xc0, 0xaa, 0x24, 0x9c,
-	0xba, 0x51, 0x9f, 0x6d, 0xc3, 0x72, 0x20, 0xfb, 0x3b, 0x7f, 0x1c, 0x22, 0x43, 0x59, 0x31, 0xd4,
-	0x62, 0xa2, 0x62, 0x92, 0xa5, 0xc2, 0x0d, 0xf9, 0xe7, 0x3e, 0xeb, 0x74, 0xfc, 0x51, 0xc4, 0xe9,
-	0x75, 0x27, 0x4b, 0x85, 0xa2, 0x1e, 0x20, 0x91, 0xbd, 0x09, 0x75, 0xfe, 0x94, 0x77, 0xc6, 0x11,
-	0x77, 0xa4, 0xfc, 0xa1, 0xdf, 0xc5, 0xa0, 0xa9, 0xda, 0xab, 0x44, 0x3f, 0x22, 0xb2, 0x3c, 0xd6,
-	0x1b, 0x5d, 0x71, 0x91, 0x08, 0xc4, 0x2e, 0xa7, 0xa6, 0x88, 0x24, 0xcf, 0xba, 0x00, 0x98, 0x98,
-	0xc3, 0x00, 0xcc, 0x03, 0xbb, 0xbd, 0x77, 0xde, 0xae, 0xcf, 0xb1, 0x15, 0x00, 0xfc, 0xed, 0x1c,
-	0xbe, 0x67, 0xd7, 0x0d, 0xb9, 0x77, 0x71, 0x7a, 0x28, 0xf7, 0x4a, 0xac, 0x0a, 0x95, 0x93, 0x27,
-	0x5f, 0x6f, 0xd7, 0xcb, 0x92, 0x7a, 0xd8, 0xfe, 0x4a, 0xfb, 0xbc, 0x5d, 0xaf, 0xb0, 0x45, 0x98,
-	0x3f, 0x38, 0x3e, 0x79, 0x72, 0x58, 0x9f, 0xb7, 0x7e, 0x46, 0x4d, 0x49, 0x0e, 0x42, 0xf6, 0x2e,
-	0x98, 0x7d, 0x05, 0x23, 0x45, 0xd2, 0xf6, 0x2d, 0x10, 0x3f, 0x9e, 0xb3, 0xe9, 0x23, 0xd6, 0x84,
-	0x85, 0xd8, 0x1c, 0x05, 0xf3, 0xf1, 0x9c, 0x1d, 0x13, 0xf6, 0x2d, 0xd8, 0x92, 0x77, 0xd3, 0xa1,
-	0x00, 0x92, 0xf8, 0x84, 0x0e, 0x3a, 0xc8, 0x09, 0xdc, 0x9b, 0x81, 0xef, 0x76, 0xad, 0x5f, 0x94,
-	0x61, 0x3d, 0x73, 0x12, 0x25, 0x0a, 0x8a, 0x88, 0x87, 0x49, 0x17, 0x99, 0x1c, 0x50, 0xce, 0xe5,
-	0x80, 0x37, 0x60, 0x85, 0xd4, 0x8e, 0x53, 0x01, 0xe6, 0x89, 0x65, 0xa4, 0x9e, 0x50, 0x42, 0xf8,
-	0x34, 0x30, 0x62, 0x73, 0xc7, 0x51, 0xdf, 0x17, 0x28, 0x0e, 0xb3, 0x46, 0x1d, 0x77, 0xf6, 0xd4,
-	0x86, 0x12, 0xda, 0x82, 0x17, 0x74, 0x6e, 0x3e, 0x74, 0xbd, 0x01, 0x25, 0x90, 0xb5, 0x34, 0x7b,
-	0x5b, 0x6e, 0x14, 0xa7, 0x9b, 0x85, 0xdb, 0xa7, 0x9b, 0xea, 0xad, 0xd3, 0x8d, 0x6c, 0xbd, 0xaf,
-	0x7c, 0xd1, 0xe1, 0x8d, 0x45, 0x6c, 0xbd, 0xd5, 0xc2, 0xfa, 0x43, 0x5c, 0x9b, 0x72, 0xde, 0x61,
-	0x5f, 0xc8, 0xc4, 0xcd, 0xeb, 0x53, 0xe2, 0x46, 0xf3, 0x66, 0x2a, 0x70, 0x3e, 0x9f, 0xdc, 0xf4,
-	0x92, 0x9e, 0xc1, 0x8a, 0xe3, 0x6e, 0x2e, 0xbe, 0xda, 0xfb, 0xdb, 0xf0, 0x5a, 0x3e, 0xaa, 0x04,
-	0x9e, 0x92, 0x84, 0xd5, 0x6f, 0xe3, 0x59, 0x51, 0x5a, 0x91, 0x7b, 0x4c, 0xa1, 0x9b, 0xb0, 0xe4,
-	0x8d, 0xba, 0xfc, 0xa9, 0x96, 0x3c, 0x41, 0x91, 0x66, 0x24, 0xc5, 0x29, 0xcf, 0xb6, 0xdf, 0x24,
-	0x75, 0x52, 0xe6, 0x96, 0x07, 0x6f, 0x36, 0x85, 0x3a, 0x26, 0xd5, 0x6c, 0x22, 0x61, 0xc6, 0x8b,
-	0x6d, 0x03, 0xe8, 0x6a, 0xa8, 0x27, 0xc6, 0x3c, 0x3e, 0x31, 0x90, 0x22, 0x9f, 0x18, 0x5f, 0x84,
-	0x35, 0xc1, 0x87, 0x7e, 0xc4, 0xd3, 0xb1, 0x67, 0x4e, 0x55, 0xb8, 0x8e, 0xcc, 0xa9, 0xe0, 0xdb,
-	0x86, 0x65, 0x12, 0x40, 0xc7, 0x63, 0x8c, 0xd7, 0x90, 0x88, 0x6e, 0xb0, 0x7e, 0x10, 0xd7, 0x43,
-	0x04, 0x29, 0x79, 0x55, 0x03, 0xd9, 0x23, 0x55, 0xc3, 0x27, 0x01, 0x59, 0x28, 0x55, 0xbb, 0x43,
-	0x27, 0x2b, 0xa1, 0xe9, 0x65, 0xea, 0x5c, 0xb5, 0x47, 0x45, 0xce, 0xfa, 0x35, 0xf9, 0xe8, 0xec,
-	0xc3, 0xb1, 0x1b, 0x3e, 0xfc, 0x83, 0x20, 0x54, 0xc7, 0xa4, 0x7c, 0x84, 0x84, 0x19, 0x3e, 0x92,
-	0x1f, 0xa9, 0xfb, 0x3f, 0x71, 0x51, 0x55, 0x11, 0x24, 0x0c, 0xaf, 0xc0, 0x02, 0x1f, 0x75, 0xd5,
-	0x96, 0xa9, 0xb6, 0x4c, 0x3e, 0xea, 0xca, 0x8d, 0xd7, 0xc1, 0xc4, 0x54, 0x44, 0xad, 0x89, 0xae,
-	0x0e, 0xed, 0x15, 0x24, 0xc3, 0x6a, 0x41, 0x32, 0xb4, 0x3c, 0xf4, 0x50, 0x0c, 0xd1, 0xc4, 0x43,
-	0x64, 0x4d, 0xca, 0x43, 0x48, 0x91, 0x1a, 0xcc, 0x42, 0x1d, 0x5f, 0xd4, 0x76, 0xde, 0x85, 0xd6,
-	0x2f, 0xe9, 0xd5, 0xb1, 0x17, 0x04, 0x83, 0x9b, 0x53, 0x37, 0x9a, 0xbc, 0xd1, 0x66, 0xe6, 0xa5,
-	0x1c, 0x7b, 0xab, 0xa8, 0xa0, 0x05, 0x92, 0x81, 0x87, 0x93, 0x82, 0x46, 0x84, 0xe6, 0x8f, 0x0c,
-	0x30, 0x1f, 0xb4, 0x2c, 0x6d, 0xc3, 0x32, 0x3d, 0xca, 0xc9, 0xc7, 0xd4, 0x99, 0x20, 0x11, 0x2f,
-	0x42, 0x52, 0x56, 0xd5, 0x74, 0xc4, 0x51, 0xba, 0xe5, 0xf2, 0xdf, 0x07, 0x98, 0xb7, 0xd3, 0xf6,
-	0xde, 0x5f, 0xf6, 0xb3, 0xfe, 0x69, 0x40, 0x73, 0x32, 0xa3, 0x3d, 0x1b, 0x5f, 0x0e, 0xfd, 0xee,
-	0x78, 0xc0, 0x1f, 0x7c, 0xce, 0x41, 0x41, 0x98, 0x9a, 0x73, 0x20, 0x65, 0xd6, 0x9c, 0x63, 0x1d,
-	0x16, 0xc3, 0x58, 0xc1, 0x78, 0xcc, 0x91, 0x10, 0x0a, 0x22, 0xdb, 0x2c, 0x8a, 0xec, 0xbf, 0x1a,
-	0xd8, 0xb6, 0xe6, 0x0c, 0x7e, 0x36, 0x8f, 0xee, 0x5c, 0x57, 0x5e, 0xc9, 0x75, 0xe5, 0xef, 0x57,
-	0xaa, 0xe5, 0x7a, 0xc5, 0xce, 0x37, 0xfa, 0xbb, 0x7f, 0x01, 0xa8, 0x27, 0xfa, 0x9c, 0x71, 0x71,
-	0xed, 0x75, 0x38, 0xfb, 0x36, 0xd4, 0xb3, 0xff, 0x53, 0xb0, 0x4d, 0xad, 0x22, 0xe7, 0xff, 0x74,
-	0x69, 0x6e, 0x4d, 0x67, 0x40, 0x5c, 0x2c, 0xf3, 0xdf, 0x3f, 0xdf, 0x29, 0x55, 0x8d, 0x58, 0x7c,
-	0x7a, 0xa6, 0xaf, 0x8b, 0x2f, 0xf8, 0xbf, 0x42, 0x17, 0x5f, 0xf4, 0x77, 0x40, 0x56, 0x7c, 0x7a,
-	0xae, 0xae, 0x8b, 0x2f, 0xf8, 0x0f, 0x40, 0x17, 0x5f, 0x34, 0x92, 0x4f, 0xc4, 0x9f, 0xc3, 0xb2,
-	0x36, 0xd2, 0x65, 0xeb, 0x79, 0xc3, 0x27, 0x53, 0xeb, 0xe6, 0xc6, 0x94, 0xdd, 0x62, 0xa9, 0xc9,
-	0xe8, 0x5c, 0x97, 0x9a, 0x1d, 0xed, 0xeb, 0x52, 0x73, 0xf3, 0xf6, 0x44, 0xea, 0x37, 0x60, 0x45,
-	0x9f, 0xce, 0x31, 0xed, 0xc3, 0xdc, 0x50, 0xb2, 0xf9, 0x89, 0x69, 0xdb, 0x19, 0xc1, 0xdf, 0x81,
-	0xd5, 0xcc, 0x10, 0x96, 0xe5, 0x3f, 0xd5, 0x11, 0xde, 0x9c, 0xba, 0xaf, 0xcb, 0xde, 0x31, 0xde,
-	0x31, 0xd8, 0xd7, 0xa0, 0x96, 0x9e, 0x67, 0xb1, 0x47, 0xe9, 0x8f, 0x33, 0x83, 0xb8, 0xe6, 0x7a,
-	0xf1, 0x66, 0x31, 0x16, 0x93, 0xc1, 0x8a, 0x8e, 0x45, 0x6e, 0x62, 0xa5, 0x63, 0x91, 0x9f, 0xc7,
-	0x24, 0x82, 0x3f, 0x40, 0x2c, 0x52, 0xcd, 0xa5, 0x8e, 0x45, 0xbe, 0xfd, 0xd5, 0xb1, 0x28, 0xe8,
-	0x4a, 0x27, 0x58, 0xb0, 0x2f, 0x03, 0x4c, 0x1a, 0x1d, 0xf6, 0xaa, 0x96, 0x0a, 0xd3, 0x1d, 0x62,
-	0xb3, 0x59, 0xb4, 0x95, 0x51, 0x35, 0x11, 0x76, 0xcd, 0x45, 0x94, 0x15, 0x96, 0x1a, 0xcb, 0x64,
-	0x85, 0xa5, 0x87, 0x0e, 0x59, 0x61, 0x58, 0xe0, 0x75, 0x61, 0x5a, 0x5f, 0xa4, 0x0b, 0xd3, 0xfb,
-	0x81, 0x44, 0xd8, 0x37, 0xd1, 0x3b, 0x93, 0x12, 0xa5, 0x7b, 0x27, 0x57, 0xaa, 0x75, 0xef, 0xe4,
-	0x2b, 0x5b, 0x0a, 0xc1, 0x2b, 0x1c, 0xdf, 0x66, 0xb2, 0x35, 0xb3, 0xf2, 0x09, 0x25, 0x5b, 0xbb,
-	0x9a, 0xdb, 0x33, 0x79, 0xf4, 0x93, 0xf6, 0xdf, 0xf9, 0x96, 0xe4, 0x1e, 0xb8, 0x97, 0xad, 0x8e,
-	0x3f, 0x7c, 0x8c, 0x3f, 0xdf, 0xf6, 0x45, 0xef, 0x31, 0xca, 0x78, 0x5b, 0xfd, 0x6f, 0xfd, 0xb8,
-	0xe7, 0xd3, 0x3a, 0xb8, 0xbc, 0x34, 0x15, 0xe9, 0x33, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x49,
-	0x6d, 0xa5, 0xd3, 0xf4, 0x1e, 0x00, 0x00,
+func init() { proto.RegisterFile("operations.proto", fileDescriptor_operations_3ef7b709b3ba32d7) }
+
+var fileDescriptor_operations_3ef7b709b3ba32d7 = []byte{
+	// 2019 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0xcf, 0x6f, 0x23, 0x49,
+	0x15, 0x4e, 0xdb, 0x9e, 0x8e, 0xf3, 0xe2, 0x24, 0x4e, 0xed, 0xee, 0xac, 0xd7, 0x33, 0x21, 0xd9,
+	0xce, 0x0c, 0x93, 0x19, 0x58, 0xcf, 0x6a, 0x40, 0x20, 0x21, 0x2d, 0x68, 0x92, 0x38, 0x64, 0x17,
+	0x66, 0x27, 0xf4, 0x64, 0x40, 0xa0, 0x85, 0x56, 0xc7, 0xae, 0xd8, 0x2d, 0x6c, 0x77, 0x6f, 0x75,
+	0x3b, 0x4c, 0x38, 0x20, 0x24, 0x24, 0xe0, 0xc8, 0x09, 0x90, 0x10, 0x12, 0x9c, 0x90, 0x10, 0x17,
+	0x2e, 0x1c, 0x90, 0x40, 0x48, 0x9c, 0xe0, 0xba, 0x07, 0x4e, 0xf0, 0x27, 0x70, 0xe3, 0xc2, 0x09,
+	0x55, 0xbd, 0xd7, 0xed, 0xae, 0xfe, 0x11, 0x92, 0x25, 0xd1, 0x0e, 0x88, 0x9b, 0xfb, 0xd5, 0xeb,
+	0xd7, 0xef, 0x7d, 0xef, 0xab, 0x57, 0xaf, 0xaa, 0x0c, 0x4d, 0x3f, 0xe0, 0xc2, 0x8d, 0x3c, 0x7f,
+	0x12, 0x76, 0x02, 0xe1, 0x47, 0x3e, 0x33, 0x07, 0x5e, 0xe4, 0x8e, 0x4e, 0xdb, 0x8d, 0x70, 0xe8,
+	0x0a, 0xde, 0x47, 0xa9, 0xf5, 0x6b, 0x03, 0x5e, 0x7e, 0x1a, 0x72, 0xb1, 0x23, 0xb8, 0x1b, 0xf1,
+	0x6d, 0xe1, 0x4e, 0x7a, 0x43, 0x9b, 0xbf, 0x3b, 0xe5, 0x61, 0xc4, 0x1e, 0x00, 0x08, 0x1e, 0xf8,
+	0xa1, 0x17, 0xf9, 0xe2, 0xb4, 0x65, 0x6c, 0x18, 0x5b, 0x8b, 0x0f, 0x58, 0x07, 0xcd, 0x74, 0xec,
+	0x64, 0xc4, 0x4e, 0x69, 0xb1, 0x75, 0x58, 0x3c, 0x52, 0x46, 0x9c, 0x89, 0x3b, 0xe6, 0xad, 0xca,
+	0x86, 0xb1, 0xd5, 0xb0, 0x01, 0x45, 0x6f, 0xbb, 0x63, 0xce, 0x36, 0xa0, 0x36, 0x0d, 0xb9, 0x68,
+	0x55, 0x95, 0xb9, 0x46, 0x6c, 0x4e, 0xfa, 0x60, 0xab, 0x11, 0x69, 0x22, 0x8c, 0x5c, 0x11, 0x39,
+	0x81, 0xef, 0x4d, 0xa2, 0x56, 0x0d, 0x4d, 0x28, 0xd1, 0x81, 0x94, 0x58, 0x13, 0x68, 0xe5, 0x5d,
+	0x0e, 0x03, 0x7f, 0x12, 0x72, 0xf6, 0x61, 0x30, 0xf1, 0x63, 0xe4, 0xef, 0x72, 0xfc, 0x01, 0xd2,
+	0xa3, 0x51, 0x76, 0x0f, 0x56, 0x03, 0xc1, 0x1d, 0xc1, 0x7b, 0xdc, 0x3b, 0xe1, 0x0e, 0x17, 0xc2,
+	0x17, 0xca, 0xdb, 0x05, 0x7b, 0x25, 0x10, 0xdc, 0x46, 0x79, 0x57, 0x8a, 0xad, 0x3f, 0x10, 0x46,
+	0x4f, 0x83, 0xfe, 0xf3, 0x82, 0xd1, 0x75, 0x30, 0x27, 0xfc, 0x1b, 0x82, 0x9f, 0x10, 0x3c, 0xf4,
+	0x24, 0xe5, 0xfe, 0xa8, 0x2f, 0xe5, 0xd7, 0x50, 0x8e, 0x4f, 0xd6, 0x1e, 0x42, 0xa6, 0x47, 0x40,
+	0x90, 0x15, 0x42, 0x61, 0x14, 0x43, 0xf1, 0x03, 0x82, 0x62, 0x97, 0x8f, 0xf8, 0xf3, 0x01, 0x45,
+	0x1c, 0x9a, 0xee, 0xd1, 0xfb, 0x08, 0xed, 0x7b, 0x06, 0xbc, 0x38, 0x33, 0x74, 0xe8, 0x0e, 0xfe,
+	0x93, 0xb8, 0x5e, 0x81, 0x7a, 0xe4, 0x0e, 0xd2, 0x41, 0xcd, 0x47, 0xee, 0xe0, 0x9c, 0x11, 0xed,
+	0xc0, 0x4b, 0x19, 0x47, 0xde, 0x47, 0x38, 0x7f, 0xa6, 0x70, 0x70, 0x96, 0x7c, 0x80, 0xe1, 0xb0,
+	0x3b, 0xb0, 0x12, 0xb9, 0x62, 0xc0, 0x23, 0x47, 0xf0, 0x13, 0x2f, 0xf4, 0xfc, 0x09, 0x91, 0x76,
+	0x19, 0xc5, 0x36, 0x49, 0x59, 0x0b, 0xe6, 0xc7, 0x3c, 0x0c, 0xdd, 0x01, 0x27, 0xf6, 0xc6, 0x8f,
+	0xd6, 0x37, 0x11, 0x91, 0x54, 0x2c, 0x84, 0xc8, 0x1a, 0x54, 0x23, 0x77, 0x40, 0x51, 0x2c, 0xc6,
+	0x1f, 0x97, 0x1a, 0x52, 0x2e, 0xa7, 0x03, 0x7f, 0xe6, 0x85, 0x51, 0xa8, 0xbc, 0xae, 0xdb, 0xf4,
+	0x54, 0x0c, 0x64, 0xb5, 0x18, 0xc8, 0xf7, 0x0c, 0xb8, 0x2e, 0x3f, 0xfe, 0x88, 0x8b, 0xc1, 0x25,
+	0x30, 0x3e, 0xc6, 0xab, 0x52, 0x8a, 0xd7, 0x0d, 0x58, 0xe8, 0xf9, 0xe3, 0xb1, 0x17, 0x39, 0x5e,
+	0x9f, 0x9c, 0xaa, 0xa3, 0xe0, 0xcd, 0xbe, 0x8c, 0x88, 0xea, 0x1b, 0x4d, 0x7c, 0xaa, 0x67, 0xa5,
+	0xd8, 0xb1, 0x17, 0xe1, 0x9a, 0x1b, 0x04, 0xa3, 0xd3, 0x96, 0xa9, 0x20, 0xc0, 0x07, 0xeb, 0x57,
+	0x34, 0x91, 0xb5, 0xa8, 0x08, 0x54, 0xcd, 0x01, 0x23, 0xe3, 0xc0, 0x36, 0x2c, 0xd1, 0x8c, 0x9d,
+	0xaa, 0x62, 0x42, 0x89, 0x5f, 0x8b, 0x03, 0x79, 0x1c, 0xaf, 0x3b, 0x68, 0x14, 0x2b, 0x8e, 0xdd,
+	0x38, 0x4a, 0x3d, 0x15, 0xc3, 0x5f, 0x2b, 0x84, 0xff, 0xad, 0x5a, 0xbd, 0xd2, 0xac, 0x5a, 0x7f,
+	0x35, 0x90, 0x01, 0xca, 0xdd, 0x43, 0xdf, 0xe6, 0xc7, 0x57, 0x9b, 0x83, 0x35, 0x80, 0xd0, 0x9f,
+	0x8a, 0x1e, 0x77, 0xc2, 0xa1, 0x4b, 0x49, 0x58, 0x40, 0xc9, 0x93, 0xa1, 0x5b, 0x9a, 0x85, 0x35,
+	0x80, 0x84, 0xea, 0xc7, 0x94, 0x88, 0x85, 0x98, 0xe5, 0xc7, 0xe9, 0x24, 0x99, 0x3a, 0xc1, 0xdd,
+	0x14, 0xc7, 0x28, 0xbc, 0xf3, 0x24, 0xe3, 0x22, 0xab, 0xd8, 0xb7, 0xe0, 0xa5, 0xc2, 0xdc, 0x9c,
+	0xfd, 0x85, 0x57, 0xa1, 0x21, 0x81, 0x73, 0x7a, 0x6a, 0xea, 0xf5, 0x69, 0x1e, 0x2d, 0x4a, 0x19,
+	0xce, 0xc6, 0x3e, 0xbb, 0x0d, 0xcb, 0xc4, 0x88, 0x58, 0xa9, 0xaa, 0x94, 0x88, 0x27, 0xa4, 0x66,
+	0xfd, 0xcc, 0x80, 0x17, 0x64, 0x8c, 0x7b, 0x7b, 0xcf, 0xeb, 0x24, 0xb2, 0xbe, 0x4b, 0x35, 0x73,
+	0xe6, 0x22, 0x25, 0x21, 0x47, 0x7a, 0xe3, 0x92, 0x48, 0x5f, 0x92, 0xab, 0xdf, 0x57, 0xa8, 0xe0,
+	0x0d, 0xb9, 0x10, 0xa7, 0x07, 0x5e, 0xef, 0xeb, 0x57, 0x8b, 0xd6, 0x5d, 0x30, 0x11, 0x1c, 0x9a,
+	0xcd, 0xab, 0xb1, 0xce, 0x67, 0xbd, 0x68, 0x47, 0x0d, 0xd8, 0xa4, 0x90, 0x5d, 0xb1, 0x6b, 0xb9,
+	0x15, 0xbb, 0xbc, 0x12, 0xdd, 0x83, 0x55, 0x6c, 0xec, 0xd2, 0x06, 0x70, 0x22, 0xac, 0xa8, 0x81,
+	0xed, 0x99, 0x95, 0x37, 0xa0, 0x89, 0xba, 0xa9, 0x68, 0xe7, 0x4b, 0xa3, 0xc5, 0xd7, 0x67, 0x02,
+	0xeb, 0x2f, 0x54, 0xb4, 0xd3, 0x00, 0x5e, 0x6e, 0x2e, 0x91, 0xeb, 0x4e, 0x24, 0x78, 0x26, 0x97,
+	0x38, 0x70, 0x28, 0x38, 0xe6, 0x52, 0xce, 0x20, 0x62, 0x62, 0x7a, 0x99, 0x59, 0x44, 0x19, 0xaa,
+	0x5c, 0xa0, 0x1e, 0x5a, 0xbf, 0xad, 0xc0, 0xaa, 0xca, 0x1c, 0x3f, 0xe1, 0x32, 0xe4, 0xff, 0xd3,
+	0xe2, 0x02, 0xb4, 0x78, 0xcf, 0x00, 0x96, 0x06, 0xef, 0x7f, 0x83, 0x12, 0xff, 0xa8, 0xc0, 0x0d,
+	0x45, 0x76, 0xf5, 0xfe, 0x9e, 0x37, 0xe2, 0xe1, 0xc3, 0x9e, 0x74, 0x77, 0x9f, 0xbb, 0x7d, 0x2e,
+	0xd8, 0x1e, 0x98, 0xae, 0x7a, 0x56, 0x71, 0x2d, 0x3f, 0xe8, 0xa4, 0x53, 0x5d, 0xf2, 0x52, 0x07,
+	0x1f, 0x0e, 0x4f, 0x03, 0x6e, 0xd3, 0xdb, 0xb2, 0xa6, 0x1e, 0x7b, 0x23, 0xee, 0x04, 0x6e, 0x34,
+	0xa4, 0x36, 0xb0, 0x2e, 0x05, 0x07, 0x6e, 0x34, 0x64, 0x9b, 0xb0, 0x14, 0xc8, 0xfe, 0xce, 0x9f,
+	0x86, 0xa8, 0x50, 0x55, 0x0a, 0x8d, 0x58, 0xa8, 0x94, 0xe4, 0x52, 0xe1, 0x86, 0xfc, 0x13, 0x1f,
+	0x77, 0x7a, 0xfe, 0x24, 0xe2, 0xb4, 0xbb, 0x93, 0x4b, 0x85, 0x92, 0xee, 0xa0, 0x90, 0xdd, 0x85,
+	0x26, 0x7f, 0xc6, 0x7b, 0xd3, 0x88, 0x3b, 0xd2, 0xfe, 0xd8, 0xef, 0x23, 0x69, 0xea, 0xf6, 0x0a,
+	0xc9, 0xf7, 0x48, 0x2c, 0x3f, 0xeb, 0x4d, 0x8e, 0xb9, 0x48, 0x0c, 0x62, 0x97, 0xd3, 0x50, 0x42,
+	0xb2, 0x67, 0x3d, 0x05, 0x98, 0x85, 0xc3, 0x00, 0xcc, 0x1d, 0xbb, 0xfb, 0xf0, 0xb0, 0xdb, 0x9c,
+	0x63, 0xcb, 0x00, 0xf8, 0xdb, 0xd9, 0x7d, 0xd3, 0x6e, 0x1a, 0x72, 0xec, 0xe9, 0xc1, 0xae, 0x1c,
+	0xab, 0xb0, 0x3a, 0xd4, 0x1e, 0x3d, 0xfe, 0x62, 0xb7, 0x59, 0x95, 0xd2, 0xdd, 0xee, 0xe7, 0xbb,
+	0x87, 0xdd, 0x66, 0x8d, 0x2d, 0xc0, 0xb5, 0x9d, 0xfd, 0x47, 0x8f, 0x77, 0x9b, 0xd7, 0xac, 0x1f,
+	0x52, 0x53, 0x92, 0x83, 0x90, 0xbd, 0x01, 0xe6, 0x50, 0xc1, 0x48, 0x4c, 0xda, 0x3c, 0x07, 0xe2,
+	0xfb, 0x73, 0x36, 0xbd, 0xc4, 0xda, 0x30, 0x1f, 0x87, 0xa3, 0x60, 0xde, 0x9f, 0xb3, 0x63, 0xc1,
+	0xb6, 0x05, 0x1b, 0x72, 0x6e, 0x3a, 0x44, 0x20, 0x89, 0x4f, 0xe8, 0x60, 0x82, 0x9c, 0xc0, 0x3d,
+	0x1d, 0xf9, 0x6e, 0xdf, 0xfa, 0x49, 0x15, 0x6e, 0x66, 0xbe, 0x44, 0x85, 0x82, 0x18, 0x71, 0x35,
+	0xe5, 0x22, 0x53, 0x03, 0xaa, 0xb9, 0x1a, 0x70, 0x1b, 0x96, 0xc9, 0xed, 0xb8, 0x14, 0x60, 0x9d,
+	0x58, 0x42, 0xe9, 0x23, 0x2a, 0x08, 0x1f, 0x05, 0x46, 0x6a, 0xee, 0x34, 0x1a, 0xfa, 0x02, 0xcd,
+	0x61, 0xd5, 0x68, 0xe2, 0xc8, 0x43, 0x35, 0xa0, 0x8c, 0x76, 0xe0, 0x05, 0x5d, 0x9b, 0x8f, 0x5d,
+	0x6f, 0x44, 0x05, 0x64, 0x35, 0xad, 0xde, 0x95, 0x03, 0xc5, 0xe5, 0x66, 0xfe, 0xfc, 0xe5, 0xa6,
+	0x7e, 0xee, 0x72, 0x23, 0x5b, 0xef, 0x63, 0x5f, 0xf4, 0x78, 0x6b, 0x01, 0x5b, 0x6f, 0xf5, 0x60,
+	0xfd, 0x26, 0x5e, 0x9b, 0x72, 0xd9, 0x61, 0x9f, 0xce, 0xf0, 0xe6, 0x56, 0x09, 0x6f, 0xb4, 0x6c,
+	0xa6, 0x88, 0xf3, 0xc9, 0x64, 0xa6, 0x57, 0xf4, 0x0a, 0x56, 0xcc, 0xbb, 0xb9, 0x78, 0x6a, 0x6f,
+	0x6f, 0xc2, 0xab, 0x79, 0x56, 0x09, 0xfc, 0x4a, 0x42, 0xab, 0x5f, 0xc6, 0x67, 0x45, 0x69, 0x47,
+	0x2e, 0xb1, 0x84, 0xae, 0xc3, 0xa2, 0x37, 0xe9, 0xf3, 0x67, 0x5a, 0xf1, 0x04, 0x25, 0x3a, 0xa3,
+	0x28, 0x96, 0x6c, 0xdb, 0x7e, 0x91, 0xac, 0x93, 0xb2, 0xb6, 0x5c, 0x79, 0xb3, 0x29, 0xd4, 0x67,
+	0x52, 0xcd, 0x26, 0x0a, 0xce, 0xd8, 0xb1, 0xad, 0x01, 0x4d, 0x0d, 0xb5, 0xc5, 0xb8, 0x86, 0x5b,
+	0x0c, 0x94, 0xc8, 0x2d, 0xc6, 0x67, 0x60, 0x55, 0xf0, 0xb1, 0x1f, 0xf1, 0x34, 0xf7, 0xcc, 0x52,
+	0x87, 0x9b, 0xa8, 0x9c, 0x22, 0xdf, 0x26, 0x2c, 0x91, 0x01, 0xfa, 0x3c, 0x72, 0xbc, 0x81, 0x42,
+	0x4c, 0xc3, 0xa7, 0x2a, 0x2d, 0xc3, 0xfa, 0x76, 0xb2, 0x28, 0x22, 0x52, 0xc9, 0xd6, 0x1a, 0x28,
+	0x28, 0xe9, 0x1f, 0xee, 0x0b, 0x28, 0x4c, 0xe9, 0xdf, 0x05, 0xda, 0x59, 0x89, 0xcf, 0x20, 0xb3,
+	0xd8, 0xd5, 0x07, 0xb4, 0xd2, 0x29, 0x17, 0xfe, 0x48, 0x05, 0x0b, 0x5d, 0xd8, 0xf1, 0x27, 0xc7,
+	0x9e, 0x18, 0xbb, 0x47, 0xa3, 0x24, 0x6f, 0xdd, 0xcc, 0xc4, 0xf8, 0x88, 0x96, 0x85, 0x92, 0xb7,
+	0x3a, 0xb9, 0xf9, 0x71, 0x3d, 0xde, 0x0b, 0xab, 0x6d, 0xcc, 0xfe, 0x1c, 0xed, 0x86, 0xdb, 0x3f,
+	0xae, 0x80, 0x79, 0xa5, 0xa5, 0xf1, 0xbf, 0x96, 0x21, 0xdb, 0x77, 0xe1, 0x8e, 0xaa, 0x0c, 0xe4,
+	0x7e, 0x6f, 0x86, 0x72, 0xae, 0x3e, 0xfc, 0xcd, 0x80, 0xb5, 0x92, 0x7c, 0x10, 0xa7, 0xd6, 0xf3,
+	0x9c, 0xda, 0x9f, 0x4b, 0xb3, 0xea, 0x0e, 0x2c, 0x93, 0x82, 0x4c, 0x8c, 0x17, 0x6f, 0x38, 0xf7,
+	0xe7, 0xec, 0x25, 0x94, 0x3f, 0x44, 0xf1, 0x45, 0x4a, 0x81, 0x4e, 0xbf, 0x9a, 0x4e, 0xbf, 0xed,
+	0x7b, 0xb0, 0x55, 0x1e, 0x1f, 0xba, 0x9d, 0x04, 0xf8, 0x73, 0xaa, 0x29, 0x4f, 0xde, 0x9d, 0xba,
+	0xe1, 0xd5, 0x6f, 0x60, 0x43, 0xf5, 0x99, 0x14, 0x63, 0x50, 0x70, 0x06, 0x63, 0xe4, 0x4b, 0x6a,
+	0xbd, 0x9a, 0x11, 0xa6, 0xae, 0x04, 0x12, 0xdb, 0x97, 0x61, 0x9e, 0x4f, 0xfa, 0x6a, 0xc8, 0x54,
+	0x43, 0x26, 0x9f, 0xf4, 0xe5, 0xc0, 0x2d, 0x30, 0x71, 0xe9, 0xa4, 0x56, 0x5a, 0x77, 0x87, 0xc6,
+	0x0a, 0x16, 0xef, 0x7a, 0xc1, 0xe2, 0x6d, 0x79, 0x58, 0x4c, 0x62, 0x88, 0x66, 0xc5, 0x84, 0xa2,
+	0x49, 0x15, 0x13, 0x94, 0x48, 0x0f, 0xce, 0x2a, 0x10, 0x78, 0x02, 0x64, 0xe7, 0xd3, 0x6d, 0xfd,
+	0x94, 0x76, 0xc9, 0x92, 0x13, 0xa7, 0x07, 0x6e, 0x34, 0x3b, 0x53, 0x38, 0x73, 0x1d, 0xcd, 0xa9,
+	0x77, 0x8a, 0x1a, 0xb0, 0x40, 0x2a, 0xf0, 0x70, 0xd6, 0x80, 0x91, 0xa0, 0xfd, 0x1d, 0xe3, 0x8a,
+	0x6b, 0xc5, 0x26, 0x2c, 0xd1, 0x21, 0x12, 0xe5, 0x98, 0x3a, 0x69, 0x14, 0xd2, 0xb4, 0x8c, 0xdb,
+	0x40, 0x55, 0xbf, 0x1c, 0xe5, 0x5b, 0x6e, 0x3e, 0xbe, 0x83, 0x7d, 0x46, 0x3a, 0xde, 0xcb, 0x5b,
+	0xad, 0xad, 0xbf, 0x1b, 0xd0, 0x9e, 0xdd, 0x29, 0x3c, 0x99, 0x1e, 0x8d, 0xfd, 0xfe, 0x74, 0xc4,
+	0xaf, 0xfc, 0x5c, 0x8e, 0x48, 0x98, 0x3a, 0x97, 0x43, 0xc9, 0x59, 0xe7, 0x72, 0x37, 0x61, 0x21,
+	0x8c, 0x1d, 0x8c, 0x8f, 0xe5, 0x12, 0x41, 0x01, 0xb3, 0xcd, 0x22, 0x66, 0xff, 0xc9, 0xc0, 0x6d,
+	0x56, 0x2e, 0xe0, 0x0f, 0xe6, 0x90, 0x28, 0xb7, 0x8b, 0xac, 0xe5, 0x76, 0x91, 0x6f, 0xd5, 0xea,
+	0xd5, 0x66, 0xcd, 0xce, 0x6f, 0x4c, 0x1f, 0xfc, 0x6e, 0x11, 0x9a, 0x89, 0x3f, 0x4f, 0xb8, 0x38,
+	0xf1, 0x7a, 0x9c, 0x7d, 0x15, 0x9a, 0xd9, 0x7b, 0x35, 0xb6, 0xae, 0x75, 0x90, 0xf9, 0x4b, 0xc2,
+	0xf6, 0x46, 0xb9, 0x02, 0xe2, 0x62, 0x99, 0xff, 0xfc, 0xd1, 0x56, 0xa5, 0x6e, 0xc4, 0xe6, 0xd3,
+	0x77, 0x50, 0xba, 0xf9, 0x82, 0xfb, 0x35, 0xdd, 0x7c, 0xd1, 0xf5, 0x55, 0xd6, 0x7c, 0xfa, 0x1e,
+	0x48, 0x37, 0x5f, 0x70, 0x67, 0xa5, 0x9b, 0x2f, 0xba, 0x42, 0x4a, 0xcc, 0x1f, 0xc2, 0x92, 0x76,
+	0x05, 0xc1, 0x6e, 0xe6, 0x03, 0x9f, 0xdd, 0xb2, 0xb4, 0xd7, 0x4a, 0x46, 0x8b, 0xad, 0x26, 0x57,
+	0x3d, 0xba, 0xd5, 0xec, 0x55, 0x94, 0x6e, 0x35, 0x77, 0x3f, 0x94, 0x58, 0xfd, 0x12, 0x2c, 0xeb,
+	0xa7, 0xc9, 0x4c, 0x7b, 0x31, 0x77, 0x88, 0xde, 0xfe, 0x50, 0xd9, 0x70, 0xc6, 0xf0, 0xd7, 0x60,
+	0x25, 0x73, 0x69, 0xc0, 0xf2, 0xaf, 0xea, 0x08, 0xaf, 0x97, 0x8e, 0xeb, 0xb6, 0xb7, 0x8c, 0xd7,
+	0x0d, 0xf6, 0x05, 0x68, 0xa4, 0xcf, 0x5f, 0xd9, 0x8d, 0xf4, 0xcb, 0x99, 0x83, 0xe3, 0xf6, 0xcd,
+	0xe2, 0xc1, 0x62, 0x2c, 0x66, 0x07, 0x81, 0x3a, 0x16, 0xb9, 0x13, 0x56, 0x1d, 0x8b, 0xfc, 0xf9,
+	0x61, 0x62, 0xf8, 0x1d, 0xc4, 0x22, 0xb5, 0x19, 0xd2, 0xb1, 0xc8, 0x6f, 0xd7, 0x74, 0x2c, 0x0a,
+	0x76, 0x51, 0x33, 0x2c, 0xd8, 0xdb, 0x00, 0xb3, 0x56, 0x8a, 0xbd, 0x92, 0x6f, 0x77, 0x63, 0x9b,
+	0xed, 0xa2, 0x21, 0x32, 0xb7, 0x80, 0xe6, 0xbe, 0x5f, 0x31, 0x58, 0x80, 0x4b, 0x65, 0xae, 0x35,
+	0x63, 0xb7, 0xce, 0xd3, 0x49, 0xb7, 0x6f, 0xff, 0x1b, 0xad, 0x82, 0x5c, 0x7e, 0x2e, 0x8e, 0xe0,
+	0x84, 0x8b, 0x28, 0x1b, 0x41, 0xea, 0xec, 0x32, 0x1b, 0x41, 0xfa, 0x64, 0x2e, 0x01, 0x9b, 0x8c,
+	0x61, 0x57, 0xa1, 0x1b, 0xd3, 0x9a, 0x31, 0xdd, 0x98, 0xde, 0x84, 0x24, 0xc6, 0xbe, 0x8c, 0x94,
+	0x98, 0xad, 0x8b, 0x3a, 0x25, 0x72, 0xfd, 0x81, 0x4e, 0x89, 0xfc, 0x72, 0x9a, 0x4a, 0xdb, 0x31,
+	0xde, 0x71, 0x64, 0x96, 0x08, 0x66, 0xe5, 0xab, 0x58, 0x76, 0xc1, 0x6c, 0x6f, 0x9e, 0xa9, 0xa3,
+	0x7f, 0x69, 0xfb, 0xf5, 0xaf, 0x48, 0xed, 0x91, 0x7b, 0xd4, 0xe9, 0xf9, 0xe3, 0xfb, 0xf8, 0xf3,
+	0x35, 0x5f, 0x0c, 0xee, 0xa3, 0x8d, 0xd7, 0xd4, 0x9f, 0x3b, 0xee, 0x0f, 0x7c, 0x7a, 0x0e, 0x8e,
+	0x8e, 0x4c, 0x25, 0xfa, 0xd8, 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0x3c, 0x2b, 0x37, 0x92, 0x19,
+	0x22, 0x00, 0x00,
 }
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 35e4db9f1..f7726474d 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
@@ -20,6 +20,38 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
+type ObjectType int32
+
+const (
+	ObjectType_UNKNOWN ObjectType = 0
+	ObjectType_COMMIT  ObjectType = 1
+	ObjectType_BLOB    ObjectType = 2
+	ObjectType_TREE    ObjectType = 3
+	ObjectType_TAG     ObjectType = 4
+)
+
+var ObjectType_name = map[int32]string{
+	0: "UNKNOWN",
+	1: "COMMIT",
+	2: "BLOB",
+	3: "TREE",
+	4: "TAG",
+}
+var ObjectType_value = map[string]int32{
+	"UNKNOWN": 0,
+	"COMMIT":  1,
+	"BLOB":    2,
+	"TREE":    3,
+	"TAG":     4,
+}
+
+func (x ObjectType) String() string {
+	return proto.EnumName(ObjectType_name, int32(x))
+}
+func (ObjectType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_shared_667153471f9eb114, []int{0}
+}
+
 type OperationMsg_Operation int32
 
 const (
@@ -43,7 +75,7 @@ func (x OperationMsg_Operation) String() string {
 	return proto.EnumName(OperationMsg_Operation_name, int32(x))
 }
 func (OperationMsg_Operation) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_shared_d2b895dab5e0de91, []int{0, 0}
+	return fileDescriptor_shared_667153471f9eb114, []int{0, 0}
 }
 
 type OperationMsg struct {
@@ -57,7 +89,7 @@ func (m *OperationMsg) Reset()         { *m = OperationMsg{} }
 func (m *OperationMsg) String() string { return proto.CompactTextString(m) }
 func (*OperationMsg) ProtoMessage()    {}
 func (*OperationMsg) Descriptor() ([]byte, []int) {
-	return fileDescriptor_shared_d2b895dab5e0de91, []int{0}
+	return fileDescriptor_shared_667153471f9eb114, []int{0}
 }
 func (m *OperationMsg) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_OperationMsg.Unmarshal(m, b)
@@ -112,7 +144,7 @@ func (m *Repository) Reset()         { *m = Repository{} }
 func (m *Repository) String() string { return proto.CompactTextString(m) }
 func (*Repository) ProtoMessage()    {}
 func (*Repository) Descriptor() ([]byte, []int) {
-	return fileDescriptor_shared_d2b895dab5e0de91, []int{1}
+	return fileDescriptor_shared_667153471f9eb114, []int{1}
 }
 func (m *Repository) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Repository.Unmarshal(m, b)
@@ -195,7 +227,7 @@ func (m *GitCommit) Reset()         { *m = GitCommit{} }
 func (m *GitCommit) String() string { return proto.CompactTextString(m) }
 func (*GitCommit) ProtoMessage()    {}
 func (*GitCommit) Descriptor() ([]byte, []int) {
-	return fileDescriptor_shared_d2b895dab5e0de91, []int{2}
+	return fileDescriptor_shared_667153471f9eb114, []int{2}
 }
 func (m *GitCommit) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GitCommit.Unmarshal(m, b)
@@ -277,7 +309,7 @@ func (m *CommitAuthor) Reset()         { *m = CommitAuthor{} }
 func (m *CommitAuthor) String() string { return proto.CompactTextString(m) }
 func (*CommitAuthor) ProtoMessage()    {}
 func (*CommitAuthor) Descriptor() ([]byte, []int) {
-	return fileDescriptor_shared_d2b895dab5e0de91, []int{3}
+	return fileDescriptor_shared_667153471f9eb114, []int{3}
 }
 func (m *CommitAuthor) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitAuthor.Unmarshal(m, b)
@@ -329,7 +361,7 @@ func (m *ExitStatus) Reset()         { *m = ExitStatus{} }
 func (m *ExitStatus) String() string { return proto.CompactTextString(m) }
 func (*ExitStatus) ProtoMessage()    {}
 func (*ExitStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_shared_d2b895dab5e0de91, []int{4}
+	return fileDescriptor_shared_667153471f9eb114, []int{4}
 }
 func (m *ExitStatus) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExitStatus.Unmarshal(m, b)
@@ -369,7 +401,7 @@ func (m *Branch) Reset()         { *m = Branch{} }
 func (m *Branch) String() string { return proto.CompactTextString(m) }
 func (*Branch) ProtoMessage()    {}
 func (*Branch) Descriptor() ([]byte, []int) {
-	return fileDescriptor_shared_d2b895dab5e0de91, []int{5}
+	return fileDescriptor_shared_667153471f9eb114, []int{5}
 }
 func (m *Branch) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Branch.Unmarshal(m, b)
@@ -422,7 +454,7 @@ func (m *Tag) Reset()         { *m = Tag{} }
 func (m *Tag) String() string { return proto.CompactTextString(m) }
 func (*Tag) ProtoMessage()    {}
 func (*Tag) Descriptor() ([]byte, []int) {
-	return fileDescriptor_shared_d2b895dab5e0de91, []int{6}
+	return fileDescriptor_shared_667153471f9eb114, []int{6}
 }
 func (m *Tag) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Tag.Unmarshal(m, b)
@@ -498,7 +530,7 @@ func (m *User) Reset()         { *m = User{} }
 func (m *User) String() string { return proto.CompactTextString(m) }
 func (*User) ProtoMessage()    {}
 func (*User) Descriptor() ([]byte, []int) {
-	return fileDescriptor_shared_d2b895dab5e0de91, []int{7}
+	return fileDescriptor_shared_667153471f9eb114, []int{7}
 }
 func (m *User) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_User.Unmarshal(m, b)
@@ -557,7 +589,7 @@ func (m *ObjectPool) Reset()         { *m = ObjectPool{} }
 func (m *ObjectPool) String() string { return proto.CompactTextString(m) }
 func (*ObjectPool) ProtoMessage()    {}
 func (*ObjectPool) Descriptor() ([]byte, []int) {
-	return fileDescriptor_shared_d2b895dab5e0de91, []int{8}
+	return fileDescriptor_shared_667153471f9eb114, []int{8}
 }
 func (m *ObjectPool) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ObjectPool.Unmarshal(m, b)
@@ -603,61 +635,64 @@ func init() {
 	proto.RegisterType((*Tag)(nil), "gitaly.Tag")
 	proto.RegisterType((*User)(nil), "gitaly.User")
 	proto.RegisterType((*ObjectPool)(nil), "gitaly.ObjectPool")
+	proto.RegisterEnum("gitaly.ObjectType", ObjectType_name, ObjectType_value)
 	proto.RegisterEnum("gitaly.OperationMsg_Operation", OperationMsg_Operation_name, OperationMsg_Operation_value)
 	proto.RegisterExtension(E_OpType)
 }
 
-func init() { proto.RegisterFile("shared.proto", fileDescriptor_shared_d2b895dab5e0de91) }
-
-var fileDescriptor_shared_d2b895dab5e0de91 = []byte{
-	// 773 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xdd, 0x8e, 0x1b, 0x35,
-	0x14, 0x66, 0x26, 0xff, 0x27, 0xb3, 0x25, 0x98, 0xbd, 0x18, 0x2d, 0x6a, 0x1b, 0x06, 0x09, 0xed,
-	0x05, 0x9d, 0x54, 0xa9, 0xc4, 0x05, 0x57, 0x6c, 0x97, 0xaa, 0x6a, 0xd1, 0x6e, 0x56, 0xde, 0x44,
-	0x48, 0xdc, 0x8c, 0x9c, 0xcc, 0xa9, 0x63, 0x34, 0x13, 0x5b, 0xb6, 0x53, 0x91, 0x5e, 0xf2, 0x40,
-	0x3c, 0x09, 0xef, 0xc1, 0x63, 0x80, 0x6c, 0x67, 0xb2, 0x61, 0xbb, 0x20, 0xee, 0x7c, 0x3e, 0x7f,
-	0x3e, 0x3e, 0xc7, 0xdf, 0x77, 0x0c, 0x89, 0x59, 0x33, 0x8d, 0x65, 0xae, 0xb4, 0xb4, 0x92, 0x74,
-	0xb9, 0xb0, 0xac, 0xda, 0x9d, 0x3d, 0xe5, 0x52, 0xf2, 0x0a, 0x27, 0x1e, 0x5d, 0x6e, 0xdf, 0x4d,
-	0xac, 0xa8, 0xd1, 0x58, 0x56, 0xab, 0x40, 0x3c, 0x1b, 0xdf, 0x27, 0x94, 0x68, 0x56, 0x5a, 0x28,
-	0x2b, 0x75, 0x60, 0x64, 0x06, 0x92, 0x99, 0x42, 0xcd, 0xac, 0x90, 0x9b, 0x2b, 0xc3, 0x49, 0x0e,
-	0xb1, 0x54, 0x69, 0x34, 0x8e, 0xce, 0x1f, 0x4d, 0x9f, 0xe4, 0xe1, 0x9e, 0xfc, 0x98, 0x71, 0x17,
-	0xd0, 0x58, 0xaa, 0xec, 0x05, 0x0c, 0x0e, 0x00, 0x19, 0x42, 0x6f, 0x71, 0xfd, 0xe3, 0xf5, 0xec,
-	0xa7, 0xeb, 0xd1, 0x27, 0x2e, 0xb8, 0x5a, 0xcc, 0x2f, 0xe6, 0x33, 0x3a, 0x8a, 0x48, 0x02, 0xfd,
-	0x8b, 0xcb, 0xcb, 0x57, 0xb7, 0xb7, 0x33, 0x3a, 0x8a, 0xb3, 0xdf, 0x63, 0x00, 0x8a, 0x4a, 0x1a,
-	0x61, 0xa5, 0xde, 0x91, 0x2f, 0x21, 0x31, 0x56, 0x6a, 0xc6, 0xb1, 0xd8, 0xb0, 0x1a, 0xd3, 0x78,
-	0x1c, 0x9d, 0x0f, 0xe8, 0x70, 0x8f, 0x5d, 0xb3, 0x1a, 0xc9, 0x57, 0x70, 0xa2, 0xb1, 0x62, 0x56,
-	0xbc, 0xc7, 0x42, 0x31, 0xbb, 0x4e, 0x5b, 0x9e, 0x93, 0x34, 0xe0, 0x0d, 0xb3, 0x6b, 0xf2, 0x1c,
-	0x4e, 0xb9, 0xb0, 0x85, 0x5c, 0xfe, 0x82, 0x2b, 0x5b, 0x94, 0x42, 0xe3, 0xca, 0xe5, 0x4f, 0xdb,
-	0x9e, 0x4b, 0xb8, 0xb0, 0x33, 0xbf, 0xf5, 0x43, 0xb3, 0x43, 0x5e, 0xc3, 0xd8, 0x9d, 0x60, 0x95,
-	0x45, 0xbd, 0x61, 0x16, 0xef, 0x9f, 0x15, 0x68, 0xd2, 0xce, 0xb8, 0x75, 0x3e, 0xa0, 0x8f, 0xb9,
-	0xb0, 0x17, 0x0d, 0xed, 0x9f, 0x69, 0x04, 0x1a, 0x57, 0x1f, 0xaf, 0x0a, 0x7d, 0xe8, 0x29, 0xed,
-	0x86, 0xfa, 0x78, 0x75, 0xd4, 0xe7, 0xd7, 0xf0, 0x29, 0xaf, 0x0a, 0xa5, 0xa5, 0xbf, 0xc3, 0xb7,
-	0xd1, 0xf7, 0xb4, 0x13, 0x5e, 0xdd, 0x04, 0xd4, 0xf5, 0xf1, 0xb6, 0xdd, 0x8f, 0x46, 0xf1, 0xdb,
-	0x76, 0xbf, 0x37, 0xea, 0xd3, 0xb6, 0xa3, 0x65, 0x7f, 0x46, 0x30, 0x78, 0x2d, 0xec, 0xa5, 0xac,
-	0x6b, 0x61, 0xc9, 0x23, 0x88, 0x45, 0xe9, 0x35, 0x1a, 0xd0, 0x58, 0x94, 0x24, 0x85, 0x9e, 0xd9,
-	0xfa, 0x92, 0xfc, 0xd3, 0x25, 0xb4, 0x09, 0x09, 0x81, 0xf6, 0x52, 0x96, 0x3b, 0xff, 0x5a, 0x09,
-	0xf5, 0x6b, 0xf2, 0x0d, 0x74, 0xd9, 0xd6, 0xae, 0xa5, 0xf6, 0xef, 0x32, 0x9c, 0x9e, 0x36, 0x2a,
-	0x87, 0xec, 0x17, 0x7e, 0x8f, 0xee, 0x39, 0x64, 0x0a, 0x83, 0x95, 0xc7, 0x2d, 0xea, 0xb4, 0xf3,
-	0x1f, 0x07, 0xee, 0x68, 0xe4, 0x31, 0x80, 0x62, 0x1a, 0x37, 0xb6, 0x10, 0xa5, 0x49, 0xbb, 0xfe,
-	0xfd, 0x06, 0x01, 0x79, 0x53, 0x1a, 0xf2, 0x05, 0x0c, 0x5c, 0x21, 0x85, 0x11, 0x1f, 0x30, 0xed,
-	0x8d, 0xa3, 0xf3, 0x16, 0xed, 0x3b, 0xe0, 0x56, 0x7c, 0xc0, 0x6c, 0x0d, 0xc9, 0x71, 0x5a, 0xd7,
-	0x81, 0xf7, 0x44, 0x14, 0x3a, 0x70, 0x6b, 0x72, 0x0a, 0x1d, 0xac, 0x99, 0xa8, 0xf6, 0xdd, 0x86,
-	0x80, 0xe4, 0xd0, 0x2e, 0x99, 0x45, 0xdf, 0xeb, 0x70, 0x7a, 0x96, 0x07, 0xeb, 0xe7, 0x8d, 0xf5,
-	0xf3, 0x79, 0x33, 0x1b, 0xd4, 0xf3, 0xb2, 0x0c, 0xe0, 0xd5, 0xaf, 0xc2, 0xde, 0x5a, 0x66, 0xb7,
-	0xc6, 0xe5, 0x7c, 0xcf, 0xaa, 0x6d, 0xb8, 0xa8, 0x43, 0x43, 0x90, 0xcd, 0xa1, 0xfb, 0x52, 0xb3,
-	0xcd, 0x6a, 0xfd, 0x60, 0x1d, 0xdf, 0xc2, 0x89, 0x65, 0x9a, 0xa3, 0x2d, 0x42, 0xef, 0xbe, 0x9e,
-	0xe1, 0xf4, 0xb3, 0xe6, 0x7d, 0x0e, 0x8a, 0xd1, 0x24, 0xf0, 0x42, 0x94, 0xfd, 0x11, 0x41, 0x6b,
-	0xce, 0xf8, 0x83, 0x39, 0x83, 0xb6, 0xf1, 0x41, 0xdb, 0x8f, 0xee, 0x68, 0xfd, 0xaf, 0x3b, 0x9c,
-	0x27, 0x6a, 0x34, 0x86, 0x71, 0xf4, 0x32, 0x27, 0xb4, 0x09, 0xdd, 0xb4, 0xed, 0x97, 0x41, 0x81,
-	0x8e, 0x57, 0x60, 0xb8, 0xc7, 0x9c, 0x08, 0xce, 0x22, 0x96, 0x71, 0x8e, 0xda, 0xdb, 0xf8, 0x5f,
-	0x2d, 0x12, 0x38, 0xd9, 0x3b, 0x68, 0x2f, 0x0c, 0x6a, 0xf2, 0x39, 0x74, 0x78, 0x55, 0x1c, 0x9c,
-	0xd9, 0xe6, 0xd5, 0x9b, 0xf2, 0xd0, 0x63, 0xfc, 0x90, 0x7e, 0xad, 0x63, 0xfd, 0x9e, 0xc2, 0x90,
-	0x57, 0xc5, 0xd6, 0xb8, 0x11, 0xab, 0x71, 0x3f, 0xb4, 0xc0, 0xab, 0xc5, 0x1e, 0xc9, 0xbe, 0x07,
-	0x08, 0x83, 0x77, 0x23, 0x65, 0x45, 0xa6, 0x00, 0x47, 0xe3, 0x16, 0xf9, 0x3a, 0x49, 0x53, 0xe7,
-	0xdd, 0xd0, 0xd1, 0x23, 0xd6, 0x77, 0x33, 0xe8, 0x49, 0x55, 0xd8, 0x9d, 0x42, 0xf2, 0xe4, 0x23,
-	0x7f, 0x5c, 0xa1, 0x5d, 0xcb, 0x72, 0xa6, 0xdc, 0x4f, 0x66, 0xd2, 0xbf, 0x7e, 0xbb, 0x67, 0xf6,
-	0xe3, 0x3f, 0x90, 0x76, 0xa5, 0x9a, 0xef, 0x14, 0xbe, 0x7c, 0xfe, 0xb3, 0xdb, 0xae, 0xd8, 0x32,
-	0x5f, 0xc9, 0x7a, 0x12, 0x96, 0xcf, 0xa4, 0xe6, 0x93, 0x70, 0xe8, 0x99, 0x4f, 0x3e, 0xe1, 0x72,
-	0x1f, 0xab, 0xe5, 0xb2, 0xeb, 0xa1, 0x17, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0x14, 0xaf, 0x34,
-	0xae, 0xd1, 0x05, 0x00, 0x00,
+func init() { proto.RegisterFile("shared.proto", fileDescriptor_shared_667153471f9eb114) }
+
+var fileDescriptor_shared_667153471f9eb114 = []byte{
+	// 813 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x54, 0xdd, 0x6e, 0xdb, 0x36,
+	0x14, 0x9e, 0x64, 0xf9, 0xef, 0x58, 0xe9, 0x34, 0x2e, 0x17, 0x42, 0x86, 0xb6, 0x9e, 0x06, 0x0c,
+	0xc1, 0xb0, 0xca, 0x85, 0x0b, 0xec, 0x62, 0x57, 0xb3, 0xb3, 0x20, 0x48, 0x37, 0x47, 0x01, 0xa3,
+	0x60, 0xc0, 0x6e, 0x04, 0xda, 0x62, 0x69, 0x0e, 0x92, 0x29, 0x90, 0x74, 0xb1, 0xf4, 0x72, 0x0f,
+	0xb4, 0x27, 0xd9, 0x7b, 0xec, 0x31, 0x36, 0x90, 0xb4, 0x1c, 0x37, 0xcd, 0x86, 0xde, 0xf1, 0x7c,
+	0xfc, 0x78, 0x78, 0x3e, 0x7e, 0xe7, 0x10, 0x42, 0xb5, 0x26, 0x92, 0x96, 0x69, 0x23, 0x85, 0x16,
+	0xa8, 0xc7, 0xb8, 0x26, 0xd5, 0xdd, 0xc9, 0x73, 0x26, 0x04, 0xab, 0xe8, 0xc4, 0xa2, 0xcb, 0xed,
+	0x9b, 0x89, 0xe6, 0x35, 0x55, 0x9a, 0xd4, 0x8d, 0x23, 0x9e, 0x8c, 0x1f, 0x12, 0x4a, 0xaa, 0x56,
+	0x92, 0x37, 0x5a, 0x48, 0xc7, 0x48, 0x14, 0x84, 0x59, 0x43, 0x25, 0xd1, 0x5c, 0x6c, 0x16, 0x8a,
+	0xa1, 0x14, 0x7c, 0xd1, 0xc4, 0xde, 0xd8, 0x3b, 0x7d, 0x32, 0x7d, 0x96, 0xba, 0x7b, 0xd2, 0x43,
+	0xc6, 0x7d, 0x80, 0x7d, 0xd1, 0x24, 0xaf, 0x60, 0xb8, 0x07, 0xd0, 0x08, 0xfa, 0xb7, 0x57, 0x3f,
+	0x5d, 0x65, 0xbf, 0x5c, 0x45, 0x9f, 0x98, 0x60, 0x71, 0x9b, 0xcf, 0xf2, 0x0c, 0x47, 0x1e, 0x0a,
+	0x61, 0x30, 0x3b, 0x3b, 0x3b, 0xbf, 0xb9, 0xc9, 0x70, 0xe4, 0x27, 0x7f, 0xfa, 0x00, 0x98, 0x36,
+	0x42, 0x71, 0x2d, 0xe4, 0x1d, 0xfa, 0x12, 0x42, 0xa5, 0x85, 0x24, 0x8c, 0x16, 0x1b, 0x52, 0xd3,
+	0xd8, 0x1f, 0x7b, 0xa7, 0x43, 0x3c, 0xda, 0x61, 0x57, 0xa4, 0xa6, 0xe8, 0x2b, 0x38, 0x92, 0xb4,
+	0x22, 0x9a, 0xbf, 0xa5, 0x45, 0x43, 0xf4, 0x3a, 0xee, 0x58, 0x4e, 0xd8, 0x82, 0xd7, 0x44, 0xaf,
+	0xd1, 0x4b, 0x38, 0x66, 0x5c, 0x17, 0x62, 0xf9, 0x1b, 0x5d, 0xe9, 0xa2, 0xe4, 0x92, 0xae, 0x4c,
+	0xfe, 0x38, 0xb0, 0x5c, 0xc4, 0xb8, 0xce, 0xec, 0xd6, 0x8f, 0xed, 0x0e, 0xba, 0x80, 0xb1, 0x39,
+	0x41, 0x2a, 0x4d, 0xe5, 0x86, 0x68, 0xfa, 0xf0, 0x2c, 0xa7, 0x2a, 0xee, 0x8e, 0x3b, 0xa7, 0x43,
+	0xfc, 0x94, 0x71, 0x3d, 0x6b, 0x69, 0xef, 0xa7, 0xe1, 0x54, 0x99, 0xfa, 0x58, 0x55, 0xc8, 0xbd,
+	0xa6, 0xb8, 0xe7, 0xea, 0x63, 0xd5, 0x81, 0xce, 0xaf, 0xe1, 0x53, 0x56, 0x15, 0x8d, 0x14, 0xf6,
+	0x0e, 0x2b, 0x63, 0x60, 0x69, 0x47, 0xac, 0xba, 0x76, 0xa8, 0xd1, 0xf1, 0x3a, 0x18, 0x78, 0x91,
+	0xff, 0x3a, 0x18, 0xf4, 0xa3, 0x01, 0x0e, 0x0c, 0x2d, 0xf9, 0xdb, 0x83, 0xe1, 0x05, 0xd7, 0x67,
+	0xa2, 0xae, 0xb9, 0x46, 0x4f, 0xc0, 0xe7, 0xa5, 0xf5, 0x68, 0x88, 0x7d, 0x5e, 0xa2, 0x18, 0xfa,
+	0x6a, 0x6b, 0x4b, 0xb2, 0x4f, 0x17, 0xe2, 0x36, 0x44, 0x08, 0x82, 0xa5, 0x28, 0xef, 0xec, 0x6b,
+	0x85, 0xd8, 0xae, 0xd1, 0xb7, 0xd0, 0x23, 0x5b, 0xbd, 0x16, 0xd2, 0xbe, 0xcb, 0x68, 0x7a, 0xdc,
+	0xba, 0xec, 0xb2, 0xcf, 0xec, 0x1e, 0xde, 0x71, 0xd0, 0x14, 0x86, 0x2b, 0x8b, 0x6b, 0x2a, 0xe3,
+	0xee, 0xff, 0x1c, 0xb8, 0xa7, 0xa1, 0xa7, 0x00, 0x0d, 0x91, 0x74, 0xa3, 0x0b, 0x5e, 0xaa, 0xb8,
+	0x67, 0xdf, 0x6f, 0xe8, 0x90, 0xcb, 0x52, 0xa1, 0x2f, 0x60, 0x68, 0x0a, 0x29, 0x14, 0x7f, 0x47,
+	0xe3, 0xfe, 0xd8, 0x3b, 0xed, 0xe0, 0x81, 0x01, 0x6e, 0xf8, 0x3b, 0x9a, 0xac, 0x21, 0x3c, 0x4c,
+	0x6b, 0x14, 0xd8, 0x9e, 0xf0, 0x9c, 0x02, 0xb3, 0x46, 0xc7, 0xd0, 0xa5, 0x35, 0xe1, 0xd5, 0x4e,
+	0xad, 0x0b, 0x50, 0x0a, 0x41, 0x49, 0x34, 0xb5, 0x5a, 0x47, 0xd3, 0x93, 0xd4, 0xb5, 0x7e, 0xda,
+	0xb6, 0x7e, 0x9a, 0xb7, 0xb3, 0x81, 0x2d, 0x2f, 0x49, 0x00, 0xce, 0x7f, 0xe7, 0xfa, 0x46, 0x13,
+	0xbd, 0x55, 0x26, 0xe7, 0x5b, 0x52, 0x6d, 0xdd, 0x45, 0x5d, 0xec, 0x82, 0x24, 0x87, 0xde, 0x5c,
+	0x92, 0xcd, 0x6a, 0xfd, 0x68, 0x1d, 0xdf, 0xc1, 0x91, 0x26, 0x92, 0x51, 0x5d, 0x38, 0xed, 0xb6,
+	0x9e, 0xd1, 0xf4, 0xb3, 0xf6, 0x7d, 0xf6, 0x8e, 0xe1, 0xd0, 0xf1, 0x5c, 0x94, 0xfc, 0xe5, 0x41,
+	0x27, 0x27, 0xec, 0xd1, 0x9c, 0xce, 0x5b, 0x7f, 0xef, 0xed, 0x07, 0x77, 0x74, 0x3e, 0xea, 0x0e,
+	0xd3, 0x13, 0x35, 0x55, 0x8a, 0x30, 0x6a, 0x6d, 0x0e, 0x71, 0x1b, 0x9a, 0x69, 0xdb, 0x2d, 0x9d,
+	0x03, 0x5d, 0xeb, 0xc0, 0x68, 0x87, 0x19, 0x13, 0x4c, 0x8b, 0x68, 0xc2, 0x18, 0x95, 0xb6, 0x8d,
+	0xff, 0xb3, 0x45, 0x1c, 0x27, 0x79, 0x03, 0xc1, 0xad, 0xa2, 0x12, 0x7d, 0x0e, 0x5d, 0x56, 0x15,
+	0xfb, 0xce, 0x0c, 0x58, 0x75, 0x59, 0xee, 0x35, 0xfa, 0x8f, 0xf9, 0xd7, 0x39, 0xf4, 0xef, 0x39,
+	0x8c, 0x58, 0x55, 0x6c, 0x95, 0x19, 0xb1, 0x9a, 0xee, 0x86, 0x16, 0x58, 0x75, 0xbb, 0x43, 0x92,
+	0x1f, 0x00, 0xdc, 0xe0, 0x5d, 0x0b, 0x51, 0xa1, 0x29, 0xc0, 0xc1, 0xb8, 0x79, 0xb6, 0x4e, 0xd4,
+	0xd6, 0x79, 0x3f, 0x74, 0xf8, 0x80, 0xf5, 0xcd, 0xbc, 0xcd, 0x90, 0xdf, 0x35, 0xf4, 0xfd, 0xdf,
+	0x0a, 0xa0, 0x77, 0x96, 0x2d, 0x16, 0x97, 0x79, 0xe4, 0xa1, 0x01, 0x04, 0xf3, 0x9f, 0xb3, 0x79,
+	0xe4, 0x9b, 0x55, 0x8e, 0xcf, 0xcf, 0xa3, 0x0e, 0xea, 0x43, 0x27, 0x9f, 0x5d, 0x44, 0xc1, 0xf7,
+	0x19, 0xf4, 0x45, 0x53, 0x68, 0x93, 0xe0, 0xd9, 0x07, 0x3d, 0xb6, 0xa0, 0x7a, 0x2d, 0xca, 0xac,
+	0x31, 0xbf, 0xa1, 0x8a, 0xff, 0xf9, 0xe3, 0xc1, 0xc0, 0x1c, 0xfe, 0xa3, 0xb8, 0x27, 0x1a, 0x53,
+	0xc6, 0xfc, 0xe5, 0xaf, 0x66, 0xbb, 0x22, 0xcb, 0x74, 0x25, 0xea, 0x89, 0x5b, 0xbe, 0x10, 0x92,
+	0x4d, 0xdc, 0xa1, 0x17, 0x36, 0xf9, 0x84, 0x89, 0x5d, 0xdc, 0x2c, 0x97, 0x3d, 0x0b, 0xbd, 0xfa,
+	0x37, 0x00, 0x00, 0xff, 0xff, 0x87, 0xef, 0xe0, 0x3f, 0x15, 0x06, 0x00, 0x00,
 }
diff --git a/vendor/vendor.json b/vendor/vendor.json
index ec86ee7e8..b87802714 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -593,12 +593,12 @@
 			"revisionTime": "2016-03-31T18:18:00Z"
 		},
 		{
-			"checksumSHA1": "GIKWOybd1FBje1xV81B+havPyOQ=",
+			"checksumSHA1": "g0JjMFl0H1GGQkLxr3pWCxkdmOw=",
 			"path": "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb",
-			"revision": "f90f9782cbceab4f8611b2f7ba680c78ae555c85",
-			"revisionTime": "2019-04-16T22:54:53Z",
-			"version": "v1.26.0",
-			"versionExact": "v1.26.0"
+			"revision": "7b27d6a46a66d884d8e2cccd05b322fed0dbb665",
+			"revisionTime": "2019-04-24T20:35:25Z",
+			"version": "v1.27.0",
+			"versionExact": "v1.27.0"
 		},
 		{
 			"checksumSHA1": "WMOuBgCyclqy+Mqunb0NbykaC4Y=",