Add RPC for applying patches to a branch

This adds an RPC that takes a branch and a stream of patches generated
using `git format-patch`, the patches are applied to the branch using
`git am`.

When the specified branch does not exist, it will be created from
HEAD, if it existed, the patches will be applied to that branch.

If the patches could not be applied, a gRPC `FailedPrecondition` is
raised.

To apply the patches, a random new temporary branch is created from
either the specified branch or HEAD. That branch is checked out in a
worktree and we attempt to apply the patches. If it succeeds, then we
update the specified branch to the new revision. After the attempt, we
remove the temporary branch.

The response of the RPC is a `BranchUpdate` response containing
whether or not a new branch was created, and the new tip of the
branch.

18 files changed, 983 insertions, 182 deletions

diff --git a/changelogs/unreleased/bvl-apply-patch-rpc.yml b/changelogs/unreleased/bvl-apply-patch-rpc.yml
new file mode 100644
index 000000000..56a597a68
--- /dev/null
+++ b/changelogs/unreleased/bvl-apply-patch-rpc.yml
@@ -0,0 +1,5 @@
+---
+title: Add an endpoint to apply patches to a branch
+merge_request: 926
+author:
+type: added
diff --git a/internal/service/operations/apply_patch.go b/internal/service/operations/apply_patch.go
new file mode 100644
index 000000000..f616904d4
--- /dev/null
+++ b/internal/service/operations/apply_patch.go
@@ -0,0 +1,80 @@
+package operations
+
+import (
+	"fmt"
+
+	"gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
+	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func (s *server) UserApplyPatch(stream gitalypb.OperationService_UserApplyPatchServer) error {
+	firstRequest, err := stream.Recv()
+	if err != nil {
+		return err
+	}
+
+	header := firstRequest.GetHeader()
+	if header == nil {
+		return status.Errorf(codes.InvalidArgument, "UserApplyPatch: empty UserApplyPatch_Header")
+	}
+
+	if err := validateUserApplyPatchHeader(header); err != nil {
+		return status.Errorf(codes.InvalidArgument, "UserApplyPatch: %v", err)
+	}
+
+	requestCtx := stream.Context()
+	rubyClient, err := s.OperationServiceClient(requestCtx)
+	if err != nil {
+		return err
+	}
+
+	clientCtx, err := rubyserver.SetHeaders(requestCtx, header.GetRepository())
+	if err != nil {
+		return err
+	}
+
+	rubyStream, err := rubyClient.UserApplyPatch(clientCtx)
+	if err != nil {
+		return err
+	}
+
+	if err := rubyStream.Send(firstRequest); err != nil {
+		return err
+	}
+
+	err = rubyserver.Proxy(func() error {
+		request, err := stream.Recv()
+		if err != nil {
+			return err
+		}
+		return rubyStream.Send(request)
+	})
+	if err != nil {
+		return err
+	}
+
+	response, err := rubyStream.CloseAndRecv()
+	if err != nil {
+		return err
+	}
+
+	return stream.SendAndClose(response)
+}
+
+func validateUserApplyPatchHeader(header *gitalypb.UserApplyPatchRequest_Header) error {
+	if header.GetRepository() == nil {
+		return fmt.Errorf("missing Repository")
+	}
+
+	if header.GetUser() == nil {
+		return fmt.Errorf("missing User")
+	}
+
+	if header.GetTargetBranch() == nil {
+		return fmt.Errorf("missing Branch")
+	}
+
+	return nil
+}
diff --git a/internal/service/operations/apply_patch_test.go b/internal/service/operations/apply_patch_test.go
new file mode 100644
index 000000000..d5604047c
--- /dev/null
+++ b/internal/service/operations/apply_patch_test.go
@@ -0,0 +1,256 @@
+package operations_test
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"strings"
+	"testing"
+	"testing/iotest"
+
+	"github.com/stretchr/testify/require"
+	"gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
+	"gitlab.com/gitlab-org/gitaly/internal/service/operations"
+	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
+	"gitlab.com/gitlab-org/gitaly/streamio"
+	"google.golang.org/grpc/codes"
+)
+
+func TestSuccessfulUserApplyPatch(t *testing.T) {
+	server, serverSocketPath := runFullServer(t)
+	defer server.Stop()
+
+	client, conn := operations.NewOperationClient(t, serverSocketPath)
+	defer conn.Close()
+
+	testRepo, testRepoPath, cleanupFn := testhelper.NewTestRepo(t)
+	defer cleanupFn()
+
+	ctx, cancel := testhelper.Context()
+	defer cancel()
+
+	user := &gitalypb.User{
+		Name:  []byte("Jane Doe"),
+		Email: []byte("janedoe@gitlab.com"),
+		GlId:  "user-1",
+	}
+
+	testPatchReadme := "testdata/0001-A-commit-from-a-patch.patch"
+	testPatchFeature := "testdata/0001-This-does-not-apply-to-the-feature-branch.patch"
+
+	testCases := []struct {
+		desc           string
+		branchName     string
+		branchCreated  bool
+		patches        []string
+		commitMessages []string
+	}{
+		{
+			desc:           "a new branch",
+			branchName:     "patched-branch",
+			branchCreated:  true,
+			patches:        []string{testPatchReadme},
+			commitMessages: []string{"A commit from a patch"},
+		},
+		{
+			desc:           "an existing branch",
+			branchName:     "feature",
+			branchCreated:  false,
+			patches:        []string{testPatchReadme},
+			commitMessages: []string{"A commit from a patch"},
+		},
+		{
+			desc:           "multiple patches",
+			branchName:     "branch-with-multiple-patches",
+			branchCreated:  true,
+			patches:        []string{testPatchReadme, testPatchFeature},
+			commitMessages: []string{"A commit from a patch", "This does not apply to the `feature` branch"},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.desc, func(t *testing.T) {
+			stream, err := client.UserApplyPatch(ctx)
+			require.NoError(t, err)
+
+			headerRequest := applyPatchHeaderRequest(testRepo, user, testCase.branchName)
+			require.NoError(t, stream.Send(headerRequest))
+
+			writer := streamio.NewWriter(func(p []byte) error {
+				patchRequest := applyPatchPatchesRequest(p)
+
+				return stream.Send(patchRequest)
+			})
+
+			for _, patchFileName := range testCase.patches {
+				func() {
+					file, err := os.Open(patchFileName)
+					require.NoError(t, err)
+					defer file.Close()
+
+					byteReader := iotest.OneByteReader(file)
+					_, err = io.Copy(writer, byteReader)
+					require.NoError(t, err)
+				}()
+			}
+
+			response, err := stream.CloseAndRecv()
+			require.NoError(t, err)
+
+			response.GetBranchUpdate()
+			require.Equal(t, testCase.branchCreated, response.GetBranchUpdate().GetBranchCreated())
+
+			branches := testhelper.MustRunCommand(t, nil, "git", "-C", testRepoPath, "branch")
+			require.Contains(t, string(branches), testCase.branchName)
+
+			maxCount := fmt.Sprintf("--max-count=%d", len(testCase.commitMessages))
+
+			gitArgs := []string{
+				"-C",
+				testRepoPath,
+				"log",
+				testCase.branchName,
+				"--format=%s",
+				maxCount,
+				"--reverse",
+			}
+
+			output := testhelper.MustRunCommand(t, nil, "git", gitArgs...)
+			commitMessages := strings.Split(string(output), "\n")
+			// Throw away the last element, as that's going to be
+			// an empty string.
+			if len(commitMessages) > 0 {
+				commitMessages = commitMessages[:len(commitMessages)-1]
+			}
+			require.Equal(t, commitMessages, testCase.commitMessages)
+		})
+	}
+}
+
+func TestFailedPatchApplyPatch(t *testing.T) {
+	server, serverSocketPath := runFullServer(t)
+	defer server.Stop()
+
+	client, conn := operations.NewOperationClient(t, serverSocketPath)
+	defer conn.Close()
+
+	testRepo, _, cleanupFn := testhelper.NewTestRepo(t)
+	defer cleanupFn()
+
+	ctx, cancel := testhelper.Context()
+	defer cancel()
+
+	user := &gitalypb.User{
+		Name:  []byte("Jane Doe"),
+		Email: []byte("janedoe@gitlab.com"),
+		GlId:  "user-1",
+	}
+
+	testPatch, err := ioutil.ReadFile("testdata/0001-This-does-not-apply-to-the-feature-branch.patch")
+	require.NoError(t, err)
+
+	stream, err := client.UserApplyPatch(ctx)
+	require.NoError(t, err)
+
+	headerRequest := applyPatchHeaderRequest(testRepo, user, "feature")
+	require.NoError(t, stream.Send(headerRequest))
+
+	patchRequest := applyPatchPatchesRequest(testPatch)
+	require.NoError(t, stream.Send(patchRequest))
+
+	_, err = stream.CloseAndRecv()
+	testhelper.RequireGrpcError(t, err, codes.FailedPrecondition)
+}
+
+func TestFailedValidationUserApplyPatch(t *testing.T) {
+	server, serverSocketPath := runFullServer(t)
+	defer server.Stop()
+
+	client, conn := operations.NewOperationClient(t, serverSocketPath)
+	defer conn.Close()
+
+	testRepo, _, cleanupFn := testhelper.NewTestRepo(t)
+	defer cleanupFn()
+
+	ctx, cancel := testhelper.Context()
+	defer cancel()
+
+	user := &gitalypb.User{
+		Name:  []byte("Jane Doe"),
+		Email: []byte("janedoe@gitlab.com"),
+		GlId:  "user-1",
+	}
+
+	testCases := []struct {
+		desc         string
+		errorMessage string
+		repo         *gitalypb.Repository
+		user         *gitalypb.User
+		branchName   string
+	}{
+		{
+			desc:         "missing Repository",
+			errorMessage: "missing Repository",
+			branchName:   "new-branch",
+			user:         user,
+		},
+		{
+			desc:         "missing Branch",
+			errorMessage: "missing Branch",
+			repo:         testRepo,
+			user:         user,
+		},
+		{
+			desc:         "empty BranchName",
+			errorMessage: "missing Branch",
+			repo:         testRepo,
+			user:         user,
+			branchName:   "",
+		},
+		{
+			desc:         "missing User",
+			errorMessage: "missing User",
+			branchName:   "new-branch",
+			repo:         testRepo,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.desc, func(t *testing.T) {
+			stream, err := client.UserApplyPatch(ctx)
+			require.NoError(t, err)
+
+			request := applyPatchHeaderRequest(testCase.repo, testCase.user, testCase.branchName)
+			require.NoError(t, stream.Send(request))
+
+			_, err = stream.CloseAndRecv()
+
+			testhelper.RequireGrpcError(t, err, codes.InvalidArgument)
+			require.Contains(t, err.Error(), testCase.errorMessage)
+		})
+	}
+}
+
+func applyPatchHeaderRequest(repo *gitalypb.Repository, user *gitalypb.User, branch string) *gitalypb.UserApplyPatchRequest {
+	header := &gitalypb.UserApplyPatchRequest_Header_{
+		Header: &gitalypb.UserApplyPatchRequest_Header{
+			Repository:   repo,
+			User:         user,
+			TargetBranch: []byte(branch),
+		},
+	}
+	return &gitalypb.UserApplyPatchRequest{
+		UserApplyPatchRequestPayload: header,
+	}
+}
+
+func applyPatchPatchesRequest(patches []byte) *gitalypb.UserApplyPatchRequest {
+	requestPatches := &gitalypb.UserApplyPatchRequest_Patches{
+		Patches: patches,
+	}
+
+	return &gitalypb.UserApplyPatchRequest{
+		UserApplyPatchRequestPayload: requestPatches,
+	}
+}
diff --git a/internal/service/operations/testdata/0001-A-commit-from-a-patch.patch b/internal/service/operations/testdata/0001-A-commit-from-a-patch.patch
new file mode 100644
index 000000000..88a714c63
--- /dev/null
+++ b/internal/service/operations/testdata/0001-A-commit-from-a-patch.patch
@@ -0,0 +1,20 @@
+From 3fee0042e610fb3563e4379e316704cb1210f3de Mon Sep 17 00:00:00 2001
+From: Bob Van Landuyt <bob@vanlanduyt.co>
+Date: Thu, 18 Oct 2018 13:40:35 +0200
+Subject: [PATCH] A commit from a patch
+
+---
+ README | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/README b/README
+index 3742e48..e40a3b9 100644
+--- a/README
++++ b/README
+@@ -1 +1,3 @@
+ Sample repo for testing gitlab features
++
++This was applied in a patch!
+-- 
+2.19.1
+
diff --git a/internal/service/operations/testdata/0001-This-does-not-apply-to-the-feature-branch.patch b/internal/service/operations/testdata/0001-This-does-not-apply-to-the-feature-branch.patch
new file mode 100644
index 000000000..1abcb0e1e
--- /dev/null
+++ b/internal/service/operations/testdata/0001-This-does-not-apply-to-the-feature-branch.patch
@@ -0,0 +1,24 @@
+From 00c68c2b4f954370ce82a1162bc29c13f524897e Mon Sep 17 00:00:00 2001
+From: Bob Van Landuyt <bob@vanlanduyt.co>
+Date: Mon, 22 Oct 2018 11:05:48 +0200
+Subject: [PATCH] This does not apply to the `feature` branch
+
+---
+ files/ruby/feature.rb | 5 +++++
+ 1 file changed, 5 insertions(+)
+ create mode 100644 files/ruby/feature.rb
+
+diff --git a/files/ruby/feature.rb b/files/ruby/feature.rb
+new file mode 100644
+index 0000000..fef26e4
+--- /dev/null
++++ b/files/ruby/feature.rb
+@@ -0,0 +1,5 @@
++class Feature
++  def bar
++    puts 'foo'
++  end
++end
+-- 
+2.19.1
+
diff --git a/ruby/Gemfile b/ruby/Gemfile
index 44accc405..75792782f 100644
--- a/ruby/Gemfile
+++ b/ruby/Gemfile
@@ -6,7 +6,7 @@ gem 'bundler', '>= 1.16.5'
 gem 'rugged', '~> 0.27'
 gem 'github-linguist', '~> 6.1', require: 'linguist'
 gem 'gitlab-markup', '~> 1.6.4'
