Added update submodule ref operation to repositories

This new operation allows to update the reference of a submodule
from the repository.

18 files changed, 915 insertions, 157 deletions

diff --git a/changelogs/unreleased/fj-add-update-submodule.yml b/changelogs/unreleased/fj-add-update-submodule.yml
new file mode 100644
index 000000000..0f0865fca
--- /dev/null
+++ b/changelogs/unreleased/fj-add-update-submodule.yml
@@ -0,0 +1,5 @@
+---
+title: Add submodule reference update operation in the repository
+merge_request: 936
+author:
+type: added
diff --git a/internal/service/operations/submodules.go b/internal/service/operations/submodules.go
new file mode 100644
index 000000000..3d37efec8
--- /dev/null
+++ b/internal/service/operations/submodules.go
@@ -0,0 +1,62 @@
+package operations
+
+import (
+	"fmt"
+	"regexp"
+
+	"gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
+	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
+	"golang.org/x/net/context"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func (s *server) UserUpdateSubmodule(ctx context.Context, req *gitalypb.UserUpdateSubmoduleRequest) (*gitalypb.UserUpdateSubmoduleResponse, error) {
+	if err := validateUserUpdateSubmoduleRequest(req); err != nil {
+		return nil, status.Errorf(codes.InvalidArgument, "UserUpdateSubmodule: %v", err)
+	}
+
+	client, err := s.OperationServiceClient(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	clientCtx, err := rubyserver.SetHeaders(ctx, req.GetRepository())
+	if err != nil {
+		return nil, err
+	}
+
+	return client.UserUpdateSubmodule(clientCtx, req)
+}
+
+func validateUserUpdateSubmoduleRequest(req *gitalypb.UserUpdateSubmoduleRequest) error {
+	if req.GetRepository() == nil {
+		return fmt.Errorf("empty Repository")
+	}
+
+	if req.GetUser() == nil {
+		return fmt.Errorf("empty User")
+	}
+
+	if req.GetCommitSha() == "" {
+		return fmt.Errorf("empty CommitSha")
+	}
+
+	if match, err := regexp.MatchString(`\A[0-9a-f]{40}\z`, req.GetCommitSha()); !match || err != nil {
+		return fmt.Errorf("invalid CommitSha")
+	}
+
+	if len(req.GetBranch()) == 0 {
+		return fmt.Errorf("empty Branch")
+	}
+
+	if len(req.GetSubmodule()) == 0 {
+		return fmt.Errorf("empty Submodule")
+	}
+
+	if len(req.GetCommitMessage()) == 0 {
+		return fmt.Errorf("empty CommitMessage")
+	}
+
+	return nil
+}
diff --git a/internal/service/operations/submodules_test.go b/internal/service/operations/submodules_test.go
new file mode 100644
index 000000000..57d32cbed
--- /dev/null
+++ b/internal/service/operations/submodules_test.go
@@ -0,0 +1,317 @@
+package operations
+
+import (
+	"bytes"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"gitlab.com/gitlab-org/gitaly-proto/go/gitalypb"
+	"gitlab.com/gitlab-org/gitaly/internal/git/log"
+	"gitlab.com/gitlab-org/gitaly/internal/git/lstree"
+	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
+	"google.golang.org/grpc/codes"
+)
+
+func TestSuccessfulUserUpdateSubmoduleRequest(t *testing.T) {
+	server, serverSocketPath := runOperationServiceServer(t)
+	defer server.Stop()
+
+	client, conn := NewOperationClient(t, serverSocketPath)
+	defer conn.Close()
+
+	testRepo, testRepoPath, cleanup := testhelper.NewTestRepo(t)
+	defer cleanup()
+
+	commitMessage := []byte("Update Submodule message")
+
+	testCases := []struct {
+		desc      string
+		submodule string
+		commitSha string
+		branch    string
+	}{
+		{
+			desc:      "Update submodule",
+			submodule: "gitlab-grack",
+			commitSha: "41fa1bc9e0f0630ced6a8a211d60c2af425ecc2d",
+			branch:    "master",
+		},
+		{
+			desc:      "Update submodule inside folder",
+			submodule: "test_inside_folder/another_folder/six",
+			commitSha: "e25eda1fece24ac7a03624ed1320f82396f35bd8",
+			branch:    "submodule_inside_folder",
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.desc, func(t *testing.T) {
+			ctx, cancel := testhelper.Context()
+			defer cancel()
+
+			request := &gitalypb.UserUpdateSubmoduleRequest{
+				Repository:    testRepo,
+				User:          user,
+				Submodule:     []byte(testCase.submodule),
+				CommitSha:     testCase.commitSha,
+				Branch:        []byte(testCase.branch),
+				CommitMessage: commitMessage,
+			}
+
+			response, err := client.UserUpdateSubmodule(ctx, request)
+			require.NoError(t, err)
+			require.Empty(t, response.GetCommitError())
+			require.Empty(t, response.GetPreReceiveError())
+
+			commit, err := log.GetCommit(ctx, testRepo, response.BranchUpdate.CommitId)
+			require.NoError(t, err)
+			require.Equal(t, commit.Author.Email, user.Email)
+			require.Equal(t, commit.Committer.Email, user.Email)
+			require.Equal(t, commit.Subject, commitMessage)
+
+			entry := testhelper.MustRunCommand(t, nil, "git", "-C", testRepoPath, "ls-tree", "-z", fmt.Sprintf("%s^{tree}:", response.BranchUpdate.CommitId), testCase.submodule)
+			parser := lstree.NewParser(bytes.NewReader(entry))
+			parsedEntry, err := parser.NextEntry()
+			require.NoError(t, err)
+			require.Equal(t, parsedEntry.Path, testCase.submodule)
+			require.Equal(t, parsedEntry.Oid, testCase.commitSha)
+		})
+	}
+}
+
+func TestFailedUserUpdateSubmoduleRequestDueToValidations(t *testing.T) {
+	server, serverSocketPath := runOperationServiceServer(t)
+	defer server.Stop()
+
+	client, conn := NewOperationClient(t, serverSocketPath)
+	defer conn.Close()
+
+	testRepo, _, cleanup := testhelper.NewTestRepo(t)
+	defer cleanup()
+
+	testCases := []struct {
+		desc    string
+		request *gitalypb.UserUpdateSubmoduleRequest
+		code    codes.Code
+	}{
+		{
+			desc: "empty Repository",
+			request: &gitalypb.UserUpdateSubmoduleRequest{
+				Repository:    nil,
+				User:          user,
+				Submodule:     []byte("six"),
+				CommitSha:     "db54006ff1c999fd485af44581dabe9b6c85a701",
+				Branch:        []byte("some-branch"),
+				CommitMessage: []byte("Update Submodule message"),
+			},
+			code: codes.InvalidArgument,
+		},
+		{
+			desc: "empty User",
+			request: &gitalypb.UserUpdateSubmoduleRequest{
+				Repository:    testRepo,
+				User:          nil,
+				Submodule:     []byte("six"),
+				CommitSha:     "db54006ff1c999fd485af44581dabe9b6c85a701",
+				Branch:        []byte("some-branch"),
+				CommitMessage: []byte("Update Submodule message"),
+			},
+			code: codes.InvalidArgument,
+		},
+		{
+			desc: "empty Submodule",
+			request: &gitalypb.UserUpdateSubmoduleRequest{
+				Repository:    testRepo,
+				User:          user,
+				Submodule:     nil,
+				CommitSha:     "db54006ff1c999fd485af44581dabe9b6c85a701",
+				Branch:        []byte("some-branch"),
+				CommitMessage: []byte("Update Submodule message"),
+			},
+			code: codes.InvalidArgument,
+		},
+		{
+			desc: "empty CommitSha",
+			request: &gitalypb.UserUpdateSubmoduleRequest{
+				Repository:    testRepo,
+				User:          user,
+				Submodule:     []byte("six"),
+				CommitSha:     "",
+				Branch:        []byte("some-branch"),
+				CommitMessage: []byte("Update Submodule message"),
+			},
+			code: codes.InvalidArgument,
+		},
+		{
+			desc: "invalid CommitSha",
+			request: &gitalypb.UserUpdateSubmoduleRequest{
+				Repository:    testRepo,
+				User:          user,
+				Submodule:     []byte("six"),
+				CommitSha:     "foobar",
+				Branch:        []byte("some-branch"),
+				CommitMessage: []byte("Update Submodule message"),
+			},
+			code: codes.InvalidArgument,
+		},
+		{
+			desc: "invalid CommitSha",
+			request: &gitalypb.UserUpdateSubmoduleRequest{
+				Repository:    testRepo,
+				User:          user,
+				Submodule:     []byte("six"),
+				CommitSha:     "db54006ff1c999fd485a",
+				Branch:        []byte("some-branch"),
+				CommitMessage: []byte("Update Submodule message"),
+			},
+			code: codes.InvalidArgument,
+		},
+		{
+			desc: "empty Branch",
+			request: &gitalypb.UserUpdateSubmoduleRequest{
+				Repository:    testRepo,
+				User:          user,
+				Submodule:     []byte("six"),
+				CommitSha:     "db54006ff1c999fd485af44581dabe9b6c85a701",
+				Branch:        nil,
+				CommitMessage: []byte("Update Submodule message"),
+			},
+			code: codes.InvalidArgument,
+		},
+		{
+			desc: "empty CommitMessage",
+			request: &gitalypb.UserUpdateSubmoduleRequest{
+				Repository:    testRepo,
+				User:          user,
+				Submodule:     []byte("six"),
+				CommitSha:     "db54006ff1c999fd485af44581dabe9b6c85a701",
+				Branch:        []byte("some-branch"),
+				CommitMessage: nil,
+			},
+			code: codes.InvalidArgument,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.desc, func(t *testing.T) {
+			ctx, cancel := testhelper.Context()
+			defer cancel()
+
+			_, err := client.UserUpdateSubmodule(ctx, testCase.request)
+			testhelper.RequireGrpcError(t, err, testCase.code)
+			require.Contains(t, err.Error(), testCase.desc)
+		})
+	}
+}
+
+func TestFailedUserUpdateSubmoduleRequestDueToInvalidBranch(t *testing.T) {
+	ctx, cancel := testhelper.Context()
+	defer cancel()
+
+	server, serverSocketPath := runOperationServiceServer(t)
+	defer server.Stop()
+
+	client, conn := NewOperationClient(t, serverSocketPath)
+	defer conn.Close()
+
+	testRepo, _, cleanup := testhelper.NewTestRepo(t)
+	defer cleanup()
+
+	request := &gitalypb.UserUpdateSubmoduleRequest{
+		Repository:    testRepo,
+		User:          user,
+		Submodule:     []byte("six"),
+		CommitSha:     "db54006ff1c999fd485af44581dabe9b6c85a701",
+		Branch:        []byte("non/existent"),
+		CommitMessage: []byte("Update Submodule message"),
+	}
+
+	_, err := client.UserUpdateSubmodule(ctx, request)
+	testhelper.RequireGrpcError(t, err, codes.InvalidArgument)
+	require.Contains(t, err.Error(), "Cannot find branch")
+}
+
+func TestFailedUserUpdateSubmoduleRequestDueToInvalidSubmodule(t *testing.T) {
+	ctx, cancel := testhelper.Context()
+	defer cancel()
+
+	server, serverSocketPath := runOperationServiceServer(t)
+	defer server.Stop()
+
+	client, conn := NewOperationClient(t, serverSocketPath)
+	defer conn.Close()
+
+	testRepo, _, cleanup := testhelper.NewTestRepo(t)
+	defer cleanup()
+
+	request := &gitalypb.UserUpdateSubmoduleRequest{
+		Repository:    testRepo,
+		User:          user,
+		Submodule:     []byte("non-existent-submodule"),
+		CommitSha:     "db54006ff1c999fd485af44581dabe9b6c85a701",
+		Branch:        []byte("master"),
+		CommitMessage: []byte("Update Submodule message"),
+	}
+
+	response, err := client.UserUpdateSubmodule(ctx, request)
+	require.NoError(t, err)
+	require.Equal(t, response.CommitError, "Invalid submodule path")
+}
+
+func TestFailedUserUpdateSubmoduleRequestDueToSameReference(t *testing.T) {
+	ctx, cancel := testhelper.Context()
+	defer cancel()
+
+	server, serverSocketPath := runOperationServiceServer(t)
+	defer server.Stop()
+
+	client, conn := NewOperationClient(t, serverSocketPath)
+	defer conn.Close()
+
+	testRepo, _, cleanup := testhelper.NewTestRepo(t)
+	defer cleanup()
+
+	request := &gitalypb.UserUpdateSubmoduleRequest{
+		Repository:    testRepo,
+		User:          user,
+		Submodule:     []byte("six"),
+		CommitSha:     "41fa1bc9e0f0630ced6a8a211d60c2af425ecc2d",
+		Branch:        []byte("master"),
+		CommitMessage: []byte("Update Submodule message"),
+	}
+
+	_, err := client.UserUpdateSubmodule(ctx, request)
+	require.NoError(t, err)
+
+	response, err := client.UserUpdateSubmodule(ctx, request)
+	require.NoError(t, err)
+	require.Contains(t, response.CommitError, "is already at")
+}
+
+func TestFailedUserUpdateSubmoduleRequestDueToRepositoryEmpty(t *testing.T) {
+	ctx, cancel := testhelper.Context()
+	defer cancel()
+
+	server, serverSocketPath := runOperationServiceServer(t)
+	defer server.Stop()
+
+	client, conn := NewOperationClient(t, serverSocketPath)
+	defer conn.Close()
+
+	testRepo, _, cleanup := testhelper.InitRepoWithWorktree(t)
+	defer cleanup()
+
+	request := &gitalypb.UserUpdateSubmoduleRequest{
+		Repository:    testRepo,
+		User:          user,
+		Submodule:     []byte("six"),
+		CommitSha:     "41fa1bc9e0f0630ced6a8a211d60c2af425ecc2d",
+		Branch:        []byte("master"),
+		CommitMessage: []byte("Update Submodule message"),
+	}
+
+	response, err := client.UserUpdateSubmodule(ctx, request)
+	require.NoError(t, err)
+	require.Equal(t, response.CommitError, "Repository is empty")
+}
diff --git a/ruby/.rubocop_todo.yml b/ruby/.rubocop_todo.yml
index 09cd8aae3..9e688a186 100644
--- a/ruby/.rubocop_todo.yml
+++ b/ruby/.rubocop_todo.yml
@@ -73,7 +73,7 @@ Metrics/BlockLength:
 # Offense count: 11
 # Configuration parameters: CountComments.
 Metrics/ClassLength:
-  Max: 780
+  Max: 850
 
 # Offense count: 9
 Metrics/CyclomaticComplexity:
diff --git a/ruby/Gemfile b/ruby/Gemfile
index 9c821b31d..016f80284 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.121.0', require: 'gitaly'
+gem 'gitaly-proto', '~> 0.123.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 9436d27bb..034085352 100644
--- a/ruby/Gemfile.lock
+++ b/ruby/Gemfile.lock
@@ -30,7 +30,7 @@ GEM
       multipart-post (>= 1.2, < 3)
     gemojione (3.3.0)
       json
-    gitaly-proto (0.121.0)
+    gitaly-proto (0.123.0)
       grpc (~> 1.0)
     github-linguist (6.2.0)
       charlock_holmes (~> 0.7.6)
@@ -150,7 +150,7 @@ DEPENDENCIES
   bundler (>= 1.16.5)
   factory_bot
   faraday (~> 0.12)
-  gitaly-proto (~> 0.121.0)
+  gitaly-proto (~> 0.123.0)
   github-linguist (~> 6.1)
   gitlab-gollum-lib (~> 4.2)
   gitlab-gollum-rugged_adapter (~> 0.4.4)
@@ -167,4 +167,4 @@ DEPENDENCIES
   timecop
 
 BUNDLED WITH
-   1.16.6
+   1.17.1
diff --git a/ruby/lib/gitaly_server/operations_service.rb b/ruby/lib/gitaly_server/operations_service.rb
index af73d72cf..a5d4fc278 100644
--- a/ruby/lib/gitaly_server/operations_service.rb
+++ b/ruby/lib/gitaly_server/operations_service.rb
@@ -320,6 +320,30 @@ module GitalyServer
       end
     end
 
+    def user_update_submodule(request, call)
+      bridge_exceptions do
+        user = Gitlab::Git::User.from_gitaly(request.user)
+
+        begin
+          branch_update = Gitlab::Git::Repository.from_gitaly_with_block(request.repository, call) do |repo|
+            begin
+              Gitlab::Git::Submodule
+                .new(user, repo, request.submodule, request.branch)
+                .update(request.commit_sha, request.commit_message.dup)
+            rescue ArgumentError => e
+              raise GRPC::InvalidArgument.new(e.to_s)
+            end
+          end
+
+          Gitaly::UserUpdateSubmoduleResponse.new(branch_update: branch_update_result(branch_update))
+        rescue Gitlab::Git::CommitError => e
+          Gitaly::UserUpdateSubmoduleResponse.new(commit_error: set_utf8!(e.message))
+        rescue Gitlab::Git::PreReceiveError => e
+          Gitaly::UserUpdateSubmoduleResponse.new(pre_receive_error: set_utf8!(e.message))
+        end
+      end
+    end
+
     private
 
     def commit_files_opts(call, header, actions)
diff --git a/ruby/lib/gitlab/git/index.rb b/ruby/lib/gitlab/git/index.rb
index f6bf1dfe0..701811045 100644
--- a/ruby/lib/gitlab/git/index.rb
+++ b/ruby/lib/gitlab/git/index.rb
@@ -106,13 +106,9 @@ module Gitlab
       def normalize_path(path)
         raise IndexError, "You must provide a file path" unless path
 
-        pathname = Gitlab::Git::PathHelper.normalize_path(path.dup)
-
-        pathname.each_filename do |segment|
-          raise IndexError, 'Path cannot include directory traversal' if segment == '..'
-        end
-
-        pathname.to_s
+        Gitlab::Git::PathHelper.normalize_path!(path.dup)
+      rescue Gitlab::Git::PathHelper::InvalidPath => e
+        raise IndexError, e.message
       end
 
       def add_blob(options, mode: nil)
diff --git a/ruby/lib/gitlab/git/path_helper.rb b/ruby/lib/gitlab/git/path_helper.rb
index 57b82a37d..8624fb408 100644
--- a/ruby/lib/gitlab/git/path_helper.rb
+++ b/ruby/lib/gitlab/git/path_helper.rb
@@ -3,14 +3,24 @@
 module Gitlab
   module Git
     class PathHelper
+      InvalidPath = Class.new(StandardError)
+
       class << self
-        def normalize_path(filename)
+        def normalize_path!(filename)
+          return unless filename
+
           # Strip all leading slashes so that //foo -> foo
           filename = filename.sub(%r{\A/*}, '')
 
           # Expand relative paths (e.g. foo/../bar)
           filename = Pathname.new(filename)
           filename.relative_path_from(Pathname.new(''))
+
+          filename.each_filename do |segment|
+            raise InvalidPath, 'Path cannot include directory traversal' if segment == '..'
+          end
+
+          filename.to_s
         end
       end
     end
diff --git a/ruby/lib/gitlab/git/repository.rb b/ruby/lib/gitlab/git/repository.rb
index 92f0ddb2a..00a7c9866 100644
--- a/ruby/lib/gitlab/git/repository.rb
+++ b/ruby/lib/gitlab/git/repository.rb
@@ -513,6 +513,32 @@ module Gitlab
         end
       end
 
+      def update_submodule(submodule_path, commit_sha, branch, committer, message)
+        target = rugged.rev_parse(branch)
+        raise CommitError, 'Invalid branch' unless target.is_a?(Rugged::Commit)
+
+        current_entry = rugged_submodule_entry(target, submodule_path)
+        raise CommitError, 'Invalid submodule path' unless current_entry
+        raise CommitError, "The submodule #{submodule_path} is already at #{commit_sha}" if commit_sha == current_entry[:oid]
+
+        commit_tree = target.tree.update([action: :upsert,
+                                          oid: commit_sha,
+                                          filemode: 0o160000,
+                                          path: submodule_path])
+
+        options = {
+          parents: [target.oid],
+          tree: commit_tree,
+          message: message,
+          author: committer,
+          committer: committer
+        }
+
+        create_commit(options).tap do |result|
+          raise CommitError, 'Failed to create commit' unless result
+        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)
 
@@ -1087,6 +1113,22 @@ module Gitlab
       def rev_list_param(spec)
         spec == :all ? ['--all'] : spec
       end
+
+      def rugged_submodule_entry(target, submodule_path)
+        parent_dir = File.dirname(submodule_path)
+        parent_dir = '' if parent_dir == '.'
+        parent_tree = rugged.rev_parse("#{target.oid}^{tree}:#{parent_dir}")
+
+        return unless parent_tree.is_a?(Rugged::Tree)
+
+        current_entry = parent_tree[File.basename(submodule_path)]
+
+        valid_submodule_entry?(current_entry) ? current_entry : nil
+      end
+
+      def valid_submodule_entry?(entry)
+        entry && entry[:type] == :commit
+      end
     end
   end
 end
diff --git a/ruby/lib/gitlab/git/submodule.rb b/ruby/lib/gitlab/git/submodule.rb
new file mode 100644
index 000000000..03a39576f
--- /dev/null
+++ b/ruby/lib/gitlab/git/submodule.rb
@@ -0,0 +1,37 @@
+module Gitlab
+  module Git
+    class Submodule
+      attr_reader :user, :repository, :submodule_path, :branch_name
+
+      def initialize(user, repository, submodule_path, branch_name)
+        @user = user
+        @repository = repository
+        @branch_name = branch_name
+
+        begin
+          @submodule_path = Gitlab::Git::PathHelper.normalize_path!(submodule_path.dup)
+        rescue Gitlab::Git::PathHelper::InvalidPath => e
+          raise ArgumentError, e.message
+        end
+      end
+
+      def update(commit_sha, message)
+        validate!
+
+        OperationService.new(user, repository).with_branch(branch_name, start_branch_name: branch_name) do
+          committer = repository.user_to_committer(user)
+
+          repository.update_submodule(submodule_path, commit_sha, branch_name, committer, message)
+        end
+      end
+
+      private
+
+      def validate!
+        raise ArgumentError, 'User cannot be empty' unless user
+        raise ArgumentError, 'Submodule can not be empty' unless submodule_path.present?
+        raise CommitError, 'Repository is empty' if repository.empty?
+      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 b6d7e065e..5708a7711 100644
--- a/ruby/spec/lib/gitlab/git/repository_spec.rb
+++ b/ruby/spec/lib/gitlab/git/repository_spec.rb
@@ -770,6 +770,32 @@ describe Gitlab::Git::Repository do # rubocop:disable Metrics/BlockLength
     end
   end
 
+  describe '#update_submodule' do
+    let(:new_oid) { 'db97db76ecd478eb361f439807438f82d97b29a5' }
+    let(:repository) { gitlab_git_from_gitaly(new_mutable_test_repo) }
+    let(:submodule) { 'gitlab-grack' }
+    let(:head_commit) { repository.commit(branch) }
+    let!(:head_submodule_reference) { repository.blob_at(head_commit.id, submodule).id }
+    let(:committer) { repository.user_to_committer(user) }
+    let(:message) { 'Update submodule' }
+    let(:branch) { 'master' }
+
+    subject do
+      repository.update_submodule(submodule,
+                                  new_oid,
+                                  branch,
+                                  committer,
+                                  message)
+    end
+
+    it 'updates the submodule oid' do
+      blob = repository.blob_at(subject, submodule)
+
+      expect(blob.id).not_to eq head_submodule_reference
+      expect(blob.id).to eq new_oid
+    end
+  end
+
   def create_remote_branch(remote_name, branch_name, source_branch_name)
     source_branch = repository.branches.find { |branch| branch.name == source_branch_name }
     repository_rugged.references.create("refs/remotes/#{remote_name}/#{branch_name}", source_branch.dereferenced_target.sha)
diff --git a/ruby/spec/lib/gitlab/git/submodule_spec.rb b/ruby/spec/lib/gitlab/git/submodule_spec.rb
new file mode 100644
index 000000000..1b3d1f84c
--- /dev/null
+++ b/ruby/spec/lib/gitlab/git/submodule_spec.rb
@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Gitlab::Git::Submodule do
+  include TestRepo
+
+  let(:repository) { gitlab_git_from_gitaly(new_mutable_test_repo) }
+  let(:user) { Gitlab::Git::User.new('johndone', 'John Doe', 'johndoe@mail.com', 'user-1') }
+  let(:message) { 'Updating submodule' }
+  let(:branch) { 'master' }
+  let(:new_oid) { 'db97db76ecd478eb361f439807438f82d97b29a5' }
+  let(:submodule_path) { 'gitlab-grack' }
+
+  subject do
+    described_class.new(user, repository, submodule_path, branch).update(new_oid, message)
+  end
+
+  describe '#validate!' do
+    context 'with repository' do
+      let(:repository) { gitlab_git_from_gitaly(new_empty_test_repo) }
+
+      it 'raises error if empty' do
+        expect { subject }.to raise_error(Gitlab::Git::CommitError, 'Repository is empty')
+      end
+    end
+
+    context 'with user' do
+      let(:user) { nil }
+
+      it 'raises error if not present' do
+        expect { subject }.to raise_error(ArgumentError, 'User cannot be empty')
+      end
+    end
+
+    context 'with submodule' do
+      context 'when is not present' do
+        let(:submodule_path) { '' }
+
+        it 'raises error' do
+          expect { subject }.to raise_error(ArgumentError, 'Submodule can not be empty')
+        end
+      end
+
+      context 'when it has path traversal' do
+        let(:submodule_path) { '../gitlab-grack' }
+
+        it 'raises error' do
+          expect { subject }.to raise_error(ArgumentError, 'Path cannot include directory traversal')
+        end
+      end
+    end
+  end
+
+  describe '#update' do
+    it 'updates the submodule oid' do
+      update_commit = subject
+
+      blob = repository.blob_at(update_commit.newrev, submodule_path)
+
+      expect(repository.commit.id).to eq update_commit.newrev
+      expect(blob.id).to eq new_oid
+    end
+
+    context 'when branch is not master' do
+      let(:branch) { 'csv' }
+
+      it 'updates submodule oid' do
+        update_commit = subject
+
+        blob = repository.blob_at(update_commit.newrev, submodule_path)
+
+        expect(repository.commit(branch).id).to eq update_commit.newrev
+        expect(blob.id).to eq new_oid
+      end
+    end
+
+    context 'when submodule inside folder' do
+      let(:branch) { 'submodule_inside_folder' }
+      let(:submodule_path) { 'test_inside_folder/another_folder/six' }
+      let(:new_oid) { 'e25eda1fece24ac7a03624ed1320f82396f35bd8' }
+
+      it 'updates submodule oid' do
+        update_commit = subject
+
+        blob = repository.blob_at(update_commit.newrev, submodule_path)
+
+        expect(repository.commit(branch).id).to eq update_commit.newrev
+        expect(blob.id).to eq new_oid
+      end
+    end
+  end
+end
diff --git a/ruby/spec/lib/gitlab/git/wiki_spec.rb b/ruby/spec/lib/gitlab/git/wiki_spec.rb
index baf07c016..08292df97 100644
--- a/ruby/spec/lib/gitlab/git/wiki_spec.rb
+++ b/ruby/spec/lib/gitlab/git/wiki_spec.rb
@@ -4,7 +4,6 @@ describe Gitlab::Git::Wiki do
   include TestRepo
 
   let(:repository) { gitlab_git_from_gitaly(new_empty_test_repo) }
-  let(:user) { project.owner }
 
   subject { described_class.new(repository) }
 
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 99b674910..137f29866 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
@@ -137,6 +137,8 @@ It has these top-level messages:
 	UserSquashResponse
 	UserApplyPatchRequest
 	UserApplyPatchResponse
+	UserUpdateSubmoduleRequest
+	UserUpdateSubmoduleResponse
 	ListNewBlobsRequest
 	ListNewBlobsResponse
 	FindDefaultBranchNameRequest
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 7c78f83ea..d93204629 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
@@ -1503,6 +1503,94 @@ func (m *UserApplyPatchResponse) GetBranchUpdate() *OperationBranchUpdate {
 	return nil
 }
 
+type UserUpdateSubmoduleRequest struct {
+	Repository    *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	User          *User       `protobuf:"bytes,2,opt,name=user" json:"user,omitempty"`
+	CommitSha     string      `protobuf:"bytes,3,opt,name=commit_sha,json=commitSha" json:"commit_sha,omitempty"`
+	Branch        []byte      `protobuf:"bytes,4,opt,name=branch,proto3" json:"branch,omitempty"`
+	Submodule     []byte      `protobuf:"bytes,5,opt,name=submodule,proto3" json:"submodule,omitempty"`
+	CommitMessage []byte      `protobuf:"bytes,6,opt,name=commit_message,json=commitMessage,proto3" json:"commit_message,omitempty"`
+}
+
+func (m *UserUpdateSubmoduleRequest) Reset()                    { *m = UserUpdateSubmoduleRequest{} }
+func (m *UserUpdateSubmoduleRequest) String() string            { return proto.CompactTextString(m) }
+func (*UserUpdateSubmoduleRequest) ProtoMessage()               {}
+func (*UserUpdateSubmoduleRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{30} }
+
+func (m *UserUpdateSubmoduleRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *UserUpdateSubmoduleRequest) GetUser() *User {
+	if m != nil {
+		return m.User
+	}
+	return nil
+}
+
+func (m *UserUpdateSubmoduleRequest) GetCommitSha() string {
+	if m != nil {
+		return m.CommitSha
+	}
+	return ""
+}
+
+func (m *UserUpdateSubmoduleRequest) GetBranch() []byte {
+	if m != nil {
+		return m.Branch
+	}
+	return nil
+}
+
+func (m *UserUpdateSubmoduleRequest) GetSubmodule() []byte {
+	if m != nil {
+		return m.Submodule
+	}
+	return nil
+}
+
+func (m *UserUpdateSubmoduleRequest) GetCommitMessage() []byte {
+	if m != nil {
+		return m.CommitMessage
+	}
+	return nil
+}
+
+type UserUpdateSubmoduleResponse struct {
+	BranchUpdate    *OperationBranchUpdate `protobuf:"bytes,1,opt,name=branch_update,json=branchUpdate" json:"branch_update,omitempty"`
+	PreReceiveError string                 `protobuf:"bytes,2,opt,name=pre_receive_error,json=preReceiveError" json:"pre_receive_error,omitempty"`
+	CommitError     string                 `protobuf:"bytes,4,opt,name=commit_error,json=commitError" json:"commit_error,omitempty"`
+}
+
+func (m *UserUpdateSubmoduleResponse) Reset()                    { *m = UserUpdateSubmoduleResponse{} }
+func (m *UserUpdateSubmoduleResponse) String() string            { return proto.CompactTextString(m) }
+func (*UserUpdateSubmoduleResponse) ProtoMessage()               {}
+func (*UserUpdateSubmoduleResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{31} }
+
+func (m *UserUpdateSubmoduleResponse) GetBranchUpdate() *OperationBranchUpdate {
+	if m != nil {
+		return m.BranchUpdate
+	}
+	return nil
+}
+
+func (m *UserUpdateSubmoduleResponse) GetPreReceiveError() string {
+	if m != nil {
+		return m.PreReceiveError
+	}
+	return ""
+}
+
+func (m *UserUpdateSubmoduleResponse) GetCommitError() string {
+	if m != nil {
+		return m.CommitError
+	}
+	return ""
+}
+
 func init() {
 	proto.RegisterType((*UserCreateBranchRequest)(nil), "gitaly.UserCreateBranchRequest")
 	proto.RegisterType((*UserCreateBranchResponse)(nil), "gitaly.UserCreateBranchResponse")
@@ -1535,6 +1623,8 @@ func init() {
 	proto.RegisterType((*UserApplyPatchRequest)(nil), "gitaly.UserApplyPatchRequest")
 	proto.RegisterType((*UserApplyPatchRequest_Header)(nil), "gitaly.UserApplyPatchRequest.Header")
 	proto.RegisterType((*UserApplyPatchResponse)(nil), "gitaly.UserApplyPatchResponse")
+	proto.RegisterType((*UserUpdateSubmoduleRequest)(nil), "gitaly.UserUpdateSubmoduleRequest")
+	proto.RegisterType((*UserUpdateSubmoduleResponse)(nil), "gitaly.UserUpdateSubmoduleResponse")
 	proto.RegisterEnum("gitaly.UserCommitFilesActionHeader_ActionType", UserCommitFilesActionHeader_ActionType_name, UserCommitFilesActionHeader_ActionType_value)
 }
 
@@ -1562,6 +1652,7 @@ type OperationServiceClient interface {
 	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)
+	UserUpdateSubmodule(ctx context.Context, in *UserUpdateSubmoduleRequest, opts ...grpc.CallOption) (*UserUpdateSubmoduleResponse, error)
 }
 
 type operationServiceClient struct {
@@ -1761,6 +1852,15 @@ func (x *operationServiceUserApplyPatchClient) CloseAndRecv() (*UserApplyPatchRe
 	return m, nil
 }
 
+func (c *operationServiceClient) UserUpdateSubmodule(ctx context.Context, in *UserUpdateSubmoduleRequest, opts ...grpc.CallOption) (*UserUpdateSubmoduleResponse, error) {
+	out := new(UserUpdateSubmoduleResponse)
+	err := grpc.Invoke(ctx, "/gitaly.OperationService/UserUpdateSubmodule", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // Server API for OperationService service
 
 type OperationServiceServer interface {
@@ -1777,6 +1877,7 @@ type OperationServiceServer interface {
 	UserRebase(context.Context, *UserRebaseRequest) (*UserRebaseResponse, error)
 	UserSquash(context.Context, *UserSquashRequest) (*UserSquashResponse, error)
 	UserApplyPatch(OperationService_UserApplyPatchServer) error
+	UserUpdateSubmodule(context.Context, *UserUpdateSubmoduleRequest) (*UserUpdateSubmoduleResponse, error)
 }
 
 func RegisterOperationServiceServer(s *grpc.Server, srv OperationServiceServer) {
@@ -2041,6 +2142,24 @@ func (x *operationServiceUserApplyPatchServer) Recv() (*UserApplyPatchRequest, e
 	return m, nil
 }
 
+func _OperationService_UserUpdateSubmodule_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UserUpdateSubmoduleRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(OperationServiceServer).UserUpdateSubmodule(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.OperationService/UserUpdateSubmodule",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(OperationServiceServer).UserUpdateSubmodule(ctx, req.(*UserUpdateSubmoduleRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _OperationService_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "gitaly.OperationService",
 	HandlerType: (*OperationServiceServer)(nil),
@@ -2085,6 +2204,10 @@ var _OperationService_serviceDesc = grpc.ServiceDesc{
 			MethodName: "UserSquash",
 			Handler:    _OperationService_UserSquash_Handler,
 		},
+		{
+			MethodName: "UserUpdateSubmodule",
+			Handler:    _OperationService_UserUpdateSubmodule_Handler,
+		},
 	},
 	Streams: []grpc.StreamDesc{
 		{
@@ -2110,107 +2233,113 @@ var _OperationService_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("operations.proto", fileDescriptor6) }
 
 var fileDescriptor6 = []byte{
-	// 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,
+	// 1723 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x59, 0xcf, 0x6f, 0x1b, 0xd5,
+	0x13, 0xf7, 0xda, 0xce, 0xc6, 0x99, 0x38, 0x89, 0xf3, 0xfa, 0x2b, 0x75, 0x93, 0x26, 0xdd, 0xb4,
+	0xdf, 0x6f, 0x5b, 0xa1, 0x08, 0x05, 0x04, 0xa7, 0x82, 0xf2, 0xc3, 0x21, 0x2d, 0xa4, 0x0d, 0x9b,
+	0xa4, 0x70, 0x40, 0x5a, 0x36, 0xf6, 0xc3, 0x5e, 0x61, 0x7b, 0xdd, 0xb7, 0xeb, 0xd0, 0x20, 0xc4,
+	0x05, 0x01, 0x57, 0x4e, 0x5c, 0x10, 0x12, 0x88, 0x1b, 0xe2, 0xc2, 0x85, 0x03, 0x07, 0xc4, 0x15,
+	0x4e, 0x48, 0x3d, 0xf0, 0x5f, 0xf0, 0x37, 0xa0, 0xf7, 0x66, 0xd6, 0xfb, 0xd3, 0x51, 0x5a, 0x12,
+	0xb5, 0x42, 0xdc, 0xe2, 0x79, 0xb3, 0xf3, 0x66, 0x3e, 0xf3, 0xf3, 0x4d, 0xa0, 0xe2, 0xf6, 0xb8,
+	0xb0, 0x7d, 0xc7, 0xed, 0x7a, 0x4b, 0x3d, 0xe1, 0xfa, 0x2e, 0xd3, 0x9b, 0x8e, 0x6f, 0xb7, 0x0f,
+	0xab, 0x65, 0xaf, 0x65, 0x0b, 0xde, 0x40, 0xaa, 0xf1, 0xa3, 0x06, 0x17, 0xf6, 0x3c, 0x2e, 0xd6,
+	0x04, 0xb7, 0x7d, 0xbe, 0x2a, 0xec, 0x6e, 0xbd, 0x65, 0xf2, 0x07, 0x7d, 0xee, 0xf9, 0x6c, 0x19,
+	0x40, 0xf0, 0x9e, 0xeb, 0x39, 0xbe, 0x2b, 0x0e, 0x67, 0xb4, 0x05, 0xed, 0xfa, 0xf8, 0x32, 0x5b,
+	0x42, 0x31, 0x4b, 0xe6, 0xe0, 0xc4, 0x8c, 0x70, 0xb1, 0x79, 0x18, 0xdf, 0x57, 0x42, 0xac, 0xae,
+	0xdd, 0xe1, 0x33, 0xf9, 0x05, 0xed, 0x7a, 0xd9, 0x04, 0x24, 0xdd, 0xb5, 0x3b, 0x9c, 0x2d, 0x40,
+	0xb1, 0xef, 0x71, 0x31, 0x53, 0x50, 0xe2, 0xca, 0x81, 0x38, 0xa9, 0x83, 0xa9, 0x4e, 0xa4, 0x08,
+	0xcf, 0xb7, 0x85, 0x6f, 0xf5, 0x5c, 0xa7, 0xeb, 0xcf, 0x14, 0x51, 0x84, 0x22, 0x6d, 0x4b, 0x8a,
+	0xd1, 0x85, 0x99, 0xb4, 0xca, 0x5e, 0xcf, 0xed, 0x7a, 0x9c, 0xfd, 0x0f, 0x74, 0xbc, 0x8c, 0xf4,
+	0x9d, 0x0c, 0x2e, 0x20, 0x3e, 0x3a, 0x65, 0x37, 0x61, 0xba, 0x27, 0xb8, 0x25, 0x78, 0x9d, 0x3b,
+	0x07, 0xdc, 0xe2, 0x42, 0xb8, 0x42, 0x69, 0x3b, 0x66, 0x4e, 0xf5, 0x04, 0x37, 0x91, 0x5e, 0x93,
+	0x64, 0xe3, 0x57, 0xc2, 0x68, 0xaf, 0xd7, 0x78, 0x56, 0x30, 0x3a, 0x0f, 0x7a, 0x97, 0x7f, 0x20,
+	0xf8, 0x01, 0xc1, 0x43, 0xbf, 0x24, 0xdd, 0x6d, 0x37, 0x24, 0x7d, 0x04, 0xe9, 0xf8, 0xcb, 0xd8,
+	0x40, 0xc8, 0xe2, 0x16, 0x10, 0x64, 0x99, 0x50, 0x68, 0xd9, 0x50, 0x7c, 0x41, 0x50, 0xac, 0xf3,
+	0x36, 0x7f, 0x36, 0xa0, 0x08, 0x4c, 0x8b, 0x6b, 0xf4, 0x04, 0xa6, 0x7d, 0xae, 0xc1, 0xd9, 0x50,
+	0xd0, 0xae, 0xdd, 0xfc, 0x27, 0x76, 0x5d, 0x84, 0x92, 0x6f, 0x37, 0xa3, 0x46, 0x8d, 0xfa, 0x76,
+	0xf3, 0x98, 0x16, 0xad, 0xc1, 0xb9, 0x84, 0x22, 0x4f, 0x60, 0xce, 0xef, 0x64, 0x0e, 0x66, 0xc9,
+	0x53, 0x34, 0x87, 0xfd, 0x1f, 0xa6, 0x7c, 0x5b, 0x34, 0xb9, 0x6f, 0x09, 0x7e, 0xe0, 0x78, 0x8e,
+	0xdb, 0xa5, 0xa0, 0x9d, 0x44, 0xb2, 0x49, 0x54, 0x36, 0x03, 0xa3, 0x1d, 0xee, 0x79, 0x76, 0x93,
+	0x53, 0xf4, 0x06, 0x3f, 0x8d, 0x0f, 0x11, 0x91, 0x88, 0x2d, 0x84, 0xc8, 0x1c, 0x14, 0x7c, 0xbb,
+	0x49, 0x56, 0x8c, 0x07, 0x97, 0x4b, 0x0e, 0x49, 0x97, 0xe9, 0xc0, 0x1f, 0x3a, 0x9e, 0xef, 0x29,
+	0xad, 0x4b, 0x26, 0xfd, 0xca, 0x06, 0xb2, 0x90, 0x0d, 0xe4, 0x23, 0x0d, 0xce, 0xcb, 0xcb, 0xb7,
+	0xb8, 0x68, 0x9e, 0x40, 0xc4, 0x07, 0x78, 0xe5, 0x87, 0xe2, 0x75, 0x09, 0xc6, 0xea, 0x6e, 0xa7,
+	0xe3, 0xf8, 0x96, 0xd3, 0x20, 0xa5, 0x4a, 0x48, 0xb8, 0xdd, 0x90, 0x16, 0x51, 0x7d, 0xa3, 0xc4,
+	0xa7, 0x7a, 0x36, 0x14, 0x3b, 0x76, 0x16, 0x46, 0xec, 0x5e, 0xaf, 0x7d, 0x38, 0xa3, 0x2b, 0x08,
+	0xf0, 0x87, 0xf1, 0x03, 0x25, 0x72, 0xcc, 0x2a, 0x02, 0x35, 0xa6, 0x80, 0x96, 0x50, 0x60, 0x15,
+	0x26, 0x28, 0x63, 0xfb, 0xaa, 0x98, 0x90, 0xe3, 0xe7, 0x02, 0x43, 0xee, 0x05, 0x7d, 0x07, 0x85,
+	0x62, 0xc5, 0x31, 0xcb, 0xfb, 0x91, 0x5f, 0xd9, 0xf0, 0x17, 0x33, 0xe1, 0xbf, 0x53, 0x2c, 0xe5,
+	0x2b, 0x05, 0xe3, 0x63, 0x38, 0x97, 0x29, 0xf8, 0x68, 0x5d, 0xaf, 0x40, 0x59, 0x22, 0x6f, 0xd5,
+	0x55, 0xdc, 0x34, 0x28, 0x08, 0xc6, 0x25, 0x0d, 0x43, 0xa9, 0xc1, 0xae, 0xc1, 0x24, 0x99, 0x13,
+	0x30, 0x15, 0x14, 0x13, 0x19, 0x49, 0x6c, 0xc6, 0x37, 0x1a, 0x9c, 0x91, 0x70, 0x6d, 0x6c, 0x3c,
+	0xab, 0x11, 0x60, 0x7c, 0x46, 0x09, 0x1f, 0xaa, 0x48, 0xee, 0x4c, 0x79, 0x4c, 0x3b, 0x21, 0x8f,
+	0x0d, 0x69, 0x97, 0xbf, 0xe4, 0x29, 0x5b, 0x5b, 0x5c, 0x88, 0xc3, 0x6d, 0xa7, 0xfe, 0xfe, 0xe9,
+	0xa2, 0x75, 0x03, 0x74, 0x04, 0x87, 0x42, 0x71, 0x3a, 0xe0, 0x79, 0xcd, 0xf1, 0xd7, 0xd4, 0x81,
+	0x49, 0x0c, 0xc9, 0x76, 0x53, 0x4c, 0xb5, 0x9b, 0xe1, 0x69, 0x74, 0x13, 0xa6, 0x71, 0x2a, 0x89,
+	0x0a, 0xd0, 0x15, 0xcf, 0x94, 0x3a, 0x58, 0x0d, 0xa5, 0xdc, 0x82, 0x0a, 0xf2, 0x46, 0xac, 0x1d,
+	0x1d, 0x6a, 0x2d, 0x7e, 0x1e, 0x12, 0x8c, 0x3f, 0xa9, 0xe2, 0x44, 0x01, 0x3c, 0x59, 0x5f, 0x62,
+	0xac, 0x5b, 0xbe, 0xe0, 0x09, 0x5f, 0xe2, 0xc1, 0xae, 0xe0, 0xe8, 0x4b, 0x99, 0x41, 0x14, 0x89,
+	0xd1, 0x1a, 0x39, 0x8e, 0x34, 0x64, 0x79, 0x8c, 0x64, 0x36, 0x7e, 0xce, 0xc3, 0xb4, 0xf2, 0x1c,
+	0x3f, 0xe0, 0xd2, 0xe4, 0xff, 0xc2, 0xe2, 0x31, 0xc2, 0xe2, 0x91, 0x06, 0x2c, 0x0a, 0xde, 0xbf,
+	0x23, 0x24, 0xfe, 0xc8, 0xc3, 0x25, 0x15, 0xec, 0xea, 0xfb, 0x0d, 0xa7, 0xcd, 0xbd, 0x95, 0xba,
+	0x54, 0x77, 0x93, 0xdb, 0x0d, 0x2e, 0xd8, 0x06, 0xe8, 0xb6, 0xfa, 0xad, 0xec, 0x9a, 0x5c, 0x5e,
+	0x8a, 0xba, 0x7a, 0xc8, 0x47, 0x4b, 0xf8, 0x63, 0xf7, 0xb0, 0xc7, 0x4d, 0xfa, 0x5a, 0xd6, 0xd4,
+	0xf7, 0x9c, 0x36, 0xb7, 0x7a, 0xb6, 0xdf, 0xa2, 0x19, 0xa6, 0x24, 0x09, 0xdb, 0xb6, 0xdf, 0x62,
+	0x8b, 0x30, 0xd1, 0x93, 0xc3, 0x89, 0xdb, 0xf7, 0x90, 0xa1, 0xa0, 0x18, 0xca, 0x01, 0x51, 0x31,
+	0xc9, 0x56, 0x61, 0x7b, 0xfc, 0xa5, 0x17, 0xad, 0xba, 0xdb, 0xf5, 0x39, 0x3d, 0x4d, 0x64, 0xab,
+	0x50, 0xd4, 0x35, 0x24, 0xb2, 0x1b, 0x50, 0xe1, 0x0f, 0x79, 0xbd, 0xef, 0x73, 0x4b, 0xca, 0xef,
+	0xb8, 0x0d, 0x0c, 0x9a, 0x92, 0x39, 0x45, 0xf4, 0x0d, 0x22, 0x1b, 0x7b, 0x00, 0xa1, 0xa6, 0x0c,
+	0x40, 0x5f, 0x33, 0x6b, 0x2b, 0xbb, 0xb5, 0x4a, 0x8e, 0x4d, 0x02, 0xe0, 0xdf, 0xd6, 0xfa, 0x6d,
+	0xb3, 0xa2, 0xc9, 0xb3, 0xbd, 0xed, 0x75, 0x79, 0x96, 0x67, 0x25, 0x28, 0x6e, 0xdd, 0xbb, 0x5f,
+	0xab, 0x14, 0x24, 0x75, 0xbd, 0xf6, 0x46, 0x6d, 0xb7, 0x56, 0x29, 0xb2, 0x31, 0x18, 0x59, 0xdb,
+	0xdc, 0xba, 0xb7, 0x5e, 0x19, 0x31, 0xbe, 0xd4, 0xa8, 0x00, 0x27, 0xd1, 0x61, 0xb7, 0x40, 0x6f,
+	0x29, 0x84, 0x28, 0x48, 0x16, 0x8f, 0x01, 0xe6, 0x66, 0xce, 0xa4, 0x8f, 0x58, 0x15, 0x46, 0x03,
+	0xd3, 0x15, 0x82, 0x9b, 0x39, 0x33, 0x20, 0xac, 0x1a, 0xb0, 0x20, 0xd3, 0xce, 0xa2, 0xd8, 0x90,
+	0xa6, 0x7b, 0x16, 0x62, 0x6f, 0xf5, 0xec, 0xc3, 0xb6, 0x6b, 0x37, 0x8c, 0x4f, 0x0b, 0x30, 0x9b,
+	0xb8, 0x89, 0x6a, 0x00, 0x39, 0xfb, 0x74, 0x2a, 0x41, 0x22, 0xbd, 0x0b, 0xa9, 0xf4, 0xbe, 0x06,
+	0x93, 0xa4, 0x76, 0x90, 0xe5, 0x58, 0x02, 0x26, 0x90, 0xba, 0x45, 0xb9, 0xfe, 0x1c, 0x30, 0x62,
+	0xb3, 0xfb, 0x7e, 0xcb, 0x15, 0x28, 0x0e, 0x0b, 0x42, 0x05, 0x4f, 0x56, 0xd4, 0x81, 0x12, 0xba,
+	0x04, 0x67, 0xe2, 0xdc, 0xbc, 0x63, 0x3b, 0x6d, 0xaa, 0x0d, 0xd3, 0x51, 0xf6, 0x9a, 0x3c, 0xc8,
+	0xae, 0x24, 0xa3, 0xc7, 0xaf, 0x24, 0xa5, 0xe3, 0x57, 0x92, 0x9f, 0x82, 0x06, 0x93, 0xf2, 0x03,
+	0x7b, 0x25, 0x11, 0x21, 0x57, 0x87, 0x44, 0x48, 0xcc, 0x6f, 0x91, 0x10, 0x79, 0x79, 0x90, 0xae,
+	0xf9, 0x78, 0x19, 0xca, 0x8e, 0xb0, 0x5c, 0x90, 0x9f, 0xab, 0x8b, 0x70, 0x25, 0x1d, 0x3f, 0x02,
+	0x6f, 0x19, 0x04, 0xd0, 0xf7, 0xc1, 0xb6, 0x22, 0xaa, 0xc8, 0x09, 0xd6, 0xc1, 0x79, 0x18, 0x77,
+	0xba, 0x0d, 0xfe, 0x30, 0x56, 0x01, 0x41, 0x91, 0x8e, 0xa8, 0x6c, 0x43, 0x1e, 0x0e, 0xdf, 0x0d,
+	0x9a, 0x9d, 0x2c, 0x10, 0xa7, 0x3e, 0x31, 0x0a, 0x75, 0x4d, 0x64, 0x62, 0x44, 0xc2, 0x11, 0x6f,
+	0x86, 0x39, 0xa0, 0x24, 0xb0, 0xbc, 0x96, 0xad, 0xe2, 0x78, 0xcc, 0x1c, 0x43, 0xca, 0x4e, 0xcb,
+	0x66, 0xaf, 0xc2, 0xb4, 0xe0, 0x1d, 0xd7, 0xe7, 0xd1, 0x28, 0xd3, 0x87, 0x2a, 0x5c, 0x41, 0xe6,
+	0x90, 0x22, 0xab, 0x2a, 0x09, 0xa0, 0xeb, 0x31, 0x9a, 0xcb, 0x48, 0x44, 0x37, 0x18, 0x1f, 0x05,
+	0x4d, 0x0d, 0x41, 0x1a, 0xbc, 0xeb, 0x80, 0xec, 0x91, 0xaa, 0xe1, 0x5c, 0x4f, 0x16, 0x4a, 0xd5,
+	0x1e, 0x63, 0x1c, 0x95, 0xd0, 0x34, 0x13, 0xcd, 0xaa, 0xd4, 0xa4, 0x4e, 0x65, 0x7c, 0x4b, 0x3e,
+	0xda, 0x79, 0xd0, 0xb7, 0xbd, 0xd3, 0x9f, 0xea, 0x3d, 0x75, 0x4d, 0xc4, 0x47, 0x48, 0x38, 0xc2,
+	0x47, 0xf2, 0x23, 0x95, 0xe9, 0xa1, 0x8b, 0x4a, 0x8a, 0x20, 0x61, 0xb8, 0x00, 0xa3, 0xbc, 0xdb,
+	0x50, 0x47, 0xba, 0x3a, 0xd2, 0x79, 0xb7, 0x21, 0x0f, 0xae, 0x82, 0x8e, 0x45, 0x87, 0xe6, 0x8b,
+	0xb8, 0x3a, 0x74, 0x96, 0x51, 0xf6, 0x4a, 0x19, 0x65, 0xcf, 0x70, 0xd0, 0x43, 0x01, 0x44, 0xa1,
+	0x87, 0xc8, 0x9a, 0x88, 0x87, 0x90, 0x22, 0x35, 0x38, 0x0a, 0x75, 0x7c, 0xd3, 0x99, 0x69, 0x17,
+	0x1a, 0x5f, 0xd3, 0xd3, 0x61, 0x45, 0xbe, 0x51, 0xb7, 0x6d, 0x3f, 0x7c, 0x68, 0x1d, 0x59, 0x97,
+	0x52, 0xec, 0x4b, 0x59, 0xad, 0xab, 0x27, 0x19, 0xb8, 0x17, 0xb6, 0x2e, 0x22, 0x54, 0x3f, 0xd1,
+	0x40, 0x3f, 0xd5, 0x06, 0xb4, 0x08, 0x13, 0xb4, 0x01, 0x21, 0x1f, 0xd3, 0x78, 0x81, 0x44, 0x4c,
+	0x84, 0x41, 0x03, 0x55, 0xef, 0x73, 0x4b, 0xe9, 0x96, 0xaa, 0x7f, 0xef, 0x60, 0xdd, 0x8e, 0xda,
+	0x7b, 0x72, 0xd5, 0xcf, 0xf8, 0x4b, 0x83, 0x6a, 0xb8, 0x25, 0xdc, 0xe9, 0xef, 0x77, 0xdc, 0x46,
+	0xbf, 0x7d, 0xca, 0x95, 0x6b, 0x0e, 0x80, 0x82, 0x50, 0xc6, 0x11, 0x46, 0x0a, 0xbd, 0x7e, 0x65,
+	0x1c, 0x0d, 0xcb, 0x8b, 0x59, 0x18, 0xf3, 0x02, 0x05, 0xa9, 0x05, 0x87, 0x84, 0x8c, 0xc8, 0xd6,
+	0xb3, 0x22, 0xfb, 0x37, 0x0d, 0x67, 0xcf, 0x94, 0xc1, 0x4f, 0xe7, 0xe5, 0x9c, 0x1a, 0xad, 0x8b,
+	0xa9, 0xd1, 0xfa, 0x4e, 0xb1, 0x54, 0xa8, 0x14, 0xcd, 0xf4, 0xb4, 0xbe, 0xfc, 0xd5, 0x18, 0x54,
+	0x06, 0xfa, 0xec, 0x70, 0x71, 0xe0, 0xd4, 0x39, 0x7b, 0x0b, 0x2a, 0xc9, 0x4d, 0x39, 0x9b, 0x8f,
+	0x75, 0xe4, 0xf4, 0xda, 0xbf, 0xba, 0x30, 0x9c, 0x01, 0x71, 0x31, 0x72, 0x81, 0xe0, 0xe8, 0x3e,
+	0x39, 0x2e, 0x38, 0x63, 0x57, 0x1e, 0x17, 0x9c, 0xb5, 0x8a, 0x0e, 0x05, 0x47, 0xb7, 0xb9, 0x71,
+	0xc1, 0x19, 0x9b, 0xe7, 0xb8, 0xe0, 0xac, 0x45, 0xb0, 0x91, 0x63, 0x77, 0x61, 0x22, 0xb6, 0x42,
+	0x64, 0xb3, 0x69, 0x33, 0xc3, 0x2d, 0x69, 0x75, 0x6e, 0xc8, 0x69, 0x52, 0xde, 0x60, 0x49, 0x1b,
+	0x97, 0x97, 0x5c, 0x22, 0xc7, 0xe5, 0xa5, 0x36, 0xbb, 0x46, 0x8e, 0xbd, 0x0d, 0x53, 0x89, 0x7d,
+	0x1c, 0xbb, 0x1c, 0xfd, 0x26, 0xbd, 0x7e, 0xac, 0xce, 0x0f, 0x3d, 0x0f, 0xa4, 0x5e, 0xd7, 0x9e,
+	0xd7, 0xd8, 0xeb, 0x50, 0x8e, 0xee, 0x85, 0xd8, 0xa5, 0xe8, 0x67, 0x89, 0x85, 0x56, 0x75, 0x36,
+	0xfb, 0x70, 0xa0, 0xe6, 0x9b, 0x30, 0x19, 0x5f, 0x4d, 0xb0, 0x38, 0x52, 0xc9, 0x9d, 0x4f, 0xf5,
+	0xf2, 0xb0, 0xe3, 0x81, 0xc8, 0x1a, 0x40, 0xf8, 0xac, 0x65, 0x17, 0x63, 0x35, 0x22, 0xba, 0x27,
+	0xa8, 0x56, 0xb3, 0x8e, 0x06, 0x62, 0xee, 0x23, 0x80, 0x91, 0xd1, 0x30, 0x0e, 0x60, 0x7a, 0x78,
+	0x8d, 0x03, 0x98, 0x31, 0x53, 0x4a, 0x00, 0x43, 0xf5, 0xe4, 0xf0, 0x91, 0x54, 0x2f, 0x32, 0xd9,
+	0x25, 0xd5, 0x8b, 0xce, 0x33, 0xa1, 0x95, 0xd8, 0x45, 0xe3, 0x62, 0x62, 0xc3, 0x47, 0x5c, 0x4c,
+	0xbc, 0xe9, 0x1a, 0x39, 0xb6, 0x83, 0xf8, 0x87, 0x1d, 0x20, 0x8e, 0x7f, 0xaa, 0x13, 0xc6, 0xf1,
+	0x4f, 0x37, 0x0e, 0x65, 0xe2, 0xbb, 0xb8, 0xdc, 0x4c, 0x94, 0x41, 0x66, 0xa4, 0xf3, 0x35, 0xd9,
+	0x14, 0xaa, 0x8b, 0x47, 0xf2, 0x04, 0x77, 0xec, 0xeb, 0xea, 0xbf, 0x8d, 0x2f, 0xfc, 0x1d, 0x00,
+	0x00, 0xff, 0xff, 0x84, 0xcd, 0xe8, 0xb5, 0x97, 0x1c, 0x00, 0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/remote.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/remote.pb.go
index 9fc7440ca..9ae8c09b6 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/remote.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/gitalypb/remote.pb.go
@@ -150,6 +150,8 @@ type UpdateRemoteMirrorRequest struct {
 	Repository           *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
 	RefName              string      `protobuf:"bytes,2,opt,name=ref_name,json=refName" json:"ref_name,omitempty"`
 	OnlyBranchesMatching [][]byte    `protobuf:"bytes,3,rep,name=only_branches_matching,json=onlyBranchesMatching,proto3" json:"only_branches_matching,omitempty"`
+	SshKey               string      `protobuf:"bytes,4,opt,name=ssh_key,json=sshKey" json:"ssh_key,omitempty"`
+	KnownHosts           string      `protobuf:"bytes,5,opt,name=known_hosts,json=knownHosts" json:"known_hosts,omitempty"`
 }
 
 func (m *UpdateRemoteMirrorRequest) Reset()                    { *m = UpdateRemoteMirrorRequest{} }
@@ -178,6 +180,20 @@ func (m *UpdateRemoteMirrorRequest) GetOnlyBranchesMatching() [][]byte {
 	return nil
 }
 
+func (m *UpdateRemoteMirrorRequest) GetSshKey() string {
+	if m != nil {
+		return m.SshKey
+	}
+	return ""
+}
+
+func (m *UpdateRemoteMirrorRequest) GetKnownHosts() string {
+	if m != nil {
+		return m.KnownHosts
+	}
+	return ""
+}
+
 type UpdateRemoteMirrorResponse struct {
 }
 
@@ -550,39 +566,41 @@ var _RemoteService_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("remote.proto", fileDescriptor8) }
 
 var fileDescriptor8 = []byte{
-	// 536 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0x4f, 0x8f, 0xd3, 0x3e,
-	0x10, 0xfd, 0xa5, 0xe9, 0xf6, 0xd7, 0x0e, 0x5d, 0xd4, 0xba, 0xd5, 0x2a, 0xcd, 0xf6, 0xd0, 0x35,
-	0x20, 0xe5, 0x42, 0x0f, 0xe5, 0xcf, 0x15, 0xb1, 0x07, 0x24, 0x40, 0xcb, 0xc1, 0x88, 0x0b, 0x12,
-	0x0a, 0xd9, 0x74, 0xb2, 0x8d, 0x94, 0xc4, 0xc1, 0x76, 0x57, 0xf4, 0x63, 0xf0, 0x0d, 0x38, 0x70,
-	0xe0, 0x63, 0xa2, 0x24, 0x4e, 0x9a, 0xd2, 0xb4, 0x48, 0xac, 0xb8, 0xd9, 0x33, 0xf3, 0xc6, 0xef,
-	0x8d, 0x9f, 0x13, 0xe8, 0x0b, 0x8c, 0xb9, 0xc2, 0x79, 0x2a, 0xb8, 0xe2, 0xa4, 0x73, 0x13, 0x2a,
-	0x2f, 0xda, 0xd8, 0x7d, 0xb9, 0xf2, 0x04, 0x2e, 0x8b, 0x28, 0xfd, 0x69, 0xc0, 0xe0, 0xe5, 0x72,
-	0xc9, 0xf2, 0x4a, 0x86, 0x5f, 0xd6, 0x28, 0x15, 0x59, 0x00, 0x08, 0x4c, 0xb9, 0x0c, 0x15, 0x17,
-	0x1b, 0xcb, 0x98, 0x19, 0xce, 0xbd, 0x05, 0x99, 0x17, 0xf8, 0x39, 0xab, 0x32, 0xac, 0x56, 0x45,
-	0x08, 0xb4, 0x13, 0x2f, 0x46, 0xab, 0x35, 0x33, 0x9c, 0x1e, 0xcb, 0xd7, 0x64, 0x00, 0xe6, 0x5a,
-	0x44, 0x96, 0x99, 0x87, 0xb2, 0x25, 0x79, 0x04, 0xf7, 0xe3, 0x50, 0x08, 0x2e, 0x5c, 0x81, 0x41,
-	0xec, 0xa5, 0xd2, 0x3a, 0x99, 0x99, 0x4e, 0x8f, 0x9d, 0x16, 0x51, 0x56, 0x04, 0xdf, 0xb4, 0xbb,
-	0xed, 0xc1, 0x49, 0x19, 0xd4, 0xa5, 0x74, 0x04, 0xc3, 0x1a, 0x53, 0x99, 0xf2, 0x44, 0x22, 0xfd,
-	0x04, 0xa3, 0x2c, 0x72, 0x8b, 0xff, 0x44, 0x01, 0x9d, 0xc3, 0x78, 0xb7, 0x7d, 0x71, 0x2c, 0x39,
-	0x83, 0x8e, 0x40, 0xb9, 0x8e, 0x54, 0xde, 0xbb, 0xcb, 0xf4, 0x8e, 0x7e, 0x33, 0xc0, 0x7e, 0x85,
-	0xca, 0x5f, 0xbd, 0x4e, 0x14, 0x8a, 0xc4, 0x8b, 0xee, 0x4e, 0xeb, 0x05, 0x0c, 0x8b, 0x7b, 0x74,
-	0x6b, 0xd0, 0xd6, 0x41, 0xe8, 0x40, 0xe8, 0x13, 0xcb, 0x08, 0x7d, 0x06, 0xe7, 0x8d, 0x94, 0xfe,
-	0x20, 0xe5, 0xbb, 0x01, 0x93, 0x0f, 0xe9, 0xd2, 0x53, 0x5a, 0xfb, 0x95, 0xbe, 0xa1, 0xbf, 0x57,
-	0x32, 0x81, 0xae, 0xc0, 0xc0, 0xad, 0x0d, 0xf9, 0x7f, 0x81, 0xc1, 0xbb, 0xcc, 0x29, 0x4f, 0xe1,
-	0x8c, 0x27, 0xd1, 0xc6, 0xbd, 0x16, 0x5e, 0xe2, 0xaf, 0x50, 0xba, 0xb1, 0xa7, 0xfc, 0x55, 0x98,
-	0xdc, 0x58, 0xe6, 0xcc, 0x74, 0xfa, 0x6c, 0x9c, 0x65, 0x2f, 0x75, 0xf2, 0x4a, 0xe7, 0xe8, 0x14,
-	0xec, 0x26, 0x86, 0xda, 0x1a, 0x99, 0xee, 0x30, 0xa9, 0x0c, 0x53, 0x51, 0xd2, 0x0a, 0x72, 0xdd,
-	0x59, 0x2a, 0x67, 0xdf, 0x63, 0x7a, 0x47, 0x9f, 0xc3, 0xb4, 0x19, 0xb6, 0x9d, 0x17, 0x7e, 0x0d,
-	0xa5, 0x92, 0xe5, 0xbc, 0x8a, 0x1d, 0x0d, 0xc0, 0xaa, 0xe1, 0x38, 0x57, 0x0c, 0x83, 0xbb, 0x4c,
-	0x6b, 0xcb, 0xaf, 0xb5, 0xc3, 0xef, 0x31, 0x4c, 0x1a, 0xce, 0xd1, 0xe4, 0x06, 0x60, 0x0a, 0x0c,
-	0xb4, 0xa2, 0x6c, 0xb9, 0xf8, 0xd1, 0x86, 0xd3, 0xa2, 0xf6, 0x3d, 0x8a, 0xdb, 0xd0, 0x47, 0x72,
-	0x09, 0xbd, 0xea, 0x1d, 0x11, 0xab, 0x64, 0xf1, 0xfb, 0x47, 0xc0, 0x9e, 0x34, 0x64, 0xf4, 0x64,
-	0xff, 0x23, 0x9f, 0x61, 0xd4, 0xe0, 0x29, 0x42, 0x4b, 0xcc, 0xe1, 0x37, 0x60, 0x3f, 0x38, 0x5a,
-	0x53, 0x9d, 0xf0, 0x16, 0xfa, 0xf5, 0x97, 0x47, 0xce, 0xb7, 0xe3, 0xda, 0x7b, 0xee, 0xf6, 0xb4,
-	0x39, 0x59, 0x35, 0x73, 0x81, 0xec, 0x1b, 0x85, 0x5c, 0x94, 0xa8, 0x83, 0x36, 0xb7, 0xe9, 0xb1,
-	0x92, 0xb2, 0xbd, 0x63, 0x10, 0x1f, 0xc6, 0x4d, 0xa6, 0x21, 0x5b, 0xb1, 0x87, 0x9d, 0x68, 0x3f,
-	0x3c, 0x5e, 0x54, 0xa9, 0xf8, 0x08, 0xc3, 0xbd, 0x9b, 0x27, 0xb3, 0x06, 0xf0, 0x8e, 0xf9, 0xec,
-	0x8b, 0x23, 0x15, 0x65, 0xef, 0xeb, 0x4e, 0xfe, 0x3b, 0x78, 0xf2, 0x2b, 0x00, 0x00, 0xff, 0xff,
-	0x6e, 0x61, 0xf7, 0x2a, 0x34, 0x06, 0x00, 0x00,
+	// 574 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0x4d, 0x6f, 0xd3, 0x30,
+	0x18, 0x26, 0x4b, 0xd7, 0xb5, 0xef, 0x3a, 0xd4, 0xba, 0xd5, 0x48, 0xb3, 0x4a, 0x74, 0x06, 0xa4,
+	0x5e, 0xe8, 0xa1, 0x7c, 0x5c, 0x11, 0x3b, 0x20, 0x60, 0x1a, 0x07, 0x23, 0x2e, 0x48, 0x28, 0x64,
+	0xed, 0x9b, 0x25, 0x5a, 0x1b, 0x17, 0xdb, 0x1d, 0xf4, 0x67, 0xf0, 0x1f, 0x38, 0xf0, 0x9b, 0xf8,
+	0x35, 0xc8, 0x89, 0x93, 0xa6, 0x34, 0x2d, 0x12, 0x13, 0x37, 0xfb, 0x79, 0x3f, 0xfc, 0x3e, 0x8f,
+	0x1f, 0x27, 0xd0, 0x10, 0x38, 0xe3, 0x0a, 0x87, 0x73, 0xc1, 0x15, 0x27, 0xd5, 0xab, 0x48, 0xf9,
+	0xd3, 0xa5, 0xdb, 0x90, 0xa1, 0x2f, 0x70, 0x92, 0xa2, 0xf4, 0xa7, 0x05, 0xcd, 0x97, 0x93, 0x09,
+	0x4b, 0x32, 0x19, 0x7e, 0x59, 0xa0, 0x54, 0x64, 0x04, 0x20, 0x70, 0xce, 0x65, 0xa4, 0xb8, 0x58,
+	0x3a, 0x56, 0xdf, 0x1a, 0x1c, 0x8e, 0xc8, 0x30, 0xad, 0x1f, 0xb2, 0x3c, 0xc2, 0x0a, 0x59, 0x84,
+	0x40, 0x25, 0xf6, 0x67, 0xe8, 0xec, 0xf5, 0xad, 0x41, 0x9d, 0x25, 0x6b, 0xd2, 0x04, 0x7b, 0x21,
+	0xa6, 0x8e, 0x9d, 0x40, 0x7a, 0x49, 0x1e, 0xc1, 0xdd, 0x59, 0x24, 0x04, 0x17, 0x9e, 0xc0, 0x60,
+	0xe6, 0xcf, 0xa5, 0xb3, 0xdf, 0xb7, 0x07, 0x75, 0x76, 0x94, 0xa2, 0x2c, 0x05, 0xdf, 0x56, 0x6a,
+	0x95, 0xe6, 0x7e, 0x06, 0x9a, 0x54, 0xda, 0x86, 0x56, 0x61, 0x52, 0x39, 0xe7, 0xb1, 0x44, 0xfa,
+	0x09, 0xda, 0x1a, 0xb9, 0xc1, 0xff, 0xc2, 0x80, 0x0e, 0xa1, 0xb3, 0xde, 0x3e, 0x3d, 0x96, 0x1c,
+	0x43, 0x55, 0xa0, 0x5c, 0x4c, 0x55, 0xd2, 0xbb, 0xc6, 0xcc, 0x8e, 0x7e, 0xb7, 0xc0, 0x7d, 0x85,
+	0x6a, 0x1c, 0xbe, 0x89, 0x15, 0x8a, 0xd8, 0x9f, 0xde, 0x7e, 0xac, 0x17, 0xd0, 0x4a, 0xef, 0xd1,
+	0x2b, 0x94, 0xee, 0x6d, 0x2d, 0x6d, 0x0a, 0x73, 0x62, 0x86, 0xd0, 0x67, 0x70, 0x52, 0x3a, 0xd2,
+	0x5f, 0xa8, 0xfc, 0xb2, 0xa0, 0xfb, 0x61, 0x3e, 0xf1, 0x95, 0xe1, 0x7e, 0x61, 0x6e, 0xe8, 0xdf,
+	0x99, 0x74, 0xa1, 0x26, 0x30, 0xf0, 0x0a, 0x22, 0x1f, 0x08, 0x0c, 0xde, 0x69, 0xa7, 0x3c, 0x85,
+	0x63, 0x1e, 0x4f, 0x97, 0xde, 0xa5, 0xf0, 0xe3, 0x71, 0x88, 0xd2, 0x9b, 0xf9, 0x6a, 0x1c, 0x46,
+	0xf1, 0x95, 0x63, 0xf7, 0xed, 0x41, 0x83, 0x75, 0x74, 0xf4, 0xcc, 0x04, 0x2f, 0x4c, 0x8c, 0xdc,
+	0x83, 0x03, 0x29, 0x43, 0xef, 0x1a, 0x97, 0x4e, 0x25, 0xe9, 0x57, 0x95, 0x32, 0x3c, 0xc7, 0x25,
+	0xb9, 0x0f, 0x87, 0xd7, 0x31, 0xff, 0x1a, 0x7b, 0x21, 0x97, 0x4a, 0x7b, 0x4c, 0x07, 0x21, 0x81,
+	0x5e, 0x6b, 0x84, 0xf6, 0xc0, 0x2d, 0xe3, 0x66, 0x4c, 0xa5, 0x15, 0x8b, 0xe2, 0xdc, 0x6a, 0x39,
+	0x19, 0xc3, 0x3d, 0x51, 0x4c, 0x87, 0x12, 0xde, 0x75, 0x66, 0x76, 0xf4, 0x39, 0xf4, 0xca, 0xcb,
+	0x56, 0x4a, 0xe3, 0xb7, 0x48, 0x0f, 0x64, 0x94, 0x4e, 0x77, 0x34, 0x00, 0xa7, 0x50, 0xc7, 0xb9,
+	0x62, 0x18, 0xdc, 0x46, 0xe7, 0xd5, 0x7c, 0x7b, 0x6b, 0xf3, 0x3d, 0x86, 0x6e, 0xc9, 0x39, 0x66,
+	0xb8, 0x26, 0xd8, 0x02, 0x03, 0xc3, 0x48, 0x2f, 0x47, 0x3f, 0x2a, 0x70, 0x94, 0xe6, 0xbe, 0x47,
+	0x71, 0x13, 0x8d, 0x91, 0x9c, 0x41, 0x3d, 0x7f, 0x81, 0xc4, 0xc9, 0xa6, 0xf8, 0xf3, 0xf3, 0xe1,
+	0x76, 0x4b, 0x22, 0x46, 0xd9, 0x3b, 0xe4, 0x33, 0xb4, 0x4b, 0xdc, 0x48, 0x68, 0x56, 0xb3, 0xfd,
+	0xf5, 0xb8, 0x0f, 0x76, 0xe6, 0xe4, 0x27, 0x9c, 0x43, 0xa3, 0xf8, 0x66, 0xc9, 0xc9, 0x4a, 0xae,
+	0x8d, 0x0f, 0x85, 0xdb, 0x2b, 0x0f, 0xe6, 0xcd, 0x3c, 0x20, 0x9b, 0x46, 0x21, 0xa7, 0x59, 0xd5,
+	0xd6, 0x07, 0xe2, 0xd2, 0x5d, 0x29, 0x59, 0xfb, 0x81, 0x45, 0xc6, 0xd0, 0x29, 0x33, 0x0d, 0x59,
+	0x91, 0xdd, 0xee, 0x44, 0xf7, 0xe1, 0xee, 0xa4, 0x9c, 0xc5, 0x47, 0x68, 0x6d, 0xdc, 0x3c, 0xe9,
+	0x97, 0x14, 0xaf, 0x99, 0xcf, 0x3d, 0xdd, 0x91, 0x91, 0xf5, 0xbe, 0xac, 0x26, 0x3f, 0x92, 0x27,
+	0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x29, 0x20, 0x7c, 0x92, 0x6e, 0x06, 0x00, 0x00,
 }
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 567dcce62..bf5312a38 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -331,12 +331,12 @@
 			"versionExact": "v1.2.2"
 		},
 		{
-			"checksumSHA1": "sgtWlz2r6XUcjr+eXvBrb9JqgVs=",
+			"checksumSHA1": "C1VkHf9tBfLl56Vy8GS6Fk6AWcc=",
 			"path": "gitlab.com/gitlab-org/gitaly-proto/go/gitalypb",
-			"revision": "43fb53d30d4eba169e663f708544c3b813eb0c9a",
-			"revisionTime": "2018-10-22T12:10:33Z",
-			"version": "v0.121.0",
-			"versionExact": "v0.121.0"
+			"revision": "c8b4ff89954ef4edcdad214dc696f487d4243978",
+			"revisionTime": "2018-11-05T14:00:44Z",
+			"version": "v0.123.0",
+			"versionExact": "v0.123.0"
 		},
 		{
 			"checksumSHA1": "BGm8lKZmvJbf/YOJLeL1rw2WVjA=",