-gem 'gitaly-proto', '~> 0.116.0', require: 'gitaly'
+gem 'gitaly-proto', '~> 0.121.0', require: 'gitaly'
 gem 'activesupport', '~> 5.0.2'
 gem 'rdoc', '~> 4.2'
 gem 'gitlab-gollum-lib', '~> 4.2', require: false
diff --git a/ruby/Gemfile.lock b/ruby/Gemfile.lock
index 20c316515..6b015029b 100644
--- a/ruby/Gemfile.lock
+++ b/ruby/Gemfile.lock
@@ -18,9 +18,8 @@ GEM
       multipart-post (>= 1.2, < 3)
     gemojione (3.3.0)
       json
-    gitaly-proto (0.116.0)
-      google-protobuf (~> 3.1)
-      grpc (~> 1.10)
+    gitaly-proto (0.121.0)
+      grpc (~> 1.0)
     github-linguist (6.2.0)
       charlock_holmes (~> 0.7.6)
       escape_utils (~> 1.2.0)
@@ -117,7 +116,7 @@ DEPENDENCIES
   bundler (>= 1.16.5)
   factory_bot
   faraday (~> 0.12)
-  gitaly-proto (~> 0.116.0)
+  gitaly-proto (~> 0.121.0)
   github-linguist (~> 6.1)
   gitlab-gollum-lib (~> 4.2)
   gitlab-gollum-rugged_adapter (~> 0.4.4)
diff --git a/ruby/lib/gitaly_server/operations_service.rb b/ruby/lib/gitaly_server/operations_service.rb
index 7b5555cc1..af73d72cf 100644
--- a/ruby/lib/gitaly_server/operations_service.rb
+++ b/ruby/lib/gitaly_server/operations_service.rb
@@ -298,6 +298,28 @@ module GitalyServer
       end
     end
 
+    def user_apply_patch(call)
+      bridge_exceptions do
+        stream = call.each_remote_read
+        first_request = stream.next
+
+        header = first_request.header
+        user = Gitlab::Git::User.from_gitaly(header.user)
+        target_branch = header.target_branch
+        patches = stream.lazy.map(&:patches)
+
+        branch_update = Gitlab::Git::Repository.from_gitaly_with_block(header.repository, call) do |repo|
+          begin
+            Gitlab::Git::CommitPatches.new(user, repo, target_branch, patches).commit
+          rescue Gitlab::Git::PatchError => e
+            raise GRPC::FailedPrecondition.new(e.message)
+          end
+        end
+
+        Gitaly::UserApplyPatchResponse.new(branch_update: branch_update_result(branch_update))
+      end
+    end
+
     private
 
     def commit_files_opts(call, header, actions)
diff --git a/ruby/lib/gitlab/git.rb b/ruby/lib/gitlab/git.rb
index 24ef40cfd..ce7fc4b2c 100644
--- a/ruby/lib/gitlab/git.rb
+++ b/ruby/lib/gitlab/git.rb
@@ -61,6 +61,7 @@ module Gitlab
     OSError = Class.new(BaseError)
     UnknownRef = Class.new(BaseError)
     PreReceiveError = Class.new(BaseError)
+    PatchError = Class.new(BaseError)
 
     class << self
       include Gitlab::EncodingHelper
diff --git a/ruby/lib/gitlab/git/commit_patches.rb b/ruby/lib/gitlab/git/commit_patches.rb
new file mode 100644
index 000000000..137fb2343
--- /dev/null
+++ b/ruby/lib/gitlab/git/commit_patches.rb
@@ -0,0 +1,22 @@
+module Gitlab
+  module Git
+    class CommitPatches
+      attr_reader :user, :repository, :branch_name, :patches
+
+      def initialize(user, repository, branch_name, patches)
+        @user = user
+        @branch_name = branch_name
+        @patches = patches
+        @repository = repository
+      end
+
+      def commit
+        start_point = repository.find_branch(branch_name)&.target || repository.root_ref
+
+        OperationService.new(user, repository).with_branch(branch_name) do
+          repository.commit_patches(start_point, patches, extra_env: user.git_env)
+        end
+      end
+    end
+  end
+end
diff --git a/ruby/lib/gitlab/git/repository.rb b/ruby/lib/gitlab/git/repository.rb
index b7fc6ecbe..801a1ac88 100644
--- a/ruby/lib/gitlab/git/repository.rb
+++ b/ruby/lib/gitlab/git/repository.rb
@@ -1,3 +1,5 @@
+require 'securerandom'
+
 module Gitlab
   module Git
     # These are monkey patches on top of the vendored version of Repository.
@@ -20,6 +22,7 @@ module Gitlab
       # or things will break! (REBASE_WORKTREE_PREFIX and SQUASH_WORKTREE_PREFIX)
       REBASE_WORKTREE_PREFIX = 'rebase'.freeze
       SQUASH_WORKTREE_PREFIX = 'squash'.freeze
+      AM_WORKTREE_PREFIX = 'am'.freeze
       GITALY_INTERNAL_URL = 'ssh://gitaly/internal.git'.freeze
       GITLAB_PROJECTS_TIMEOUT = Gitlab.config.gitlab_shell.git_timeout
       AUTOCRLF_VALUES = { 'true' => true, 'false' => false, 'input' => :input }.freeze
@@ -46,9 +49,11 @@ module Gitlab
         def from_gitaly_with_block(gitaly_repository, call)
           repository = from_gitaly(gitaly_repository, call)
 
-          yield repository
+          result = yield repository
 
           repository.cleanup
+
+          result
         end
 
         def create(repo_path)
@@ -433,7 +438,7 @@ module Gitlab
 
       def rebase(user, rebase_id, branch:, branch_sha:, remote_repository:, remote_branch:)
         rebase_path = worktree_path(REBASE_WORKTREE_PREFIX, rebase_id)
-        env = git_env_for_user(user)
+        env = git_env.merge(user.git_env)
 
         if remote_repository.is_a?(RemoteRepository)
           env.merge!(remote_repository.fetch_env)
@@ -458,7 +463,7 @@ module Gitlab
 
       def squash(user, squash_id, branch:, start_sha:, end_sha:, author:, message:)
         squash_path = worktree_path(SQUASH_WORKTREE_PREFIX, squash_id)
-        env = git_env_for_user(user).merge(
+        env = git_env.merge(user.git_env).merge(
           'GIT_AUTHOR_NAME' => author.name,
           'GIT_AUTHOR_EMAIL' => author.email
         )
@@ -488,6 +493,23 @@ module Gitlab
         end
       end
 
+      def commit_patches(start_point, patches, extra_env: {})
+        worktree_path = worktree_path(AM_WORKTREE_PREFIX, SecureRandom.hex)
+        env = git_env.merge(extra_env)
+
+        with_worktree(worktree_path, start_point, env: env) do
+          result, status = run_git(%w[am --quiet --3way], chdir: worktree_path) do |stdin|
+            loop { stdin.write(patches.next) }
+          end
+
+          raise Gitlab::Git::PatchError, result unless status == 0
+
+          run_git!(
+            %w[rev-parse --quiet --verify HEAD], chdir: worktree_path, env: env
+          ).chomp
+        end
+      end
+
       def push_remote_branches(remote_name, branch_names, forced: true)
         success = @gitlab_projects.push_branches(remote_name, GITLAB_PROJECTS_TIMEOUT, forced, branch_names)
 
@@ -815,11 +837,8 @@ module Gitlab
         output
       end
 
-      def git_env_for_user(user)
+      def git_env
         {
-          'GIT_COMMITTER_NAME' => user.name,
-          'GIT_COMMITTER_EMAIL' => user.email,
-          'GL_ID' => Gitlab::GlId.gl_id(user),
           'GL_PROTOCOL' => Gitlab::Git::Hook::GL_PROTOCOL,
           'GL_REPOSITORY' => gl_repository
         }
diff --git a/ruby/lib/gitlab/git/user.rb b/ruby/lib/gitlab/git/user.rb
index e573cd0e1..41e14dca8 100644
--- a/ruby/lib/gitlab/git/user.rb
+++ b/ruby/lib/gitlab/git/user.rb
@@ -30,6 +30,14 @@ module Gitlab
       def to_gitaly
         Gitaly::User.new(gl_username: username, gl_id: gl_id, name: name.b, email: email.b)
       end
+
+      def git_env
+        {
+          'GIT_COMMITTER_NAME' => name,
+          'GIT_COMMITTER_EMAIL' => email,
+          'GL_ID' => Gitlab::GlId.gl_id(self)
+        }
+      end
     end
   end
 end
diff --git a/ruby/spec/lib/gitlab/git/commit_patches_spec.rb b/ruby/spec/lib/gitlab/git/commit_patches_spec.rb
new file mode 100644
index 000000000..e79cf4331
--- /dev/null
+++ b/ruby/spec/lib/gitlab/git/commit_patches_spec.rb
@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Gitlab::Git::CommitPatches do
+  include TestRepo
+
+  describe "#commit" do
+    let(:repository) { gitlab_git_from_gitaly(new_mutable_test_repo) }
+    let(:testdata_dir) { File.join(File.dirname(__FILE__), '../../../../../internal/service/operations/testdata') }
+    let(:patches) { File.foreach(File.join(testdata_dir, patch_file_name)) }
+    let(:user) { Gitlab::Git::User.new('jane', 'Jane Doe', 'jane@doe.org', '123') }
+
+    def apply_patches(branch_name)
+      described_class.new(user, repository, branch_name, patches).commit
+    end
+
+    context 'when the patch applies' do
+      let(:patch_file_name) { '0001-A-commit-from-a-patch.patch' }
+
+      it 'creates the branch and applies the patch' do
+        branch_update = apply_patches('patched_branch')
+        commit = repository.commit(branch_update.newrev)
+
+        expect(commit.message).to eq("A commit from a patch\n")
+        expect(branch_update).to be_branch_created
+      end
+
+      it 'updates the branch if it already existed' do
+        branch_update = apply_patches('feature')
+        commit = repository.commit(branch_update.newrev)
+
+        expect(commit.message).to eq("A commit from a patch\n")
+        expect(branch_update).not_to be_branch_created
+      end
+    end
+
+    context 'when the patch does not apply' do
+      let(:patch_file_name) { '0001-This-does-not-apply-to-the-feature-branch.patch' }
+
+      it 'raises a PatchError' do
+        expect { apply_patches('feature') }.to raise_error Gitlab::Git::PatchError
+      end
+
+      it 'does not update the branch' do
+        expect do
+          begin
+            apply_patches('feature')
+          rescue Gitlab::Git::PatchError => e
+            e
+          end
+        end.not_to(change { repository.find_branch('feature').target })
+      end
+
+      it 'does not leave branches dangling' do
+        expect do
+          begin
+            apply_patches('feature')
+          rescue Gitlab::Git::PatchError => e
+            e
+          end
+        end.not_to(change { repository.branches.size })
+      end
+    end
+  end
+end
diff --git a/ruby/spec/lib/gitlab/git/repository_spec.rb b/ruby/spec/lib/gitlab/git/repository_spec.rb
index f7464b837..2b9f77abb 100644
--- a/ruby/spec/lib/gitlab/git/repository_spec.rb
+++ b/ruby/spec/lib/gitlab/git/repository_spec.rb
@@ -31,6 +31,12 @@ describe Gitlab::Git::Repository do
         expect(repository.rugged).to receive(:close)
       end
     end
+
+    it 'returns the passed result of the block passed' do
+      result = described_class.from_gitaly_with_block(test_repo_read_only, call) { 'Hello world' }
+
+      expect(result).to eq('Hello world')
+    end
   end
 
   describe '#cleanup' do
@@ -112,4 +118,34 @@ describe Gitlab::Git::Repository do
       end
     end
   end
+
+  describe "#commit_patches" do
+    let(:repository) { gitlab_git_from_gitaly(new_mutable_test_repo) }
+    let(:testdata_dir) { File.join(File.dirname(__FILE__), '../../../../../internal/service/operations/testdata') }
+    let(:patches) { File.foreach(File.join(testdata_dir, patch_file_name)) }
+
+    def apply_patches(branch_name)
+      repository.commit_patches(branch_name, patches)
+    end
+
+    context 'when the patch applies' do
+      let(:patch_file_name) { '0001-A-commit-from-a-patch.patch' }
+
+      it 'creates a new rev with the patch' do
+        new_rev = apply_patches(repository.root_ref)
+        commit = repository.commit(new_rev)
+
+        expect(new_rev).not_to be_nil
+        expect(commit.message).to eq("A commit from a patch\n")
+      end
+    end
+
+    context 'when the patch does not apply' do
+      let(:patch_file_name) { '0001-This-does-not-apply-to-the-feature-branch.patch' }
+
+      it 'raises a PatchError' do
+        expect { apply_patches('feature') }.to raise_error Gitlab::Git::PatchError
+      end
+    end
+  end
 end
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/blob.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/blob.pb.go
index 507883ee4..99b674910 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/blob.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/blob.pb.go
@@ -135,6 +135,8 @@ It has these top-level messages:
 	UserRebaseResponse
 	UserSquashRequest
 	UserSquashResponse
+	UserApplyPatchRequest
+	UserApplyPatchResponse
 	ListNewBlobsRequest
 	ListNewBlobsResponse
 	FindDefaultBranchNameRequest
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/diff.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/diff.pb.go
index a4ae94db6..6d59b34cc 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/diff.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/diff.pb.go
@@ -25,15 +25,18 @@ type CommitDiffRequest struct {
 	Paths                  [][]byte    `protobuf:"bytes,5,rep,name=paths,proto3" json:"paths,omitempty"`
 	CollapseDiffs          bool        `protobuf:"varint,6,opt,name=collapse_diffs,json=collapseDiffs" json:"collapse_diffs,omitempty"`
 	EnforceLimits          bool        `protobuf:"varint,7,opt,name=enforce_limits,json=enforceLimits" json:"enforce_limits,omitempty"`
-	MaxFiles               int32       `protobuf:"varint,8,opt,name=max_files,json=maxFiles" json:"max_files,omitempty"`
-	MaxLines               int32       `protobuf:"varint,9,opt,name=max_lines,json=maxLines" json:"max_lines,omitempty"`
-	MaxBytes               int32       `protobuf:"varint,10,opt,name=max_bytes,json=maxBytes" json:"max_bytes,omitempty"`
-	SafeMaxFiles           int32       `protobuf:"varint,11,opt,name=safe_max_files,json=safeMaxFiles" json:"safe_max_files,omitempty"`
-	SafeMaxLines           int32       `protobuf:"varint,12,opt,name=safe_max_lines,json=safeMaxLines" json:"safe_max_lines,omitempty"`
-	SafeMaxBytes           int32       `protobuf:"varint,13,opt,name=safe_max_bytes,json=safeMaxBytes" json:"safe_max_bytes,omitempty"`
+	// These limits are only enforced when enforce_limits == true.
+	MaxFiles int32 `protobuf:"varint,8,opt,name=max_files,json=maxFiles" json:"max_files,omitempty"`
+	MaxLines int32 `protobuf:"varint,9,opt,name=max_lines,json=maxLines" json:"max_lines,omitempty"`
+	MaxBytes int32 `protobuf:"varint,10,opt,name=max_bytes,json=maxBytes" json:"max_bytes,omitempty"`
 	// Limitation of a single diff patch,
 	// patches surpassing this limit are pruned by default.
+	// If this is 0 you will get back empty patches.
 	MaxPatchBytes int32 `protobuf:"varint,14,opt,name=max_patch_bytes,json=maxPatchBytes" json:"max_patch_bytes,omitempty"`
+	// These limits are only enforced if collapse_diffs == true.
+	SafeMaxFiles int32 `protobuf:"varint,11,opt,name=safe_max_files,json=safeMaxFiles" json:"safe_max_files,omitempty"`
+	SafeMaxLines int32 `protobuf:"varint,12,opt,name=safe_max_lines,json=safeMaxLines" json:"safe_max_lines,omitempty"`
+	SafeMaxBytes int32 `protobuf:"varint,13,opt,name=safe_max_bytes,json=safeMaxBytes" json:"safe_max_bytes,omitempty"`
 }
 
 func (m *CommitDiffRequest) Reset()                    { *m = CommitDiffRequest{} }
@@ -111,6 +114,13 @@ func (m *CommitDiffRequest) GetMaxBytes() int32 {
 	return 0
 }
 
+func (m *CommitDiffRequest) GetMaxPatchBytes() int32 {
+	if m != nil {
+		return m.MaxPatchBytes
+	}
+	return 0
+}
+
 func (m *CommitDiffRequest) GetSafeMaxFiles() int32 {
 	if m != nil {
 		return m.SafeMaxFiles
@@ -132,13 +142,6 @@ func (m *CommitDiffRequest) GetSafeMaxBytes() int32 {
 	return 0
 }
 
-func (m *CommitDiffRequest) GetMaxPatchBytes() int32 {
-	if m != nil {
-		return m.MaxPatchBytes
-	}
-	return 0
-}
-
 // A CommitDiffResponse corresponds to a single changed file in a commit.
 type CommitDiffResponse struct {
 	FromPath []byte `protobuf:"bytes,1,opt,name=from_path,json=fromPath,proto3" json:"from_path,omitempty"`
@@ -1004,58 +1007,58 @@ func init() { proto.RegisterFile("diff.proto", fileDescriptor3) }
 
 var fileDescriptor3 = []byte{
 	// 864 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0x4d, 0x6f, 0xe3, 0x44,
-	0x18, 0xc6, 0xcd, 0x47, 0x9d, 0x37, 0x6e, 0xda, 0x4e, 0x51, 0xd7, 0xcd, 0x72, 0x88, 0x2c, 0xb6,
-	0x1b, 0x84, 0x54, 0xa1, 0x72, 0xe1, 0x80, 0x90, 0xd8, 0xad, 0x40, 0x5d, 0xb5, 0x62, 0x65, 0x0e,
-	0x1c, 0x38, 0x58, 0xd3, 0xcc, 0x38, 0x1e, 0x61, 0x7b, 0xc2, 0xcc, 0xd0, 0xb4, 0x7f, 0x03, 0xf8,
-	0x09, 0x48, 0x5c, 0xb8, 0xf3, 0xd7, 0x38, 0xa2, 0x79, 0xc7, 0x5f, 0x69, 0xa3, 0xbd, 0xec, 0x1e,
-	0x7a, 0xcb, 0xfb, 0x3c, 0x8f, 0xdf, 0xef, 0x77, 0x5a, 0x00, 0x26, 0xd2, 0xf4, 0x6c, 0xa5, 0xa4,
-	0x91, 0x64, 0xb8, 0x14, 0x86, 0xe6, 0xf7, 0xd3, 0x40, 0x67, 0x54, 0x71, 0xe6, 0xd0, 0xe8, 0xaf,
-	0x3e, 0x1c, 0xbe, 0x96, 0x45, 0x21, 0xcc, 0x85, 0x48, 0xd3, 0x98, 0xff, 0xfa, 0x1b, 0xd7, 0x86,
-	0x9c, 0x03, 0x28, 0xbe, 0x92, 0x5a, 0x18, 0xa9, 0xee, 0x43, 0x6f, 0xe6, 0xcd, 0xc7, 0xe7, 0xe4,
-	0xcc, 0x39, 0x38, 0x8b, 0x1b, 0x26, 0xee, 0xa8, 0xc8, 0xa7, 0x30, 0xc9, 0x79, 0x6a, 0x92, 0x05,
-	0x7a, 0x4b, 0x04, 0x0b, 0x77, 0x66, 0xde, 0x7c, 0x14, 0x07, 0x16, 0x75, 0x21, 0x2e, 0x19, 0x39,
-	0x85, 0x7d, 0x25, 0x96, 0x59, 0x57, 0xd6, 0x43, 0xd9, 0x1e, 0xc2, 0x8d, 0xee, 0x2b, 0x08, 0xc5,
-	0xb2, 0x94, 0x8a, 0x27, 0xeb, 0x4c, 0x18, 0xae, 0x57, 0x74, 0xc1, 0x93, 0x45, 0x46, 0xcb, 0x25,
-	0x0f, 0xfb, 0x33, 0x6f, 0xee, 0xc7, 0xc7, 0x8e, 0xff, 0xa9, 0xa1, 0x5f, 0x23, 0x4b, 0x3e, 0x86,
-	0xc1, 0x8a, 0x9a, 0x4c, 0x87, 0x83, 0x59, 0x6f, 0x1e, 0xc4, 0xce, 0x20, 0x2f, 0x60, 0xb2, 0x90,
-	0x79, 0x4e, 0x57, 0x9a, 0x27, 0xb6, 0x29, 0x3a, 0x1c, 0xa2, 0x97, 0xbd, 0x1a, 0xb5, 0xe5, 0xa3,
-	0x8c, 0x97, 0xa9, 0x54, 0x0b, 0x9e, 0xe4, 0xa2, 0x10, 0x46, 0x87, 0xbb, 0x4e, 0x56, 0xa1, 0x57,
-	0x08, 0x92, 0xe7, 0x30, 0x2a, 0xe8, 0x5d, 0x92, 0x8a, 0x9c, 0xeb, 0xd0, 0x9f, 0x79, 0xf3, 0x41,
-	0xec, 0x17, 0xf4, 0xee, 0x3b, 0x6b, 0xd7, 0x64, 0x2e, 0x4a, 0xae, 0xc3, 0x51, 0x43, 0x5e, 0x59,
-	0xbb, 0x26, 0x6f, 0xee, 0x0d, 0xd7, 0x21, 0x34, 0xe4, 0x2b, 0x6b, 0xdb, 0x16, 0x6a, 0x9a, 0xf2,
-	0xa4, 0xf5, 0x3d, 0x46, 0x45, 0x60, 0xd1, 0xeb, 0xda, 0x7f, 0x57, 0xe5, 0x82, 0x04, 0x1b, 0x2a,
-	0x17, 0xa8, 0xab, 0x72, 0xd1, 0xf6, 0x36, 0x54, 0x2e, 0xe2, 0x29, 0xec, 0x5b, 0xc1, 0x8a, 0x9a,
-	0x45, 0x56, 0xc9, 0x26, 0x28, 0xdb, 0x2b, 0xe8, 0xdd, 0x5b, 0x8b, 0xa2, 0x2e, 0xfa, 0x6f, 0x07,
-	0x48, 0x77, 0x4d, 0xf4, 0x4a, 0x96, 0x9a, 0xdb, 0x6a, 0x52, 0x25, 0x0b, 0xfb, 0x7d, 0x86, 0x6b,
-	0x12, 0xc4, 0xbe, 0x05, 0xde, 0x52, 0x93, 0x91, 0x67, 0xb0, 0x6b, 0xa4, 0xa3, 0x76, 0x90, 0x1a,
-	0x1a, 0x59, 0x13, 0xf8, 0x55, 0x33, 0xfb, 0xa1, 0x35, 0x2f, 0x19, 0x39, 0x82, 0x81, 0x91, 0x16,
-	0xee, 0x23, 0xdc, 0x37, 0xf2, 0x92, 0x91, 0x13, 0xf0, 0x65, 0xce, 0x92, 0x42, 0x32, 0x1e, 0x0e,
-	0x30, 0xb7, 0x5d, 0x99, 0xb3, 0x6b, 0xc9, 0xb8, 0xa5, 0x4a, 0xbe, 0x76, 0xd4, 0xd0, 0x51, 0x25,
-	0x5f, 0x23, 0x75, 0x0c, 0xc3, 0x1b, 0x51, 0x52, 0x75, 0x5f, 0x0d, 0xb0, 0xb2, 0x6c, 0x5b, 0x14,
-	0x5d, 0x57, 0x05, 0x33, 0x6a, 0x28, 0x4e, 0x28, 0x88, 0x03, 0x45, 0xd7, 0x58, 0xef, 0x05, 0x35,
-	0x94, 0xcc, 0x20, 0xe0, 0x25, 0x4b, 0x64, 0xea, 0x84, 0x38, 0x28, 0x3f, 0x06, 0x5e, 0xb2, 0x1f,
-	0x52, 0x54, 0x91, 0x97, 0xb0, 0x2f, 0x6f, 0xb9, 0x4a, 0x73, 0xb9, 0x4e, 0x0a, 0xaa, 0x7e, 0xe1,
-	0x0a, 0x67, 0xe5, 0xc7, 0x93, 0x1a, 0xbe, 0x46, 0x94, 0x7c, 0x02, 0xa3, 0x7a, 0xc5, 0x18, 0x0e,
-	0xca, 0x8f, 0x5b, 0xc0, 0x36, 0xd0, 0x48, 0x99, 0xe4, 0x54, 0x2d, 0x39, 0x0e, 0xc8, 0x8f, 0x7d,
-	0x23, 0xe5, 0x95, 0xb5, 0xdf, 0xf4, 0x7d, 0xff, 0x60, 0x14, 0xfd, 0xe3, 0x35, 0xad, 0xe7, 0xb9,
-	0xa1, 0x4f, 0xe7, 0x44, 0x9b, 0x43, 0xeb, 0x77, 0x0e, 0x2d, 0xfa, 0xdb, 0x83, 0x71, 0x27, 0xdd,
-	0xa7, 0xbb, 0x22, 0xd1, 0x2b, 0x38, 0xda, 0xe8, 0x6b, 0xb5, 0xd3, 0x9f, 0xc3, 0x90, 0x59, 0x40,
-	0x87, 0xde, 0xac, 0x37, 0x1f, 0x9f, 0x1f, 0xd5, 0x4d, 0xed, 0x8a, 0x2b, 0x49, 0xc4, 0xea, 0xd9,
-	0xe0, 0x56, 0xbc, 0xcf, 0x6c, 0xa6, 0xe0, 0x2b, 0x7e, 0x2b, 0xb4, 0x90, 0x65, 0xd5, 0x8b, 0xc6,
-	0x8e, 0x3e, 0xab, 0x33, 0xad, 0xa2, 0x54, 0x99, 0x12, 0xe8, 0xe3, 0x06, 0xbb, 0xae, 0xe2, 0xef,
-	0xe8, 0x77, 0x0f, 0x26, 0x31, 0x5d, 0x3f, 0xa9, 0xc7, 0x3c, 0x7a, 0x01, 0xfb, 0x4d, 0x4e, 0xef,
-	0xc8, 0xfd, 0x0f, 0x0f, 0x75, 0xef, 0xdd, 0xca, 0x0f, 0x9b, 0xfc, 0x29, 0x1c, 0xb4, 0x49, 0xbd,
-	0x23, 0xfb, 0x3f, 0x3d, 0x38, 0xb0, 0x25, 0xfe, 0x68, 0xa8, 0xd1, 0x4f, 0x27, 0xfd, 0x9f, 0x61,
-	0xd4, 0x64, 0x65, 0xf3, 0xee, 0xdc, 0x21, 0xfe, 0xb6, 0x0f, 0x14, 0x65, 0x4c, 0x18, 0x21, 0x4b,
-	0x8d, 0x91, 0x06, 0x71, 0x0b, 0x58, 0x96, 0xf1, 0x9c, 0x3b, 0xb6, 0xe7, 0xd8, 0x06, 0x88, 0xbe,
-	0x86, 0xc3, 0x4e, 0xc9, 0x55, 0x73, 0x5e, 0xc2, 0x40, 0x5b, 0xa0, 0xba, 0x9f, 0xc3, 0xba, 0xdc,
-	0x56, 0xe9, 0xf8, 0xf3, 0x7f, 0x7b, 0x30, 0x46, 0x90, 0xab, 0x5b, 0xb1, 0xe0, 0xe4, 0x7b, 0x80,
-	0xf6, 0x6f, 0x0c, 0x39, 0x79, 0x70, 0x77, 0xed, 0x46, 0x4f, 0xa7, 0xdb, 0x28, 0x17, 0x3d, 0xfa,
-	0xe8, 0x0b, 0x8f, 0xbc, 0xd9, 0x7c, 0x82, 0xa6, 0xdb, 0x2e, 0xb8, 0x72, 0xf5, 0x7c, 0x2b, 0xb7,
-	0xcd, 0x97, 0x7b, 0xf7, 0x1f, 0xf8, 0xea, 0xee, 0xea, 0x43, 0x5f, 0x1b, 0x2b, 0x83, 0xbe, 0xbe,
-	0x81, 0xdd, 0xea, 0x0e, 0xc8, 0x71, 0xb3, 0x04, 0x1b, 0xc7, 0x3a, 0x7d, 0xf6, 0x08, 0xef, 0x7c,
-	0xff, 0x2d, 0xf8, 0xf5, 0x2a, 0x92, 0xae, 0x70, 0x23, 0x8b, 0xf0, 0x31, 0xd1, 0x71, 0x71, 0xd1,
-	0x5d, 0x87, 0xf0, 0xf1, 0x68, 0x2a, 0x27, 0x27, 0x5b, 0x98, 0xd6, 0xcb, 0xcd, 0x10, 0xff, 0x79,
-	0xfc, 0xf2, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x4e, 0x5a, 0xc7, 0xa7, 0x60, 0x0a, 0x00, 0x00,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0xcb, 0x6e, 0x23, 0x45,
+	0x14, 0xa5, 0xe3, 0x47, 0xda, 0xd7, 0x1d, 0x27, 0xa9, 0xa0, 0x4c, 0xc7, 0xc3, 0xc2, 0x6a, 0xcd,
+	0xc3, 0x08, 0x29, 0x42, 0x61, 0xc3, 0x02, 0x21, 0x31, 0x13, 0x81, 0x32, 0x4a, 0xc4, 0xa8, 0x59,
+	0xb0, 0x60, 0xd1, 0xaa, 0xb8, 0xaa, 0xdd, 0x25, 0xba, 0xbb, 0x4c, 0x55, 0x11, 0x27, 0xbf, 0x01,
+	0x7c, 0x02, 0x12, 0x1b, 0xf6, 0xfc, 0x1a, 0x4b, 0x54, 0xb7, 0xfa, 0xe5, 0xc4, 0x9a, 0x4d, 0x58,
+	0x64, 0xe7, 0x7b, 0xce, 0xe9, 0x5b, 0xa7, 0xee, 0xa3, 0x12, 0x00, 0x26, 0xd2, 0xf4, 0x74, 0xa5,
+	0xa4, 0x91, 0x64, 0xb8, 0x14, 0x86, 0xe6, 0x77, 0xd3, 0x40, 0x67, 0x54, 0x71, 0xe6, 0xd0, 0xe8,
+	0xcf, 0x3e, 0x1c, 0xbe, 0x95, 0x45, 0x21, 0xcc, 0xb9, 0x48, 0xd3, 0x98, 0xff, 0xf2, 0x2b, 0xd7,
+	0x86, 0x9c, 0x01, 0x28, 0xbe, 0x92, 0x5a, 0x18, 0xa9, 0xee, 0x42, 0x6f, 0xe6, 0xcd, 0xc7, 0x67,
+	0xe4, 0xd4, 0x25, 0x38, 0x8d, 0x1b, 0x26, 0xee, 0xa8, 0xc8, 0x0b, 0x98, 0xe4, 0x3c, 0x35, 0xc9,
+	0x02, 0xb3, 0x25, 0x82, 0x85, 0x3b, 0x33, 0x6f, 0x3e, 0x8a, 0x03, 0x8b, 0xba, 0x23, 0x2e, 0x18,
+	0x79, 0x05, 0xfb, 0x4a, 0x2c, 0xb3, 0xae, 0xac, 0x87, 0xb2, 0x3d, 0x84, 0x1b, 0xdd, 0x97, 0x10,
+	0x8a, 0x65, 0x29, 0x15, 0x4f, 0xd6, 0x99, 0x30, 0x5c, 0xaf, 0xe8, 0x82, 0x27, 0x8b, 0x8c, 0x96,
+	0x4b, 0x1e, 0xf6, 0x67, 0xde, 0xdc, 0x8f, 0x8f, 0x1d, 0xff, 0x63, 0x43, 0xbf, 0x45, 0x96, 0x7c,
+	0x0c, 0x83, 0x15, 0x35, 0x99, 0x0e, 0x07, 0xb3, 0xde, 0x3c, 0x88, 0x5d, 0x40, 0x5e, 0xc2, 0x64,
+	0x21, 0xf3, 0x9c, 0xae, 0x34, 0x4f, 0x6c, 0x51, 0x74, 0x38, 0xc4, 0x2c, 0x7b, 0x35, 0x6a, 0xaf,
+	0x8f, 0x32, 0x5e, 0xa6, 0x52, 0x2d, 0x78, 0x92, 0x8b, 0x42, 0x18, 0x1d, 0xee, 0x3a, 0x59, 0x85,
+	0x5e, 0x22, 0x48, 0x9e, 0xc3, 0xa8, 0xa0, 0xb7, 0x49, 0x2a, 0x72, 0xae, 0x43, 0x7f, 0xe6, 0xcd,
+	0x07, 0xb1, 0x5f, 0xd0, 0xdb, 0x6f, 0x6d, 0x5c, 0x93, 0xb9, 0x28, 0xb9, 0x0e, 0x47, 0x0d, 0x79,
+	0x69, 0xe3, 0x9a, 0xbc, 0xbe, 0x33, 0x5c, 0x87, 0xd0, 0x90, 0x6f, 0x6c, 0x6c, 0x8b, 0x63, 0xc9,
+	0x15, 0x35, 0x8b, 0xac, 0x92, 0x4c, 0x50, 0xb2, 0x57, 0xd0, 0xdb, 0xf7, 0x16, 0x75, 0xba, 0x17,
+	0x30, 0xd1, 0x34, 0xe5, 0x49, 0xeb, 0x61, 0x8c, 0xb2, 0xc0, 0xa2, 0x57, 0xb5, 0x8f, 0xae, 0xca,
+	0x99, 0x09, 0x36, 0x54, 0xce, 0x50, 0x57, 0xe5, 0x8e, 0xdc, 0xdb, 0x50, 0xe1, 0x89, 0xd1, 0xbf,
+	0x3b, 0x40, 0xba, 0x63, 0xa2, 0x57, 0xb2, 0xd4, 0xdc, 0xde, 0x26, 0x55, 0xb2, 0xb0, 0x8e, 0x33,
+	0x1c, 0x93, 0x20, 0xf6, 0x2d, 0xf0, 0x9e, 0x9a, 0x8c, 0x3c, 0x83, 0x5d, 0x23, 0x1d, 0xb5, 0x83,
+	0xd4, 0xd0, 0xc8, 0x9a, 0xc0, 0xaf, 0x9a, 0xde, 0x0f, 0x6d, 0x78, 0xc1, 0xc8, 0x11, 0x0c, 0x8c,
+	0xb4, 0x70, 0x1f, 0xe1, 0xbe, 0x91, 0x17, 0x8c, 0x9c, 0x80, 0x2f, 0x73, 0x96, 0x14, 0x92, 0xf1,
+	0x70, 0x80, 0xd6, 0x76, 0x65, 0xce, 0xae, 0x24, 0xe3, 0x96, 0x2a, 0xf9, 0xda, 0x51, 0x43, 0x47,
+	0x95, 0x7c, 0x8d, 0xd4, 0x31, 0x0c, 0xaf, 0x45, 0x49, 0xd5, 0x5d, 0xd5, 0xc0, 0x2a, 0xb2, 0xd7,
+	0x55, 0x74, 0x5d, 0x95, 0x98, 0x51, 0x43, 0xb1, 0x43, 0x41, 0x1c, 0x28, 0xba, 0xc6, 0x0a, 0x9f,
+	0x53, 0x43, 0xc9, 0x0c, 0x02, 0x5e, 0xb2, 0x44, 0xa6, 0x4e, 0x88, 0x8d, 0xf2, 0x63, 0xe0, 0x25,
+	0xfb, 0x3e, 0x45, 0x15, 0x79, 0x0d, 0xfb, 0xf2, 0x86, 0xab, 0x34, 0x97, 0xeb, 0xa4, 0xa0, 0xea,
+	0x67, 0xae, 0xb0, 0x07, 0x7e, 0x3c, 0xa9, 0xe1, 0x2b, 0x44, 0xc9, 0x27, 0x30, 0xaa, 0x47, 0x8c,
+	0x61, 0x03, 0xfc, 0xb8, 0x05, 0x6c, 0x01, 0x8d, 0x94, 0x49, 0x4e, 0xd5, 0x92, 0x63, 0xe1, 0xfd,
+	0xd8, 0x37, 0x52, 0x5e, 0xda, 0xf8, 0x5d, 0xdf, 0xf7, 0x0f, 0x46, 0xd1, 0xdf, 0x5e, 0x53, 0x7a,
+	0x9e, 0x1b, 0xfa, 0x74, 0x56, 0xb4, 0x59, 0xb4, 0x7e, 0x67, 0xd1, 0xa2, 0xbf, 0x3c, 0x18, 0x77,
+	0xec, 0x3e, 0xdd, 0x11, 0x89, 0xde, 0xc0, 0xd1, 0x46, 0x5d, 0xab, 0x99, 0xfe, 0x0c, 0x86, 0xcc,
+	0x02, 0x3a, 0xf4, 0x66, 0xbd, 0xf9, 0xf8, 0xec, 0xa8, 0x2e, 0x6a, 0x57, 0x5c, 0x49, 0x22, 0x56,
+	0xf7, 0x06, 0xa7, 0xe2, 0x31, 0xbd, 0x99, 0x82, 0xaf, 0xf8, 0x8d, 0xd0, 0x42, 0x96, 0x55, 0x2d,
+	0x9a, 0x38, 0xfa, 0xb4, 0x76, 0x5a, 0x9d, 0x52, 0x39, 0x25, 0xd0, 0xc7, 0x09, 0x76, 0x55, 0xc5,
+	0xdf, 0xd1, 0x6f, 0x1e, 0x4c, 0x62, 0xba, 0x7e, 0x52, 0x8f, 0x79, 0xf4, 0x12, 0xf6, 0x1b, 0x4f,
+	0x1f, 0xf0, 0xfe, 0xbb, 0x87, 0xba, 0x47, 0x97, 0xf2, 0xff, 0x35, 0xff, 0x0a, 0x0e, 0x5a, 0x53,
+	0x1f, 0x70, 0xff, 0x87, 0x07, 0x07, 0xf6, 0x8a, 0x3f, 0x18, 0x6a, 0xf4, 0xd3, 0xb1, 0xff, 0x13,
+	0x8c, 0x1a, 0x57, 0xd6, 0x77, 0x67, 0x0f, 0xf1, 0xb7, 0x7d, 0xa0, 0x28, 0x63, 0xc2, 0x08, 0x59,
+	0x6a, 0x3c, 0x69, 0x10, 0xb7, 0x80, 0x65, 0x19, 0xcf, 0xb9, 0x63, 0x7b, 0x8e, 0x6d, 0x80, 0xe8,
+	0x2b, 0x38, 0xec, 0x5c, 0xb9, 0x2a, 0xce, 0x6b, 0x18, 0x68, 0x0b, 0x54, 0xfb, 0x73, 0x58, 0x5f,
+	0xb7, 0x55, 0x3a, 0xfe, 0xec, 0x9f, 0x1e, 0x8c, 0x11, 0xe4, 0xea, 0x46, 0x2c, 0x38, 0xf9, 0x0e,
+	0xa0, 0xfd, 0x1b, 0x43, 0x4e, 0xee, 0xed, 0x5d, 0x3b, 0xd1, 0xd3, 0xe9, 0x36, 0xca, 0x9d, 0x1e,
+	0x7d, 0xf4, 0xb9, 0x47, 0xde, 0x6d, 0x3e, 0x41, 0xd3, 0x6d, 0x1b, 0x5c, 0xa5, 0x7a, 0xbe, 0x95,
+	0xdb, 0x96, 0xcb, 0xbd, 0xfb, 0xf7, 0x72, 0x75, 0x67, 0xf5, 0x7e, 0xae, 0x8d, 0x91, 0xc1, 0x5c,
+	0x5f, 0xc3, 0x6e, 0xb5, 0x07, 0xe4, 0xb8, 0x19, 0x82, 0x8d, 0x65, 0x9d, 0x3e, 0x7b, 0x80, 0x77,
+	0xbe, 0xff, 0x06, 0xfc, 0x7a, 0x14, 0x49, 0x57, 0xb8, 0xe1, 0x22, 0x7c, 0x48, 0x74, 0x52, 0x9c,
+	0x77, 0xc7, 0x21, 0x7c, 0xd8, 0x9a, 0x2a, 0xc9, 0xc9, 0x16, 0xa6, 0xcd, 0x72, 0x3d, 0xc4, 0x7f,
+	0x1e, 0xbf, 0xf8, 0x2f, 0x00, 0x00, 0xff, 0xff, 0xbb, 0xf5, 0x8b, 0xe3, 0x60, 0x0a, 0x00, 0x00,
 }
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 9890491d0..7c78f83ea 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
@@ -1338,6 +1338,171 @@ func (m *UserSquashResponse) GetGitError() string {
 	return ""
 }
 
+type UserApplyPatchRequest struct {
+	// Types that are valid to be assigned to UserApplyPatchRequestPayload:
+	//	*UserApplyPatchRequest_Header_
+	//	*UserApplyPatchRequest_Patches
+	UserApplyPatchRequestPayload isUserApplyPatchRequest_UserApplyPatchRequestPayload `protobuf_oneof:"user_apply_patch_request_payload"`
+}
+
+func (m *UserApplyPatchRequest) Reset()                    { *m = UserApplyPatchRequest{} }
+func (m *UserApplyPatchRequest) String() string            { return proto.CompactTextString(m) }
+func (*UserApplyPatchRequest) ProtoMessage()               {}
+func (*UserApplyPatchRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{28} }
+
+type isUserApplyPatchRequest_UserApplyPatchRequestPayload interface{ isUserApplyPatchRequest_UserApplyPatchRequestPayload() }
+
+type UserApplyPatchRequest_Header_ struct {
+	Header *UserApplyPatchRequest_Header `protobuf:"bytes,1,opt,name=header,oneof"`
+}
+type UserApplyPatchRequest_Patches struct {
+	Patches []byte `protobuf:"bytes,2,opt,name=patches,proto3,oneof"`
+}
+
+func (*UserApplyPatchRequest_Header_) isUserApplyPatchRequest_UserApplyPatchRequestPayload() {}
+func (*UserApplyPatchRequest_Patches) isUserApplyPatchRequest_UserApplyPatchRequestPayload() {}
+
+func (m *UserApplyPatchRequest) GetUserApplyPatchRequestPayload() isUserApplyPatchRequest_UserApplyPatchRequestPayload {
+	if m != nil {
+		return m.UserApplyPatchRequestPayload
+	}
+	return nil
+}
+
+func (m *UserApplyPatchRequest) GetHeader() *UserApplyPatchRequest_Header {
+	if x, ok := m.GetUserApplyPatchRequestPayload().(*UserApplyPatchRequest_Header_); ok {
+		return x.Header
+	}
+	return nil
+}
+
+func (m *UserApplyPatchRequest) GetPatches() []byte {
+	if x, ok := m.GetUserApplyPatchRequestPayload().(*UserApplyPatchRequest_Patches); ok {
+		return x.Patches
+	}
+	return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*UserApplyPatchRequest) 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 _UserApplyPatchRequest_OneofMarshaler, _UserApplyPatchRequest_OneofUnmarshaler, _UserApplyPatchRequest_OneofSizer, []interface{}{
+		(*UserApplyPatchRequest_Header_)(nil),
+		(*UserApplyPatchRequest_Patches)(nil),
+	}
+}
+
+func _UserApplyPatchRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*UserApplyPatchRequest)
+	// user_apply_patch_request_payload
+	switch x := m.UserApplyPatchRequestPayload.(type) {
+	case *UserApplyPatchRequest_Header_:
+		b.EncodeVarint(1<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.Header); err != nil {
+			return err
+		}
+	case *UserApplyPatchRequest_Patches:
+		b.EncodeVarint(2<<3 | proto.WireBytes)
+		b.EncodeRawBytes(x.Patches)
+	case nil:
+	default:
+		return fmt.Errorf("UserApplyPatchRequest.UserApplyPatchRequestPayload has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _UserApplyPatchRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*UserApplyPatchRequest)
+	switch tag {
+	case 1: // user_apply_patch_request_payload.header
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(UserApplyPatchRequest_Header)
+		err := b.DecodeMessage(msg)
+		m.UserApplyPatchRequestPayload = &UserApplyPatchRequest_Header_{msg}
+		return true, err
+	case 2: // user_apply_patch_request_payload.patches
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.UserApplyPatchRequestPayload = &UserApplyPatchRequest_Patches{x}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _UserApplyPatchRequest_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*UserApplyPatchRequest)
+	// user_apply_patch_request_payload
+	switch x := m.UserApplyPatchRequestPayload.(type) {
+	case *UserApplyPatchRequest_Header_:
+		s := proto.Size(x.Header)
+		n += proto.SizeVarint(1<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *UserApplyPatchRequest_Patches:
+		n += proto.SizeVarint(2<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.Patches)))
+		n += len(x.Patches)
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+type UserApplyPatchRequest_Header struct {
+	Repository   *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	User         *User       `protobuf:"bytes,2,opt,name=user" json:"user,omitempty"`
+	TargetBranch []byte      `protobuf:"bytes,3,opt,name=target_branch,json=targetBranch,proto3" json:"target_branch,omitempty"`
+}
+
+func (m *UserApplyPatchRequest_Header) Reset()         { *m = UserApplyPatchRequest_Header{} }
+func (m *UserApplyPatchRequest_Header) String() string { return proto.CompactTextString(m) }
+func (*UserApplyPatchRequest_Header) ProtoMessage()    {}
+func (*UserApplyPatchRequest_Header) Descriptor() ([]byte, []int) {
+	return fileDescriptor6, []int{28, 0}
+}
+
+func (m *UserApplyPatchRequest_Header) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *UserApplyPatchRequest_Header) GetUser() *User {
+	if m != nil {
+		return m.User
+	}
+	return nil
+}
+
+func (m *UserApplyPatchRequest_Header) GetTargetBranch() []byte {
+	if m != nil {
+		return m.TargetBranch
+	}
+	return nil
+}
+
+type UserApplyPatchResponse struct {
+	BranchUpdate *OperationBranchUpdate `protobuf:"bytes,1,opt,name=branch_update,json=branchUpdate" json:"branch_update,omitempty"`
+}
+
+func (m *UserApplyPatchResponse) Reset()                    { *m = UserApplyPatchResponse{} }
+func (m *UserApplyPatchResponse) String() string            { return proto.CompactTextString(m) }
+func (*UserApplyPatchResponse) ProtoMessage()               {}
+func (*UserApplyPatchResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{29} }
+
+func (m *UserApplyPatchResponse) GetBranchUpdate() *OperationBranchUpdate {
+	if m != nil {
+		return m.BranchUpdate
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*UserCreateBranchRequest)(nil), "gitaly.UserCreateBranchRequest")
 	proto.RegisterType((*UserCreateBranchResponse)(nil), "gitaly.UserCreateBranchResponse")
@@ -1367,6 +1532,9 @@ func init() {
 	proto.RegisterType((*UserRebaseResponse)(nil), "gitaly.UserRebaseResponse")
 	proto.RegisterType((*UserSquashRequest)(nil), "gitaly.UserSquashRequest")
 	proto.RegisterType((*UserSquashResponse)(nil), "gitaly.UserSquashResponse")
+	proto.RegisterType((*UserApplyPatchRequest)(nil), "gitaly.UserApplyPatchRequest")
+	proto.RegisterType((*UserApplyPatchRequest_Header)(nil), "gitaly.UserApplyPatchRequest.Header")
+	proto.RegisterType((*UserApplyPatchResponse)(nil), "gitaly.UserApplyPatchResponse")
 	proto.RegisterEnum("gitaly.UserCommitFilesActionHeader_ActionType", UserCommitFilesActionHeader_ActionType_name, UserCommitFilesActionHeader_ActionType_value)
 }
 
@@ -1393,6 +1561,7 @@ type OperationServiceClient interface {
 	UserCommitFiles(ctx context.Context, opts ...grpc.CallOption) (OperationService_UserCommitFilesClient, error)
 	UserRebase(ctx context.Context, in *UserRebaseRequest, opts ...grpc.CallOption) (*UserRebaseResponse, error)
 	UserSquash(ctx context.Context, in *UserSquashRequest, opts ...grpc.CallOption) (*UserSquashResponse, error)
+	UserApplyPatch(ctx context.Context, opts ...grpc.CallOption) (OperationService_UserApplyPatchClient, error)
 }
 
 type operationServiceClient struct {
@@ -1558,6 +1727,40 @@ func (c *operationServiceClient) UserSquash(ctx context.Context, in *UserSquashR
 	return out, nil
 }
 
+func (c *operationServiceClient) UserApplyPatch(ctx context.Context, opts ...grpc.CallOption) (OperationService_UserApplyPatchClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_OperationService_serviceDesc.Streams[2], c.cc, "/gitaly.OperationService/UserApplyPatch", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &operationServiceUserApplyPatchClient{stream}
+	return x, nil
+}
+
+type OperationService_UserApplyPatchClient interface {
+	Send(*UserApplyPatchRequest) error
+	CloseAndRecv() (*UserApplyPatchResponse, error)
+	grpc.ClientStream
+}
+
+type operationServiceUserApplyPatchClient struct {
+	grpc.ClientStream
+}
+
+func (x *operationServiceUserApplyPatchClient) Send(m *UserApplyPatchRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *operationServiceUserApplyPatchClient) CloseAndRecv() (*UserApplyPatchResponse, error) {
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	m := new(UserApplyPatchResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // Server API for OperationService service
 
 type OperationServiceServer interface {
@@ -1573,6 +1776,7 @@ type OperationServiceServer interface {
 	UserCommitFiles(OperationService_UserCommitFilesServer) error
 	UserRebase(context.Context, *UserRebaseRequest) (*UserRebaseResponse, error)
 	UserSquash(context.Context, *UserSquashRequest) (*UserSquashResponse, error)
+	UserApplyPatch(OperationService_UserApplyPatchServer) error
 }
 
 func RegisterOperationServiceServer(s *grpc.Server, srv OperationServiceServer) {
@@ -1811,6 +2015,32 @@ func _OperationService_UserSquash_Handler(srv interface{}, ctx context.Context,
 	return interceptor(ctx, in, info, handler)
 }
 
+func _OperationService_UserApplyPatch_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(OperationServiceServer).UserApplyPatch(&operationServiceUserApplyPatchServer{stream})
+}
+
+type OperationService_UserApplyPatchServer interface {
+	SendAndClose(*UserApplyPatchResponse) error
+	Recv() (*UserApplyPatchRequest, error)
+	grpc.ServerStream
+}
+
+type operationServiceUserApplyPatchServer struct {
+	grpc.ServerStream
+}
+
+func (x *operationServiceUserApplyPatchServer) SendAndClose(m *UserApplyPatchResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *operationServiceUserApplyPatchServer) Recv() (*UserApplyPatchRequest, error) {
+	m := new(UserApplyPatchRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 var _OperationService_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "gitaly.OperationService",
 	HandlerType: (*OperationServiceServer)(nil),
@@ -1868,6 +2098,11 @@ var _OperationService_serviceDesc = grpc.ServiceDesc{
 			Handler:       _OperationService_UserCommitFiles_Handler,
 			ClientStreams: true,
 		},
+		{
+			StreamName:    "UserApplyPatch",
+			Handler:       _OperationService_UserApplyPatch_Handler,
+			ClientStreams: true,
+		},
 	},
 	Metadata: "operations.proto",
 }
@@ -1875,102 +2110,107 @@ var _OperationService_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("operations.proto", fileDescriptor6) }
 
 var fileDescriptor6 = []byte{
-	// 1545 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcd, 0x6f, 0x1b, 0xd5,
-	0x16, 0xf7, 0xd8, 0xce, 0xd8, 0x39, 0x71, 0x1c, 0xe7, 0xf6, 0xcb, 0x75, 0x9b, 0x26, 0x9d, 0xb6,
-	0xef, 0xb5, 0xd5, 0x53, 0xf4, 0x94, 0xf7, 0x04, 0xab, 0x82, 0x9a, 0xc4, 0x21, 0x05, 0xd2, 0x86,
-	0x69, 0x52, 0xd8, 0x8d, 0x6e, 0xed, 0x8b, 0x3d, 0xc2, 0xf6, 0x4c, 0xef, 0x8c, 0x43, 0x83, 0x10,
-	0x3b, 0x60, 0xcb, 0x8a, 0x35, 0x88, 0x1d, 0x62, 0xc3, 0x86, 0x05, 0x0b, 0xc4, 0x9a, 0x15, 0x52,
-	0x17, 0xfc, 0x03, 0xfc, 0x21, 0xe8, 0xde, 0x73, 0xc6, 0x9e, 0x19, 0x8f, 0xa3, 0xb4, 0x24, 0xa2,
-	0x42, 0xec, 0x3c, 0xbf, 0x73, 0xe6, 0xcc, 0x39, 0xbf, 0xf3, 0x71, 0x3f, 0x0c, 0x35, 0xcf, 0x17,
-	0x92, 0x87, 0xae, 0x37, 0x08, 0x56, 0x7d, 0xe9, 0x85, 0x1e, 0x33, 0x3b, 0x6e, 0xc8, 0x7b, 0x87,
-	0x8d, 0x4a, 0xd0, 0xe5, 0x52, 0xb4, 0x11, 0xb5, 0xbe, 0x37, 0xe0, 0xc2, 0x7e, 0x20, 0xe4, 0x86,
-	0x14, 0x3c, 0x14, 0xeb, 0x92, 0x0f, 0x5a, 0x5d, 0x5b, 0x3c, 0x19, 0x8a, 0x20, 0x64, 0x6b, 0x00,
-	0x52, 0xf8, 0x5e, 0xe0, 0x86, 0x9e, 0x3c, 0xac, 0x1b, 0x2b, 0xc6, 0xcd, 0xb9, 0x35, 0xb6, 0x8a,
-	0x66, 0x56, 0xed, 0x91, 0xc4, 0x8e, 0x69, 0xb1, 0x65, 0x98, 0x7b, 0xac, 0x8d, 0x38, 0x03, 0xde,
-	0x17, 0xf5, 0xfc, 0x8a, 0x71, 0xb3, 0x62, 0x03, 0x42, 0xf7, 0x79, 0x5f, 0xb0, 0x15, 0x28, 0x0e,
-	0x03, 0x21, 0xeb, 0x05, 0x6d, 0xae, 0x12, 0x99, 0x53, 0x3e, 0xd8, 0x5a, 0xa2, 0x4c, 0x04, 0x21,
-	0x97, 0xa1, 0xe3, 0x7b, 0xee, 0x20, 0xac, 0x17, 0xd1, 0x84, 0x86, 0x76, 0x15, 0x62, 0x0d, 0xa0,
-	0x3e, 0xe9, 0x72, 0xe0, 0x7b, 0x83, 0x40, 0xb0, 0x7f, 0x81, 0x89, 0x1f, 0x23, 0x7f, 0xab, 0xd1,
-	0x07, 0x48, 0x8f, 0xa4, 0xec, 0x36, 0x2c, 0xfa, 0x52, 0x38, 0x52, 0xb4, 0x84, 0x7b, 0x20, 0x1c,
-	0x21, 0xa5, 0x27, 0xb5, 0xb7, 0xb3, 0xf6, 0x82, 0x2f, 0x85, 0x8d, 0x78, 0x53, 0xc1, 0xd6, 0xcf,
-	0xc4, 0xd1, 0xbe, 0xdf, 0x7e, 0x59, 0x38, 0x3a, 0x0f, 0xe6, 0x40, 0x7c, 0x28, 0xc5, 0x01, 0xd1,
-	0x43, 0x4f, 0x0a, 0xf7, 0x7a, 0x6d, 0x85, 0xcf, 0x20, 0x8e, 0x4f, 0xd6, 0x16, 0x52, 0x96, 0x8c,
-	0x80, 0x28, 0xcb, 0xa4, 0xc2, 0xc8, 0xa6, 0xe2, 0x0b, 0xa2, 0x62, 0x53, 0xf4, 0xc4, 0xcb, 0x41,
-	0x45, 0x14, 0x5a, 0xd2, 0xa3, 0x17, 0x08, 0xed, 0x73, 0x03, 0xce, 0x8e, 0x0d, 0xed, 0xf1, 0xce,
-	0x9f, 0x89, 0xeb, 0x22, 0x94, 0x43, 0xde, 0x89, 0x07, 0x55, 0x0a, 0x79, 0xe7, 0x98, 0x11, 0x6d,
-	0xc0, 0xb9, 0x94, 0x23, 0x2f, 0x10, 0xce, 0x2f, 0x14, 0x0e, 0x76, 0xc9, 0x5f, 0x18, 0x0e, 0xfb,
-	0x37, 0x2c, 0x84, 0x5c, 0x76, 0x44, 0xe8, 0x48, 0x71, 0xe0, 0x06, 0xae, 0x37, 0xa0, 0xa2, 0xad,
-	0x22, 0x6c, 0x13, 0xca, 0xea, 0x50, 0xea, 0x8b, 0x20, 0xe0, 0x1d, 0x41, 0xd5, 0x1b, 0x3d, 0x5a,
-	0x1f, 0x21, 0x23, 0xb1, 0x58, 0x88, 0x91, 0x25, 0x28, 0x84, 0xbc, 0x43, 0x51, 0xcc, 0x45, 0x1f,
-	0x57, 0x1a, 0x0a, 0x57, 0xed, 0x20, 0x9e, 0xba, 0x41, 0x18, 0x68, 0xaf, 0xcb, 0x36, 0x3d, 0x65,
-	0x13, 0x59, 0xc8, 0x26, 0xf2, 0x99, 0x01, 0xe7, 0xd5, 0xc7, 0x77, 0x84, 0xec, 0x9c, 0x40, 0xc5,
-	0x47, 0x7c, 0xe5, 0xa7, 0xf2, 0x75, 0x09, 0x66, 0x5b, 0x5e, 0xbf, 0xef, 0x86, 0x8e, 0xdb, 0x26,
-	0xa7, 0xca, 0x08, 0xdc, 0x6b, 0xab, 0x88, 0x68, 0xbe, 0x51, 0xe3, 0xd3, 0x3c, 0x9b, 0xca, 0x1d,
-	0x3b, 0x0b, 0x33, 0xdc, 0xf7, 0x7b, 0x87, 0x75, 0x53, 0x53, 0x80, 0x0f, 0xd6, 0x77, 0xd4, 0xc8,
-	0x89, 0xa8, 0x88, 0xd4, 0x84, 0x03, 0x46, 0xca, 0x81, 0x75, 0x98, 0xa7, 0x8e, 0x1d, 0xea, 0x61,
-	0x42, 0x89, 0x5f, 0x8a, 0x02, 0x79, 0x10, 0xad, 0x3b, 0x68, 0x14, 0x27, 0x8e, 0x5d, 0x79, 0x1c,
-	0x7b, 0xca, 0xa6, 0xbf, 0x98, 0x49, 0xff, 0x9b, 0xc5, 0x72, 0xbe, 0x56, 0xb0, 0x3e, 0x81, 0x73,
-	0x99, 0x86, 0x8f, 0xf6, 0xf5, 0x2a, 0x54, 0x14, 0xf3, 0x4e, 0x4b, 0xd7, 0x4d, 0x9b, 0x8a, 0x60,
-	0x4e, 0x61, 0x58, 0x4a, 0x6d, 0x76, 0x03, 0xaa, 0x14, 0x4e, 0xa4, 0x54, 0xd0, 0x4a, 0x14, 0x24,
-	0xa9, 0x59, 0x5f, 0x19, 0x70, 0x46, 0xd1, 0xb5, 0xb5, 0xf5, 0xb2, 0x56, 0x80, 0xf5, 0x19, 0x35,
-	0xfc, 0xd8, 0x45, 0x4a, 0xe7, 0x44, 0xc6, 0x8c, 0x13, 0xca, 0xd8, 0x94, 0xe5, 0xf2, 0xa7, 0x3c,
-	0x75, 0x6b, 0x57, 0x48, 0x79, 0xb8, 0xeb, 0xb6, 0x3e, 0x38, 0x5d, 0xb6, 0x6e, 0x81, 0x89, 0xe4,
-	0x50, 0x29, 0x2e, 0x46, 0x3a, 0x6f, 0xb8, 0xe1, 0x86, 0x16, 0xd8, 0xa4, 0x90, 0x5e, 0x6e, 0x8a,
-	0x13, 0xcb, 0xcd, 0xf4, 0x36, 0xba, 0x0d, 0x8b, 0xb8, 0x2b, 0x89, 0x1b, 0x30, 0xb5, 0xce, 0x82,
-	0x16, 0xac, 0x8f, 0xad, 0xdc, 0x81, 0x1a, 0xea, 0xc6, 0xa2, 0x2d, 0x4d, 0x8d, 0x16, 0x5f, 0x1f,
-	0x03, 0xd6, 0x6f, 0x34, 0x71, 0xe2, 0x04, 0x9e, 0x6c, 0x2e, 0xb1, 0xd6, 0x9d, 0x50, 0x8a, 0x54,
-	0x2e, 0x51, 0xb0, 0x27, 0x05, 0xe6, 0x52, 0x75, 0x10, 0x55, 0x62, 0x7c, 0x46, 0xce, 0x21, 0x86,
-	0x2a, 0xcf, 0xd1, 0xcc, 0xd6, 0x8f, 0x79, 0x58, 0xd4, 0x99, 0x13, 0x07, 0x42, 0x85, 0xfc, 0x4f,
-	0x59, 0x3c, 0x47, 0x59, 0x3c, 0x33, 0x80, 0xc5, 0xc9, 0xfb, 0x7b, 0x94, 0xc4, 0xaf, 0x79, 0xb8,
-	0xa4, 0x8b, 0x5d, 0xbf, 0xbf, 0xe5, 0xf6, 0x44, 0x70, 0xb7, 0xa5, 0xdc, 0xdd, 0x16, 0xbc, 0x2d,
-	0x24, 0xdb, 0x02, 0x93, 0xeb, 0x67, 0x1d, 0x57, 0x75, 0x6d, 0x35, 0x9e, 0xea, 0x29, 0x2f, 0xad,
-	0xe2, 0xc3, 0xde, 0xa1, 0x2f, 0x6c, 0x7a, 0x5b, 0xcd, 0xd4, 0xf7, 0xdd, 0x9e, 0x70, 0x7c, 0x1e,
-	0x76, 0x69, 0x0f, 0x53, 0x56, 0xc0, 0x2e, 0x0f, 0xbb, 0xec, 0x1a, 0xcc, 0xfb, 0x6a, 0x73, 0xe2,
-	0x0d, 0x03, 0x54, 0x28, 0x68, 0x85, 0x4a, 0x04, 0x6a, 0x25, 0xb5, 0x54, 0xf0, 0x40, 0xbc, 0xf2,
-	0x7f, 0xa7, 0xe5, 0x0d, 0x42, 0x41, 0x47, 0x13, 0xb5, 0x54, 0x68, 0x74, 0x03, 0x41, 0x76, 0x0b,
-	0x6a, 0xe2, 0xa9, 0x68, 0x0d, 0x43, 0xe1, 0x28, 0xfb, 0x7d, 0xaf, 0x8d, 0x45, 0x53, 0xb6, 0x17,
-	0x08, 0xdf, 0x22, 0xd8, 0xda, 0x07, 0x18, 0x7b, 0xca, 0x00, 0xcc, 0x0d, 0xbb, 0x79, 0x77, 0xaf,
-	0x59, 0xcb, 0xb1, 0x2a, 0x00, 0xfe, 0x76, 0x36, 0xef, 0xd9, 0x35, 0x43, 0xc9, 0xf6, 0x77, 0x37,
-	0x95, 0x2c, 0xcf, 0xca, 0x50, 0xdc, 0x79, 0xf0, 0xa8, 0x59, 0x2b, 0x28, 0x74, 0xb3, 0xf9, 0x76,
-	0x73, 0xaf, 0x59, 0x2b, 0xb2, 0x59, 0x98, 0xd9, 0xd8, 0xde, 0x79, 0xb0, 0x59, 0x9b, 0xb1, 0xbe,
-	0x34, 0x68, 0x00, 0xa7, 0xd9, 0x61, 0x77, 0xc0, 0xec, 0x6a, 0x86, 0xa8, 0x48, 0xae, 0x1d, 0x83,
-	0xcc, 0xed, 0x9c, 0x4d, 0x2f, 0xb1, 0x06, 0x94, 0xa2, 0xd0, 0x35, 0x83, 0xdb, 0x39, 0x3b, 0x02,
-	0xd6, 0x2d, 0x58, 0x51, 0x6d, 0xe7, 0x50, 0x6d, 0xa8, 0xd0, 0x03, 0x07, 0xb9, 0x77, 0x7c, 0x7e,
-	0xd8, 0xf3, 0x78, 0xdb, 0xfa, 0xb4, 0x00, 0x97, 0x53, 0x5f, 0xa2, 0x19, 0x40, 0xc9, 0x3e, 0x9d,
-	0x49, 0x90, 0x6a, 0xef, 0xc2, 0x44, 0x7b, 0xdf, 0x80, 0x2a, 0xb9, 0x1d, 0x75, 0x39, 0x8e, 0x80,
-	0x79, 0x44, 0x77, 0xa8, 0xd7, 0xff, 0x03, 0x8c, 0xd4, 0xf8, 0x30, 0xec, 0x7a, 0x12, 0xcd, 0xe1,
-	0x40, 0xa8, 0xa1, 0xe4, 0xae, 0x16, 0x68, 0xa3, 0xab, 0x70, 0x26, 0xa9, 0x2d, 0xfa, 0xdc, 0xed,
-	0xd1, 0x6c, 0x58, 0x8c, 0xab, 0x37, 0x95, 0x20, 0x7b, 0x92, 0x94, 0x8e, 0x3f, 0x49, 0xca, 0xc7,
-	0x9f, 0x24, 0x3f, 0x44, 0x0b, 0xcc, 0x44, 0x1e, 0xd8, 0x6b, 0xa9, 0x0a, 0xb9, 0x3e, 0xa5, 0x42,
-	0x12, 0x79, 0x8b, 0x95, 0xc8, 0xab, 0xa3, 0x76, 0xcd, 0x27, 0xc7, 0x50, 0x76, 0x85, 0xe5, 0xa2,
-	0xfe, 0x5c, 0xbf, 0x06, 0x57, 0x27, 0xeb, 0x47, 0xe2, 0x57, 0x46, 0x05, 0xf4, 0x6d, 0x74, 0x5b,
-	0x11, 0x77, 0xe4, 0x04, 0xe7, 0xe0, 0x32, 0xcc, 0xb9, 0x83, 0xb6, 0x78, 0x9a, 0x98, 0x80, 0xa0,
-	0xa1, 0x23, 0x26, 0xdb, 0x94, 0x83, 0xc3, 0x37, 0xa3, 0xc5, 0x4e, 0x0d, 0x88, 0x53, 0xdf, 0x31,
-	0x4a, 0xfd, 0x99, 0xd8, 0x8e, 0x11, 0x81, 0x23, 0xce, 0x0c, 0x4b, 0x40, 0x4d, 0xe0, 0x04, 0x5d,
-	0xae, 0xeb, 0x78, 0xd6, 0x9e, 0x45, 0xe4, 0x61, 0x97, 0xb3, 0xd7, 0x61, 0x51, 0x8a, 0xbe, 0x17,
-	0x8a, 0x78, 0x95, 0x99, 0x53, 0x1d, 0xae, 0xa1, 0xf2, 0x18, 0x51, 0x53, 0x95, 0x0c, 0xd0, 0xe7,
-	0xb1, 0x9a, 0x2b, 0x08, 0x62, 0x1a, 0xac, 0x8f, 0xa3, 0x45, 0x0d, 0x49, 0x1a, 0x9d, 0xeb, 0x80,
-	0xe2, 0x51, 0xae, 0xe1, 0xbe, 0x9e, 0x22, 0x54, 0xae, 0x3d, 0xc7, 0x76, 0x54, 0x51, 0xd3, 0x49,
-	0x2d, 0x56, 0xe5, 0x0e, 0xad, 0x54, 0xd6, 0xd7, 0x94, 0xa3, 0x87, 0x4f, 0x86, 0x3c, 0x38, 0xfd,
-	0x5d, 0x7d, 0xa0, 0x3f, 0x13, 0xcb, 0x11, 0x02, 0x47, 0xe4, 0x48, 0xbd, 0xa4, 0x3b, 0x7d, 0x9c,
-	0xa2, 0xb2, 0x06, 0x14, 0x0d, 0x17, 0xa0, 0x24, 0x06, 0x6d, 0x2d, 0x32, 0xb5, 0xc8, 0x14, 0x83,
-	0xb6, 0x12, 0x5c, 0x07, 0x13, 0x87, 0x0e, 0xed, 0x2f, 0x92, 0xee, 0x90, 0x2c, 0x63, 0xec, 0x95,
-	0x33, 0xc6, 0x9e, 0xe5, 0x62, 0x86, 0x22, 0x8a, 0xc6, 0x19, 0xa2, 0x68, 0x62, 0x19, 0x42, 0x44,
-	0x79, 0x70, 0x14, 0xeb, 0x78, 0xa6, 0xb3, 0x27, 0x53, 0xb8, 0xf6, 0x7b, 0x09, 0x6a, 0xa3, 0x3e,
-	0x7d, 0x28, 0xe4, 0x81, 0xdb, 0x12, 0xec, 0x5d, 0xa8, 0xa5, 0xaf, 0xfb, 0xd8, 0x72, 0x62, 0xac,
-	0x4c, 0xde, 0x5d, 0x36, 0x56, 0xa6, 0x2b, 0x60, 0x00, 0x56, 0x2e, 0x32, 0x1c, 0xbf, 0x14, 0x4b,
-	0x1a, 0xce, 0xb8, 0xf0, 0x4b, 0x1a, 0xce, 0xba, 0x4f, 0x1b, 0x1b, 0x8e, 0x5f, 0x49, 0x25, 0x0d,
-	0x67, 0x5c, 0x9f, 0x25, 0x0d, 0x67, 0xdd, 0x66, 0x59, 0x39, 0x76, 0x1f, 0xe6, 0x13, 0xf7, 0x20,
-	0xec, 0xf2, 0x64, 0x98, 0xe3, 0xab, 0x9e, 0xc6, 0xd2, 0x14, 0x69, 0xda, 0xde, 0xe8, 0xa6, 0x29,
-	0x69, 0x2f, 0x7d, 0x13, 0x96, 0xb4, 0x37, 0x71, 0x3d, 0x65, 0xe5, 0xd8, 0x7b, 0xb0, 0x90, 0xba,
-	0x54, 0x60, 0x57, 0xe2, 0xef, 0x4c, 0xde, 0xa1, 0x34, 0x96, 0xa7, 0xca, 0x23, 0xab, 0x37, 0x8d,
-	0xff, 0x1a, 0xec, 0x2d, 0xa8, 0xc4, 0x0f, 0xb7, 0xec, 0x52, 0xfc, 0xb5, 0xd4, 0xa9, 0xbc, 0x71,
-	0x39, 0x5b, 0x38, 0x72, 0xf3, 0x1d, 0xa8, 0x26, 0xcf, 0x57, 0x2c, 0xc9, 0x54, 0xfa, 0xe0, 0xda,
-	0xb8, 0x32, 0x4d, 0x3c, 0x32, 0xd9, 0x04, 0x18, 0xef, 0xcd, 0xd9, 0xc5, 0x44, 0xbf, 0xc5, 0x0f,
-	0x3b, 0x8d, 0x46, 0x96, 0x68, 0x64, 0xe6, 0x11, 0x12, 0x18, 0x5b, 0xdf, 0x92, 0x04, 0x4e, 0xae,
-	0xc0, 0x49, 0x02, 0x33, 0x16, 0x46, 0x45, 0xe0, 0xd8, 0x3d, 0x35, 0x41, 0xd3, 0xee, 0xc5, 0x96,
-	0xa7, 0xb4, 0x7b, 0xf1, 0xa1, 0x3c, 0x8e, 0x12, 0x47, 0x41, 0xd2, 0x4c, 0x62, 0x82, 0x26, 0xcd,
-	0x24, 0x27, 0x87, 0x95, 0x7b, 0x6c, 0xea, 0xff, 0x1e, 0xfe, 0xf7, 0x47, 0x00, 0x00, 0x00, 0xff,
-	0xff, 0x63, 0x19, 0x77, 0x57, 0xa5, 0x18, 0x00, 0x00,
+	// 1626 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcd, 0x6f, 0x1b, 0x55,
+	0x10, 0xf7, 0xda, 0xc9, 0xc6, 0x99, 0x38, 0x89, 0xf3, 0xfa, 0x95, 0xba, 0x4d, 0x93, 0x6e, 0x5a,
+	0x68, 0x2b, 0x64, 0xa1, 0x80, 0xe0, 0x54, 0x50, 0x3e, 0x1c, 0x52, 0x20, 0x6d, 0xd8, 0x24, 0x85,
+	0x03, 0xd2, 0x6a, 0x6b, 0x3f, 0xec, 0x15, 0xb6, 0x77, 0xfb, 0x76, 0x1d, 0x1a, 0x84, 0xb8, 0x20,
+	0xe0, 0xca, 0x89, 0x1b, 0x12, 0x88, 0x1b, 0xe2, 0xc2, 0x05, 0x09, 0x0e, 0x88, 0x33, 0x27, 0xa4,
+	0x1e, 0xf8, 0x77, 0xd0, 0x7b, 0x33, 0xeb, 0xfd, 0x74, 0x94, 0x96, 0x44, 0x54, 0x88, 0x9b, 0x77,
+	0x66, 0x76, 0x76, 0xe6, 0x37, 0x5f, 0xef, 0x8d, 0xa1, 0xea, 0x7a, 0x5c, 0xd8, 0x81, 0xe3, 0xf6,
+	0xfd, 0xba, 0x27, 0xdc, 0xc0, 0x65, 0x7a, 0xdb, 0x09, 0xec, 0xee, 0x61, 0xad, 0xe2, 0x77, 0x6c,
+	0xc1, 0x5b, 0x48, 0x35, 0x7e, 0xd2, 0xe0, 0xc2, 0xbe, 0xcf, 0xc5, 0xba, 0xe0, 0x76, 0xc0, 0xd7,
+	0x84, 0xdd, 0x6f, 0x76, 0x4c, 0xfe, 0x70, 0xc0, 0xfd, 0x80, 0xad, 0x00, 0x08, 0xee, 0xb9, 0xbe,
+	0x13, 0xb8, 0xe2, 0x70, 0x5e, 0x5b, 0xd2, 0x6e, 0x4c, 0xad, 0xb0, 0x3a, 0xaa, 0xa9, 0x9b, 0x43,
+	0x8e, 0x19, 0x93, 0x62, 0x8b, 0x30, 0xf5, 0x40, 0x29, 0xb1, 0xfa, 0x76, 0x8f, 0xcf, 0x17, 0x97,
+	0xb4, 0x1b, 0x15, 0x13, 0x90, 0x74, 0xd7, 0xee, 0x71, 0xb6, 0x04, 0x63, 0x03, 0x9f, 0x8b, 0xf9,
+	0x92, 0x52, 0x57, 0x09, 0xd5, 0x49, 0x1b, 0x4c, 0xc5, 0x91, 0x2a, 0xfc, 0xc0, 0x16, 0x81, 0xe5,
+	0xb9, 0x4e, 0x3f, 0x98, 0x1f, 0x43, 0x15, 0x8a, 0xb4, 0x23, 0x29, 0x46, 0x1f, 0xe6, 0xb3, 0x26,
+	0xfb, 0x9e, 0xdb, 0xf7, 0x39, 0x7b, 0x0e, 0x74, 0xfc, 0x18, 0xd9, 0x3b, 0x13, 0x7e, 0x80, 0xe4,
+	0x88, 0xcb, 0x6e, 0xc1, 0x9c, 0x27, 0xb8, 0x25, 0x78, 0x93, 0x3b, 0x07, 0xdc, 0xe2, 0x42, 0xb8,
+	0x42, 0x59, 0x3b, 0x69, 0xce, 0x7a, 0x82, 0x9b, 0x48, 0x6f, 0x48, 0xb2, 0xf1, 0x3b, 0x61, 0xb4,
+	0xef, 0xb5, 0x9e, 0x15, 0x8c, 0xce, 0x83, 0xde, 0xe7, 0x1f, 0x09, 0x7e, 0x40, 0xf0, 0xd0, 0x93,
+	0xa4, 0xbb, 0xdd, 0x96, 0xa4, 0x8f, 0x23, 0x1d, 0x9f, 0x8c, 0x4d, 0x84, 0x2c, 0xe9, 0x01, 0x41,
+	0x96, 0x0b, 0x85, 0x96, 0x0f, 0xc5, 0x57, 0x04, 0xc5, 0x06, 0xef, 0xf2, 0x67, 0x03, 0x8a, 0xd0,
+	0xb5, 0xa4, 0x45, 0x4f, 0xe1, 0xda, 0x97, 0x1a, 0x9c, 0x8d, 0x14, 0xed, 0xd9, 0xed, 0x7f, 0xe2,
+	0xd7, 0x45, 0x28, 0x07, 0x76, 0x3b, 0xee, 0xd4, 0x44, 0x60, 0xb7, 0x8f, 0xe9, 0xd1, 0x3a, 0x9c,
+	0x4b, 0x19, 0xf2, 0x14, 0xee, 0xfc, 0x41, 0xee, 0x60, 0x95, 0xfc, 0x8b, 0xee, 0xb0, 0xe7, 0x61,
+	0x36, 0xb0, 0x45, 0x9b, 0x07, 0x96, 0xe0, 0x07, 0x8e, 0xef, 0xb8, 0x7d, 0x4a, 0xda, 0x19, 0x24,
+	0x9b, 0x44, 0x65, 0xf3, 0x30, 0xd1, 0xe3, 0xbe, 0x6f, 0xb7, 0x39, 0x65, 0x6f, 0xf8, 0x68, 0x7c,
+	0x8c, 0x88, 0xc4, 0x7c, 0x21, 0x44, 0x16, 0xa0, 0x14, 0xd8, 0x6d, 0xf2, 0x62, 0x2a, 0xfc, 0xb8,
+	0x94, 0x90, 0x74, 0x59, 0x0e, 0xfc, 0x91, 0xe3, 0x07, 0xbe, 0xb2, 0xba, 0x6c, 0xd2, 0x53, 0x3e,
+	0x90, 0xa5, 0x7c, 0x20, 0x1f, 0x6b, 0x70, 0x5e, 0x7e, 0x7c, 0x9b, 0x8b, 0xf6, 0x09, 0x64, 0x7c,
+	0x88, 0x57, 0x71, 0x24, 0x5e, 0x97, 0x60, 0xb2, 0xe9, 0xf6, 0x7a, 0x4e, 0x60, 0x39, 0x2d, 0x32,
+	0xaa, 0x8c, 0x84, 0x3b, 0x2d, 0xe9, 0x11, 0xf5, 0x37, 0x2a, 0x7c, 0xea, 0x67, 0x23, 0xb1, 0x63,
+	0x67, 0x61, 0xdc, 0xf6, 0xbc, 0xee, 0xe1, 0xbc, 0xae, 0x20, 0xc0, 0x07, 0xe3, 0x47, 0x2a, 0xe4,
+	0x84, 0x57, 0x04, 0x6a, 0xc2, 0x00, 0x2d, 0x65, 0xc0, 0x1a, 0x4c, 0x53, 0xc5, 0x0e, 0x54, 0x33,
+	0xa1, 0xc0, 0x2f, 0x84, 0x8e, 0xdc, 0x0b, 0xe7, 0x0e, 0x2a, 0xc5, 0x8e, 0x63, 0x56, 0x1e, 0xc4,
+	0x9e, 0xf2, 0xe1, 0x1f, 0xcb, 0x85, 0xff, 0xcd, 0xb1, 0x72, 0xb1, 0x5a, 0x32, 0x3e, 0x85, 0x73,
+	0xb9, 0x8a, 0x8f, 0xb6, 0xf5, 0x2a, 0x54, 0x24, 0xf2, 0x56, 0x53, 0xe5, 0x4d, 0x8b, 0x92, 0x60,
+	0x4a, 0xd2, 0x30, 0x95, 0x5a, 0xec, 0x3a, 0xcc, 0x90, 0x3b, 0xa1, 0x50, 0x49, 0x09, 0x91, 0x93,
+	0x24, 0x66, 0x7c, 0xab, 0xc1, 0x19, 0x09, 0xd7, 0xe6, 0xe6, 0xb3, 0x9a, 0x01, 0xc6, 0x17, 0x54,
+	0xf0, 0x91, 0x89, 0x14, 0xce, 0x4c, 0xc4, 0xb4, 0x13, 0x8a, 0xd8, 0x88, 0x71, 0xf9, 0x5b, 0x91,
+	0xaa, 0xb5, 0xc3, 0x85, 0x38, 0xdc, 0x71, 0x9a, 0x1f, 0x9e, 0x2e, 0x5a, 0x37, 0x41, 0x47, 0x70,
+	0x28, 0x15, 0xe7, 0x42, 0x99, 0x37, 0x9c, 0x60, 0x5d, 0x31, 0x4c, 0x12, 0x48, 0x8f, 0x9b, 0xb1,
+	0xcc, 0xb8, 0x19, 0x5d, 0x46, 0xb7, 0x60, 0x0e, 0x4f, 0x25, 0x71, 0x05, 0xba, 0x92, 0x99, 0x55,
+	0x8c, 0xb5, 0x48, 0xcb, 0x6d, 0xa8, 0xa2, 0x6c, 0xcc, 0xdb, 0x89, 0x91, 0xde, 0xe2, 0xeb, 0x11,
+	0xc1, 0xf8, 0x8b, 0x3a, 0x4e, 0x1c, 0xc0, 0x93, 0x8d, 0x25, 0xe6, 0xba, 0x15, 0x08, 0x9e, 0x8a,
+	0x25, 0x32, 0xf6, 0x04, 0xc7, 0x58, 0xca, 0x0a, 0xa2, 0x4c, 0x8c, 0xf7, 0xc8, 0x29, 0xa4, 0xa1,
+	0xc8, 0x13, 0x14, 0xb3, 0xf1, 0x6b, 0x11, 0xe6, 0x54, 0xe4, 0xf8, 0x01, 0x97, 0x2e, 0xff, 0x9f,
+	0x16, 0x4f, 0x90, 0x16, 0x8f, 0x35, 0x60, 0x71, 0xf0, 0xfe, 0x1b, 0x29, 0xf1, 0x67, 0x11, 0x2e,
+	0xa9, 0x64, 0x57, 0xef, 0x6f, 0x3a, 0x5d, 0xee, 0xaf, 0x36, 0xa5, 0xb9, 0x5b, 0xdc, 0x6e, 0x71,
+	0xc1, 0x36, 0x41, 0xb7, 0xd5, 0xb3, 0xf2, 0x6b, 0x66, 0xa5, 0x1e, 0x0f, 0xf5, 0x88, 0x97, 0xea,
+	0xf8, 0xb0, 0x77, 0xe8, 0x71, 0x93, 0xde, 0x96, 0x3d, 0xf5, 0x03, 0xa7, 0xcb, 0x2d, 0xcf, 0x0e,
+	0x3a, 0x74, 0x86, 0x29, 0x4b, 0xc2, 0x8e, 0x1d, 0x74, 0xd8, 0x32, 0x4c, 0x7b, 0xf2, 0x70, 0xe2,
+	0x0e, 0x7c, 0x14, 0x28, 0x29, 0x81, 0x4a, 0x48, 0x54, 0x42, 0x72, 0x54, 0xd8, 0x3e, 0x7f, 0xe5,
+	0x65, 0xab, 0xe9, 0xf6, 0x03, 0x4e, 0x57, 0x13, 0x39, 0x2a, 0x14, 0x75, 0x1d, 0x89, 0xec, 0x26,
+	0x54, 0xf9, 0x23, 0xde, 0x1c, 0x04, 0xdc, 0x92, 0xfa, 0x7b, 0x6e, 0x0b, 0x93, 0xa6, 0x6c, 0xce,
+	0x12, 0x7d, 0x93, 0xc8, 0xc6, 0x3e, 0x40, 0x64, 0x29, 0x03, 0xd0, 0xd7, 0xcd, 0xc6, 0xea, 0x5e,
+	0xa3, 0x5a, 0x60, 0x33, 0x00, 0xf8, 0xdb, 0xda, 0xb8, 0x63, 0x56, 0x35, 0xc9, 0xdb, 0xdf, 0xd9,
+	0x90, 0xbc, 0x22, 0x2b, 0xc3, 0xd8, 0xf6, 0xbd, 0xfb, 0x8d, 0x6a, 0x49, 0x52, 0x37, 0x1a, 0x6f,
+	0x37, 0xf6, 0x1a, 0xd5, 0x31, 0x36, 0x09, 0xe3, 0xeb, 0x5b, 0xdb, 0xf7, 0x36, 0xaa, 0xe3, 0xc6,
+	0xd7, 0x1a, 0x35, 0xe0, 0x34, 0x3a, 0xec, 0x36, 0xe8, 0x1d, 0x85, 0x10, 0x25, 0xc9, 0xf2, 0x31,
+	0xc0, 0xdc, 0x2a, 0x98, 0xf4, 0x12, 0xab, 0xc1, 0x44, 0xe8, 0xba, 0x42, 0x70, 0xab, 0x60, 0x86,
+	0x84, 0x35, 0x03, 0x96, 0x64, 0xd9, 0x59, 0x94, 0x1b, 0xd2, 0x75, 0xdf, 0x42, 0xec, 0x2d, 0xcf,
+	0x3e, 0xec, 0xba, 0x76, 0xcb, 0xf8, 0xbc, 0x04, 0x97, 0x53, 0x5f, 0xa2, 0x1e, 0x40, 0xc1, 0x3e,
+	0x9d, 0x4e, 0x90, 0x2a, 0xef, 0x52, 0xa6, 0xbc, 0xaf, 0xc3, 0x0c, 0x99, 0x1d, 0x56, 0x39, 0xb6,
+	0x80, 0x69, 0xa4, 0x6e, 0x53, 0xad, 0xbf, 0x00, 0x8c, 0xc4, 0xec, 0x41, 0xd0, 0x71, 0x05, 0xaa,
+	0xc3, 0x86, 0x50, 0x45, 0xce, 0xaa, 0x62, 0x28, 0xa5, 0x75, 0x38, 0x93, 0x94, 0xe6, 0x3d, 0xdb,
+	0xe9, 0x52, 0x6f, 0x98, 0x8b, 0x8b, 0x37, 0x24, 0x23, 0xbf, 0x93, 0x4c, 0x1c, 0xbf, 0x93, 0x94,
+	0x8f, 0xdf, 0x49, 0x7e, 0x0e, 0x07, 0x4c, 0x26, 0x0e, 0xec, 0xb5, 0x54, 0x86, 0x5c, 0x1b, 0x91,
+	0x21, 0x89, 0xb8, 0xc5, 0x52, 0xe4, 0xd5, 0x61, 0xb9, 0x16, 0x93, 0x6d, 0x28, 0x3f, 0xc3, 0x0a,
+	0x61, 0x7d, 0xae, 0x2d, 0xc3, 0xd5, 0x6c, 0xfe, 0x08, 0xfc, 0xca, 0x30, 0x81, 0x7e, 0x08, 0xb7,
+	0x15, 0x71, 0x43, 0x4e, 0xb0, 0x0f, 0x2e, 0xc2, 0x94, 0xd3, 0x6f, 0xf1, 0x47, 0x89, 0x0e, 0x08,
+	0x8a, 0x74, 0x44, 0x67, 0x1b, 0x71, 0x71, 0xf8, 0x7e, 0x38, 0xec, 0x64, 0x83, 0x38, 0xf5, 0x13,
+	0xa3, 0x50, 0x9f, 0x89, 0x9d, 0x18, 0x91, 0x70, 0xc4, 0x9d, 0x61, 0x01, 0xa8, 0x08, 0x2c, 0xbf,
+	0x63, 0xab, 0x3c, 0x9e, 0x34, 0x27, 0x91, 0xb2, 0xdb, 0xb1, 0xd9, 0xeb, 0x30, 0x27, 0x78, 0xcf,
+	0x0d, 0x78, 0x3c, 0xcb, 0xf4, 0x91, 0x06, 0x57, 0x51, 0x38, 0xa2, 0xc8, 0xae, 0x4a, 0x0a, 0xe8,
+	0xf3, 0x98, 0xcd, 0x15, 0x24, 0x62, 0x18, 0x8c, 0x4f, 0xc2, 0xa1, 0x86, 0x20, 0x0d, 0xef, 0x75,
+	0x40, 0xfe, 0x48, 0xd3, 0xf0, 0x5c, 0x4f, 0x1e, 0x4a, 0xd3, 0x9e, 0xe0, 0x38, 0x2a, 0xa1, 0x69,
+	0xa7, 0x86, 0x55, 0xb9, 0x4d, 0x93, 0xca, 0xf8, 0x8e, 0x62, 0xb4, 0xfb, 0x70, 0x60, 0xfb, 0xa7,
+	0x7f, 0xaa, 0xf7, 0xd5, 0x67, 0x62, 0x31, 0x42, 0xc2, 0x11, 0x31, 0x92, 0x2f, 0xa9, 0x4a, 0x8f,
+	0x42, 0x54, 0x56, 0x04, 0x09, 0xc3, 0x05, 0x98, 0xe0, 0xfd, 0x96, 0x62, 0xe9, 0x8a, 0xa5, 0xf3,
+	0x7e, 0x4b, 0x32, 0xae, 0x81, 0x8e, 0x4d, 0x87, 0xce, 0x17, 0x49, 0x73, 0x88, 0x97, 0xd3, 0xf6,
+	0xca, 0x39, 0x6d, 0xcf, 0x70, 0x30, 0x42, 0x21, 0x44, 0x51, 0x84, 0xc8, 0x9b, 0x58, 0x84, 0x90,
+	0x22, 0x2d, 0x38, 0x0a, 0x75, 0xbc, 0xd3, 0x99, 0xd9, 0x10, 0x1a, 0xdf, 0xd0, 0xd5, 0x61, 0x55,
+	0xde, 0x51, 0x77, 0xec, 0x20, 0xba, 0x68, 0x1d, 0xd9, 0x97, 0x32, 0xe2, 0xf5, 0xbc, 0xd1, 0xe5,
+	0x49, 0x01, 0xee, 0x47, 0xa3, 0x8b, 0x08, 0xb5, 0xcf, 0x34, 0xd0, 0x4f, 0x75, 0x00, 0x2d, 0xc3,
+	0x34, 0x6d, 0x40, 0x28, 0xc6, 0x74, 0xbc, 0x40, 0x22, 0x16, 0xc2, 0x70, 0x80, 0xaa, 0xfb, 0xb9,
+	0xa5, 0x6c, 0xcb, 0xf4, 0xbf, 0xf7, 0xb1, 0x6f, 0xc7, 0xfd, 0x3d, 0xb9, 0xee, 0xb7, 0xf2, 0x4b,
+	0x19, 0xaa, 0x43, 0xb9, 0x5d, 0x2e, 0x0e, 0x9c, 0x26, 0x67, 0xef, 0x42, 0x35, 0xbd, 0x6c, 0x65,
+	0x8b, 0x89, 0xa6, 0x9e, 0xdd, 0x1c, 0xd7, 0x96, 0x46, 0x0b, 0xa0, 0xbd, 0x46, 0x21, 0x54, 0x1c,
+	0x5f, 0x49, 0x26, 0x15, 0xe7, 0xac, 0x5b, 0x93, 0x8a, 0xf3, 0xb6, 0x99, 0x91, 0xe2, 0xf8, 0x42,
+	0x30, 0xa9, 0x38, 0x67, 0x79, 0x99, 0x54, 0x9c, 0xb7, 0x4b, 0x34, 0x0a, 0xec, 0x2e, 0x4c, 0x27,
+	0xb6, 0x50, 0xec, 0x72, 0xd6, 0xcd, 0x68, 0xd1, 0x56, 0x5b, 0x18, 0xc1, 0x4d, 0xeb, 0x1b, 0xee,
+	0xf9, 0x92, 0xfa, 0xd2, 0x7b, 0xc8, 0xa4, 0xbe, 0xcc, 0x72, 0xd0, 0x28, 0xb0, 0xf7, 0x60, 0x36,
+	0xb5, 0xd2, 0x61, 0x57, 0xe2, 0xef, 0x64, 0x37, 0x58, 0xb5, 0xc5, 0x91, 0xfc, 0x50, 0xeb, 0x0d,
+	0xed, 0x45, 0x8d, 0xbd, 0x05, 0x95, 0xf8, 0x6a, 0x81, 0x5d, 0x8a, 0xbf, 0x96, 0xda, 0x89, 0xd4,
+	0x2e, 0xe7, 0x33, 0x87, 0x66, 0xbe, 0x03, 0x33, 0xc9, 0xdb, 0x2d, 0x4b, 0x22, 0x95, 0x5e, 0x1b,
+	0xd4, 0xae, 0x8c, 0x62, 0x0f, 0x55, 0x36, 0x00, 0xa2, 0x9b, 0x11, 0xbb, 0x98, 0x28, 0xc1, 0xf8,
+	0x55, 0xb3, 0x56, 0xcb, 0x63, 0x0d, 0xd5, 0xdc, 0x47, 0x00, 0x63, 0xa7, 0x8b, 0x24, 0x80, 0xd9,
+	0xf3, 0x4f, 0x12, 0xc0, 0x9c, 0x63, 0x89, 0x04, 0x30, 0x32, 0x4f, 0xce, 0xaf, 0xb4, 0x79, 0xb1,
+	0xc3, 0x41, 0xda, 0xbc, 0xf8, 0x48, 0x8c, 0xbc, 0xc4, 0x46, 0x9c, 0x54, 0x93, 0x98, 0x5f, 0x49,
+	0x35, 0xc9, 0xbe, 0x6d, 0x14, 0xd8, 0x2e, 0xe2, 0x1f, 0x35, 0x91, 0x24, 0xfe, 0x99, 0x66, 0x9a,
+	0xc4, 0x3f, 0xdb, 0x7b, 0xa4, 0x8b, 0x0f, 0x74, 0xf5, 0x77, 0xd2, 0x4b, 0x7f, 0x07, 0x00, 0x00,
+	0xff, 0xff, 0xe8, 0xc5, 0xbe, 0x70, 0x78, 0x1a, 0x00, 0x00,
 }
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 82f0a934d..c33f95433 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -213,12 +213,12 @@
 			"revisionTime": "2017-12-31T12:27:32Z"
 		},
 		{
-			"checksumSHA1": "7DDyruoxYwkzwvNiWIqfw79gUqA=",
+			"checksumSHA1": "sgtWlz2r6XUcjr+eXvBrb9JqgVs=",
 			"path": "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb",
-			"revision": "790a4f7603441ddc6d703c2eb9394212992114a3",
-			"revisionTime": "2018-10-04T12:44:29Z",
-			"version": "v0.120.0",
-			"versionExact": "v0.120.0"
+			"revision": "43fb53d30d4eba169e663f708544c3b813eb0c9a",
+			"revisionTime": "2018-10-22T12:10:33Z",
+			"version": "v0.121.0",
+			"versionExact": "v0.121.0"
 		},
 		{
 			"checksumSHA1": "nqWNlnMmVpt628zzvyo6Yv2CX5Q=",