Implement branch operations RPCs

Closes #498

21 files changed, 1135 insertions, 151 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1975a512e..7cf30bbef 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,8 @@ UNRELEASED
 
 - Terminate commands when their context cancels
   https://gitlab.com/gitlab-org/gitaly/merge_requests/318
+- Implement {Create,Delete}Branch RPCs
+  https://gitlab.com/gitlab-org/gitaly/merge_requests/311
 
 v0.35.0
 
diff --git a/internal/rubyserver/rubyserver.go b/internal/rubyserver/rubyserver.go
index 765ddb67a..a2b02c088 100644
--- a/internal/rubyserver/rubyserver.go
+++ b/internal/rubyserver/rubyserver.go
@@ -111,6 +111,14 @@ func DiffServiceClient(ctx context.Context) (pb.DiffServiceClient, error) {
 	return pb.NewDiffServiceClient(conn), err
 }
 
+// RefServiceClient returns a RefServiceClient instance that is
+// configured to connect to the running Ruby server. This assumes Start()
+// has been called already.
+func RefServiceClient(ctx context.Context) (pb.RefServiceClient, error) {
+	conn, err := newConnection(ctx)
+	return pb.NewRefServiceClient(conn), err
+}
+
 func newConnection(ctx context.Context) (*grpc.ClientConn, error) {
 	dialCtx, cancel := context.WithTimeout(ctx, ConnectTimeout)
 	defer cancel()
diff --git a/internal/service/ref/branches.go b/internal/service/ref/branches.go
new file mode 100644
index 000000000..06724df86
--- /dev/null
+++ b/internal/service/ref/branches.go
@@ -0,0 +1,41 @@
+package ref
+
+import (
+	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
+
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+
+	"golang.org/x/net/context"
+)
+
+func (s *server) CreateBranch(ctx context.Context, req *pb.CreateBranchRequest) (*pb.CreateBranchResponse, error) {
+	client, err := rubyserver.RefServiceClient(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	clientCtx, err := rubyserver.SetHeaders(ctx, req.GetRepository())
+	if err != nil {
+		return nil, err
+	}
+
+	return client.CreateBranch(clientCtx, req)
+}
+
+func (s *server) DeleteBranch(ctx context.Context, req *pb.DeleteBranchRequest) (*pb.DeleteBranchResponse, error) {
+	client, err := rubyserver.RefServiceClient(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	clientCtx, err := rubyserver.SetHeaders(ctx, req.GetRepository())
+	if err != nil {
+		return nil, err
+	}
+
+	return client.DeleteBranch(clientCtx, req)
+}
+
+func (s *server) FindBranch(ctx context.Context, req *pb.FindBranchRequest) (*pb.FindBranchResponse, error) {
+	return nil, nil
+}
diff --git a/internal/service/ref/branches_test.go b/internal/service/ref/branches_test.go
new file mode 100644
index 000000000..1b6c21360
--- /dev/null
+++ b/internal/service/ref/branches_test.go
@@ -0,0 +1,210 @@
+package ref
+
+import (
+	"os/exec"
+	"testing"
+
+	"gitlab.com/gitlab-org/gitaly/internal/git/log"
+	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
+
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+
+	"github.com/stretchr/testify/require"
+	"golang.org/x/net/context"
+	"google.golang.org/grpc/codes"
+)
+
+func TestSuccessfulCreateBranchRequest(t *testing.T) {
+	server := runRefServiceServer(t)
+	defer server.Stop()
+
+	client, conn := newRefClient(t)
+	defer conn.Close()
+
+	headCommit, err := log.GetCommit(context.Background(), testRepo, "HEAD", "")
+	require.NoError(t, err)
+
+	startPoint := "c7fbe50c7c7419d9701eebe64b1fdacc3df5b9dd"
+	startPointCommit, err := log.GetCommit(context.Background(), testRepo, startPoint, "")
+	require.NoError(t, err)
+
+	testCases := []struct {
+		desc           string
+		startPoint     string
+		expectedBranch *pb.Branch
+	}{
+		{
+			desc:       "empty start point",
+			startPoint: "",
+			expectedBranch: &pb.Branch{
+				Name:         []byte("to-be-created-soon-1"),
+				TargetCommit: headCommit,
+			},
+		},
+		{
+			desc:       "present start point",
+			startPoint: startPoint,
+			expectedBranch: &pb.Branch{
+				Name:         []byte("to-be-created-soon-2"),
+				TargetCommit: startPointCommit,
+			},
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.desc, func(t *testing.T) {
+			branchName := testCase.expectedBranch.Name
+			request := &pb.CreateBranchRequest{
+				Repository: testRepo,
+				Name:       branchName,
+				StartPoint: []byte(testCase.startPoint),
+			}
+
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+
+			response, err := client.CreateBranch(ctx, request)
+			defer exec.Command("git", "-C", testRepoPath, "branch", "-D", string(branchName)).Run()
+
+			require.NoError(t, err)
+			require.Equal(t, pb.CreateBranchResponse_OK, response.Status, "mismatched status")
+			require.Equal(t, testCase.expectedBranch, response.Branch, "mismatched branches")
+		})
+	}
+}
+
+func TestFailedCreateBranchRequest(t *testing.T) {
+	server := runRefServiceServer(t)
+	defer server.Stop()
+
+	client, conn := newRefClient(t)
+	defer conn.Close()
+
+	testCases := []struct {
+		desc       string
+		branchName string
+		startPoint string
+		status     pb.CreateBranchResponse_Status
+	}{
+		{
+			desc:       "branch exists",
+			branchName: "master",
+			status:     pb.CreateBranchResponse_ERR_EXISTS,
+		},
+		{
+			desc:       "empty branch name",
+			branchName: "",
+			status:     pb.CreateBranchResponse_ERR_INVALID,
+		},
+		{
+			desc:       "invalid start point",
+			branchName: "shiny-new-branch",
+			startPoint: "i-do-not-exist",
+			status:     pb.CreateBranchResponse_ERR_INVALID_START_POINT,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.desc, func(t *testing.T) {
+			request := &pb.CreateBranchRequest{
+				Repository: testRepo,
+				Name:       []byte(testCase.branchName),
+				StartPoint: []byte(testCase.startPoint),
+			}
+
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+
+			response, err := client.CreateBranch(ctx, request)
+
+			require.NoError(t, err)
+			require.Equal(t, testCase.status, response.Status, "mismatched status")
+		})
+	}
+}
+
+func TestSuccessfulDeleteBranchRequest(t *testing.T) {
+	server := runRefServiceServer(t)
+	defer server.Stop()
+
+	client, conn := newRefClient(t)
+	defer conn.Close()
+
+	branchNameInput := "to-be-deleted-soon"
+
+	defer exec.Command("git", "-C", testRepoPath, "branch", "-D", branchNameInput).Run()
+
+	testCases := []struct {
+		desc       string
+		branchName string
+	}{
+		{
+			desc:       "regular branch name",
+			branchName: branchNameInput,
+		},
+		{
+			desc:       "absolute reference path",
+			branchName: "refs/heads/" + branchNameInput,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.desc, func(t *testing.T) {
+			testhelper.MustRunCommand(t, nil, "git", "-C", testRepoPath, "branch", branchNameInput)
+
+			request := &pb.DeleteBranchRequest{
+				Repository: testRepo,
+				Name:       []byte(testCase.branchName),
+			}
+
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+
+			_, err := client.DeleteBranch(ctx, request)
+			require.NoError(t, err)
+
+			branches := testhelper.MustRunCommand(t, nil, "git", "-C", testRepoPath, "branch")
+			require.NotContains(t, branches, branchNameInput, "branch name exists in branches list")
+		})
+	}
+}
+
+func TestFailedDeleteBranchRequest(t *testing.T) {
+	server := runRefServiceServer(t)
+	defer server.Stop()
+
+	client, conn := newRefClient(t)
+	defer conn.Close()
+
+	testCases := []struct {
+		desc       string
+		branchName string
+		code       codes.Code
+	}{
+		{
+			desc:       "branch does not exist",
+			branchName: "this-branch-does-not-exist",
+			code:       codes.Internal,
+		},
+		{
+			desc:       "empty branch name",
+			branchName: "",
+			code:       codes.InvalidArgument,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.desc, func(t *testing.T) {
+			request := &pb.DeleteBranchRequest{
+				Repository: testRepo,
+				Name:       []byte(testCase.branchName),
+			}
+
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+
+			_, err := client.DeleteBranch(ctx, request)
+			testhelper.AssertGrpcError(t, err, testCase.code, "")
+		})
+	}
+}
diff --git a/internal/service/ref/testhelper_test.go b/internal/service/ref/testhelper_test.go
index 9aacb4dc7..75a742848 100644
--- a/internal/service/ref/testhelper_test.go
+++ b/internal/service/ref/testhelper_test.go
@@ -14,6 +14,7 @@ import (
 	pb "gitlab.com/gitlab-org/gitaly-proto/go"
 	"gitlab.com/gitlab-org/gitaly/internal/helper"
 	"gitlab.com/gitlab-org/gitaly/internal/helper/lines"
+	"gitlab.com/gitlab-org/gitaly/internal/rubyserver"
 	"gitlab.com/gitlab-org/gitaly/internal/service/renameadapter"
 	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
 	"google.golang.org/grpc"
@@ -79,6 +80,13 @@ func TestMain(m *testing.M) {
 		log.Fatal(err)
 	}
 
+	testhelper.ConfigureRuby()
+	ruby, err := rubyserver.Start()
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer ruby.Stop()
+
 	// Use 100 bytes as the maximum message size to test that fragmenting the
 	// ref list works correctly
 	lines.MaxMsgSize = 100
diff --git a/ruby/Gemfile b/ruby/Gemfile
index a12e23a57..c13a9707a 100644
--- a/ruby/Gemfile
+++ b/ruby/Gemfile
@@ -1,5 +1,5 @@
 source 'https://rubygems.org'
 
 gem 'github-linguist', '~> 4.7.0', require: 'linguist'
-gem 'gitaly-proto', '~> 0.31.0', require: 'gitaly'
+gem 'gitaly-proto', '~> 0.32.0', require: 'gitaly'
 gem 'activesupport'
diff --git a/ruby/Gemfile.lock b/ruby/Gemfile.lock
index 9d2f03b53..78292f8a4 100644
--- a/ruby/Gemfile.lock
+++ b/ruby/Gemfile.lock
@@ -13,7 +13,7 @@ GEM
     escape_utils (1.1.1)
     faraday (0.12.2)
       multipart-post (>= 1.2, < 3)
-    gitaly-proto (0.31.0)
+    gitaly-proto (0.32.0)
       google-protobuf (~> 3.1)
       grpc (~> 1.0)
     github-linguist (4.7.6)
@@ -63,7 +63,7 @@ PLATFORMS
 
 DEPENDENCIES
   activesupport
-  gitaly-proto (~> 0.31.0)
+  gitaly-proto (~> 0.32.0)
   github-linguist (~> 4.7.0)
 
 BUNDLED WITH
diff --git a/ruby/lib/gitaly_server.rb b/ruby/lib/gitaly_server.rb
index 87637c971..630535c1c 100644
--- a/ruby/lib/gitaly_server.rb
+++ b/ruby/lib/gitaly_server.rb
@@ -2,8 +2,10 @@ require 'gitaly'
 
 require_relative 'gitlab/git.rb'
 
+require_relative 'gitaly_server/utils.rb'
 require_relative 'gitaly_server/commit_service.rb'
 require_relative 'gitaly_server/diff_service.rb'
+require_relative 'gitaly_server/ref_service.rb'
 
 module GitalyServer
   REPO_PATH_HEADER = 'gitaly-repo-path'.freeze
@@ -15,5 +17,6 @@ module GitalyServer
   def self.register_handlers(server)
     server.handle(CommitService.new)
     server.handle(DiffService.new)
+    server.handle(RefService.new)
   end
 end
diff --git a/ruby/lib/gitaly_server/commit_service.rb b/ruby/lib/gitaly_server/commit_service.rb
index 276590cc4..26dd9a577 100644
--- a/ruby/lib/gitaly_server/commit_service.rb
+++ b/ruby/lib/gitaly_server/commit_service.rb
@@ -1,5 +1,7 @@
 module GitalyServer
   class CommitService < Gitaly::CommitService::Service
+    include Utils
+
     def commit_languages(request, _call)
       repo = Gitlab::Git::Repository.from_call(_call)
       revision = request.revision unless request.revision.empty?
@@ -56,28 +58,5 @@ module GitalyServer
         end
       end
     end
-
-    def gitaly_commit_from_rugged(rugged_commit)
-      Gitaly::GitCommit.new(
-        id: rugged_commit.oid,
-        subject: rugged_commit.message.split("\n", 2)[0].chomp,
-        body: rugged_commit.message,
-        parent_ids: rugged_commit.parent_ids,
-        author: gitaly_commit_author_from_rugged(rugged_commit.author),
-        committer: gitaly_commit_author_from_rugged(rugged_commit.committer),
-      )
-    end
-
-    def gitaly_commit_author_from_rugged(rugged_author)
-      Gitaly::CommitAuthor.new(
-        name: bytes!(rugged_author[:name]),
-        email: bytes!(rugged_author[:email]),
-        date: Google::Protobuf::Timestamp.new(seconds: rugged_author[:time].to_i)
-      )
-    end
-
-    def bytes!(string)
-      string.force_encoding('ASCII-8BIT')
-    end
   end
 end
diff --git a/ruby/lib/gitaly_server/ref_service.rb b/ruby/lib/gitaly_server/ref_service.rb
new file mode 100644
index 000000000..9d0cca04e
--- /dev/null
+++ b/ruby/lib/gitaly_server/ref_service.rb
@@ -0,0 +1,45 @@
+module GitalyServer
+  class RefService < Gitaly::RefService::Service
+    include Utils
+
+    def create_branch(request, _call)
+      start_point = request.start_point
+      start_point = 'HEAD' if start_point.empty?
+      branch_name = request.name
+
+      repo = Gitlab::Git::Repository.from_call(_call)
+      rugged_ref = repo.rugged.branches.create(branch_name, start_point)
+
+      Gitaly::CreateBranchResponse.new(
+        status: :OK,
+        branch: Gitaly::Branch.new(
+          name: bytes!(rugged_ref.name),
+          target_commit: gitaly_commit_from_rugged(rugged_ref.target),
+        ),
+      )
+    rescue Rugged::ReferenceError => e
+      status = case e.to_s
+               when /'refs\/heads\/#{branch_name}' is not valid/
+                 :ERR_INVALID
+               when /a reference with that name already exists/
+                 :ERR_EXISTS
+               else
+                 :ERR_INVALID_START_POINT
+               end
+
+      Gitaly::CreateBranchResponse.new(status: status)
+    end
+
+    def delete_branch(request, _call)
+      branch_name = request.name
+      raise GRPC::InvalidArgument.new("empty Name") if branch_name.empty?
+
+      repo = Gitlab::Git::Repository.from_call(_call)
+      repo.delete_branch(branch_name)
+
+      Gitaly::DeleteBranchResponse.new
+    rescue Rugged::ReferenceError => e
+      raise GRPC::Internal.new(e.to_s)
+    end
+  end
+end
diff --git a/ruby/lib/gitaly_server/utils.rb b/ruby/lib/gitaly_server/utils.rb
new file mode 100644
index 000000000..ffc08107c
--- /dev/null
+++ b/ruby/lib/gitaly_server/utils.rb
@@ -0,0 +1,26 @@
+module GitalyServer
+  module Utils
+    def gitaly_commit_from_rugged(rugged_commit)
+      Gitaly::GitCommit.new(
+        id: rugged_commit.oid,
+        subject: rugged_commit.message.split("\n", 2)[0].chomp,
+        body: rugged_commit.message,
+        parent_ids: rugged_commit.parent_ids,
+        author: gitaly_commit_author_from_rugged(rugged_commit.author),
+        committer: gitaly_commit_author_from_rugged(rugged_commit.committer),
+      )
+    end
+
+    def gitaly_commit_author_from_rugged(rugged_author)
+      Gitaly::CommitAuthor.new(
+        name: bytes!(rugged_author[:name]),
+        email: bytes!(rugged_author[:email]),
+        date: Google::Protobuf::Timestamp.new(seconds: rugged_author[:time].to_i)
+      )
+    end
+
+    def bytes!(string)
+      string.force_encoding('ASCII-8BIT')
+    end
+  end
+end
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION
index 26bea73e8..9eb2aa3f1 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION
@@ -1 +1 @@
-0.31.0
+0.32.0
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/blob.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/blob.pb.go
index a8284cde2..bfa8c3674 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/blob.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/blob.pb.go
@@ -9,6 +9,7 @@ It is generated from these files:
 	commit.proto
 	deprecated-services.proto
 	diff.proto
+	namespace.proto
 	notifications.proto
 	ref.proto
 	repository-service.proto
@@ -55,6 +56,14 @@ It has these top-level messages:
 	CommitDeltaResponse
 	CommitPatchRequest
 	CommitPatchResponse
+	AddNamespaceRequest
+	RemoveNamespaceRequest
+	RenameNamespaceRequest
+	NamespaceExistsRequest
+	NamespaceExistsResponse
+	AddNamespaceResponse
+	RemoveNamespaceResponse
+	RenameNamespaceResponse
 	PostReceiveRequest
 	PostReceiveResponse
 	FindDefaultBranchNameRequest
@@ -75,6 +84,12 @@ It has these top-level messages:
 	FindAllTagsResponse
 	RefExistsRequest
 	RefExistsResponse
+	CreateBranchRequest
+	CreateBranchResponse
+	DeleteBranchRequest
+	DeleteBranchResponse
+	FindBranchRequest
+	FindBranchResponse
 	RepositoryExistsRequest
 	RepositoryExistsResponse
 	RepackIncrementalRequest
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/namespace.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/namespace.pb.go
new file mode 100644
index 000000000..e738cc870
--- /dev/null
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/namespace.pb.go
@@ -0,0 +1,369 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: namespace.proto
+
+package gitaly
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type AddNamespaceRequest struct {
+	StorageName string `protobuf:"bytes,1,opt,name=storage_name,json=storageName" json:"storage_name,omitempty"`
+	Name        string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
+}
+
+func (m *AddNamespaceRequest) Reset()                    { *m = AddNamespaceRequest{} }
+func (m *AddNamespaceRequest) String() string            { return proto.CompactTextString(m) }
+func (*AddNamespaceRequest) ProtoMessage()               {}
+func (*AddNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
+
+func (m *AddNamespaceRequest) GetStorageName() string {
+	if m != nil {
+		return m.StorageName
+	}
+	return ""
+}
+
+func (m *AddNamespaceRequest) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+type RemoveNamespaceRequest struct {
+	StorageName string `protobuf:"bytes,1,opt,name=storage_name,json=storageName" json:"storage_name,omitempty"`
+	Name        string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
+}
+
+func (m *RemoveNamespaceRequest) Reset()                    { *m = RemoveNamespaceRequest{} }
+func (m *RemoveNamespaceRequest) String() string            { return proto.CompactTextString(m) }
+func (*RemoveNamespaceRequest) ProtoMessage()               {}
+func (*RemoveNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} }
+
+func (m *RemoveNamespaceRequest) GetStorageName() string {
+	if m != nil {
+		return m.StorageName
+	}
+	return ""
+}
+
+func (m *RemoveNamespaceRequest) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+type RenameNamespaceRequest struct {
+	StorageName string `protobuf:"bytes,1,opt,name=storage_name,json=storageName" json:"storage_name,omitempty"`
+	From        string `protobuf:"bytes,2,opt,name=from" json:"from,omitempty"`
+	To          string `protobuf:"bytes,3,opt,name=to" json:"to,omitempty"`
+}
+
+func (m *RenameNamespaceRequest) Reset()                    { *m = RenameNamespaceRequest{} }
+func (m *RenameNamespaceRequest) String() string            { return proto.CompactTextString(m) }
+func (*RenameNamespaceRequest) ProtoMessage()               {}
+func (*RenameNamespaceRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{2} }
+
+func (m *RenameNamespaceRequest) GetStorageName() string {
+	if m != nil {
+		return m.StorageName
+	}
+	return ""
+}
+
+func (m *RenameNamespaceRequest) GetFrom() string {
+	if m != nil {
+		return m.From
+	}
+	return ""
+}
+
+func (m *RenameNamespaceRequest) GetTo() string {
+	if m != nil {
+		return m.To
+	}
+	return ""
+}
+
+type NamespaceExistsRequest struct {
+	StorageName string `protobuf:"bytes,1,opt,name=storage_name,json=storageName" json:"storage_name,omitempty"`
+	Name        string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
+}
+
+func (m *NamespaceExistsRequest) Reset()                    { *m = NamespaceExistsRequest{} }
+func (m *NamespaceExistsRequest) String() string            { return proto.CompactTextString(m) }
+func (*NamespaceExistsRequest) ProtoMessage()               {}
+func (*NamespaceExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{3} }
+
+func (m *NamespaceExistsRequest) GetStorageName() string {
+	if m != nil {
+		return m.StorageName
+	}
+	return ""
+}
+
+func (m *NamespaceExistsRequest) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+type NamespaceExistsResponse struct {
+	Exists bool `protobuf:"varint,1,opt,name=exists" json:"exists,omitempty"`
+}
+
+func (m *NamespaceExistsResponse) Reset()                    { *m = NamespaceExistsResponse{} }
+func (m *NamespaceExistsResponse) String() string            { return proto.CompactTextString(m) }
+func (*NamespaceExistsResponse) ProtoMessage()               {}
+func (*NamespaceExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{4} }
+
+func (m *NamespaceExistsResponse) GetExists() bool {
+	if m != nil {
+		return m.Exists
+	}
+	return false
+}
+
+type AddNamespaceResponse struct {
+}
+
+func (m *AddNamespaceResponse) Reset()                    { *m = AddNamespaceResponse{} }
+func (m *AddNamespaceResponse) String() string            { return proto.CompactTextString(m) }
+func (*AddNamespaceResponse) ProtoMessage()               {}
+func (*AddNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{5} }
+
+type RemoveNamespaceResponse struct {
+}
+
+func (m *RemoveNamespaceResponse) Reset()                    { *m = RemoveNamespaceResponse{} }
+func (m *RemoveNamespaceResponse) String() string            { return proto.CompactTextString(m) }
+func (*RemoveNamespaceResponse) ProtoMessage()               {}
+func (*RemoveNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{6} }
+
+type RenameNamespaceResponse struct {
+}
+
+func (m *RenameNamespaceResponse) Reset()                    { *m = RenameNamespaceResponse{} }
+func (m *RenameNamespaceResponse) String() string            { return proto.CompactTextString(m) }
+func (*RenameNamespaceResponse) ProtoMessage()               {}
+func (*RenameNamespaceResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{7} }
+
+func init() {
+	proto.RegisterType((*AddNamespaceRequest)(nil), "gitaly.AddNamespaceRequest")
+	proto.RegisterType((*RemoveNamespaceRequest)(nil), "gitaly.RemoveNamespaceRequest")
+	proto.RegisterType((*RenameNamespaceRequest)(nil), "gitaly.RenameNamespaceRequest")
+	proto.RegisterType((*NamespaceExistsRequest)(nil), "gitaly.NamespaceExistsRequest")
+	proto.RegisterType((*NamespaceExistsResponse)(nil), "gitaly.NamespaceExistsResponse")
+	proto.RegisterType((*AddNamespaceResponse)(nil), "gitaly.AddNamespaceResponse")
+	proto.RegisterType((*RemoveNamespaceResponse)(nil), "gitaly.RemoveNamespaceResponse")
+	proto.RegisterType((*RenameNamespaceResponse)(nil), "gitaly.RenameNamespaceResponse")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for NamespaceService service
+
+type NamespaceServiceClient interface {
+	AddNamespace(ctx context.Context, in *AddNamespaceRequest, opts ...grpc.CallOption) (*AddNamespaceResponse, error)
+	RemoveNamespace(ctx context.Context, in *RemoveNamespaceRequest, opts ...grpc.CallOption) (*RemoveNamespaceResponse, error)
+	RenameNamespace(ctx context.Context, in *RenameNamespaceRequest, opts ...grpc.CallOption) (*RenameNamespaceResponse, error)
+	NamespaceExists(ctx context.Context, in *NamespaceExistsRequest, opts ...grpc.CallOption) (*NamespaceExistsResponse, error)
+}
+
+type namespaceServiceClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewNamespaceServiceClient(cc *grpc.ClientConn) NamespaceServiceClient {
+	return &namespaceServiceClient{cc}
+}
+
+func (c *namespaceServiceClient) AddNamespace(ctx context.Context, in *AddNamespaceRequest, opts ...grpc.CallOption) (*AddNamespaceResponse, error) {
+	out := new(AddNamespaceResponse)
+	err := grpc.Invoke(ctx, "/gitaly.NamespaceService/AddNamespace", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *namespaceServiceClient) RemoveNamespace(ctx context.Context, in *RemoveNamespaceRequest, opts ...grpc.CallOption) (*RemoveNamespaceResponse, error) {
+	out := new(RemoveNamespaceResponse)
+	err := grpc.Invoke(ctx, "/gitaly.NamespaceService/RemoveNamespace", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *namespaceServiceClient) RenameNamespace(ctx context.Context, in *RenameNamespaceRequest, opts ...grpc.CallOption) (*RenameNamespaceResponse, error) {
+	out := new(RenameNamespaceResponse)
+	err := grpc.Invoke(ctx, "/gitaly.NamespaceService/RenameNamespace", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *namespaceServiceClient) NamespaceExists(ctx context.Context, in *NamespaceExistsRequest, opts ...grpc.CallOption) (*NamespaceExistsResponse, error) {
+	out := new(NamespaceExistsResponse)
+	err := grpc.Invoke(ctx, "/gitaly.NamespaceService/NamespaceExists", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for NamespaceService service
+
+type NamespaceServiceServer interface {
+	AddNamespace(context.Context, *AddNamespaceRequest) (*AddNamespaceResponse, error)
+	RemoveNamespace(context.Context, *RemoveNamespaceRequest) (*RemoveNamespaceResponse, error)
+	RenameNamespace(context.Context, *RenameNamespaceRequest) (*RenameNamespaceResponse, error)
+	NamespaceExists(context.Context, *NamespaceExistsRequest) (*NamespaceExistsResponse, error)
+}
+
+func RegisterNamespaceServiceServer(s *grpc.Server, srv NamespaceServiceServer) {
+	s.RegisterService(&_NamespaceService_serviceDesc, srv)
+}
+
+func _NamespaceService_AddNamespace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AddNamespaceRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NamespaceServiceServer).AddNamespace(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.NamespaceService/AddNamespace",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NamespaceServiceServer).AddNamespace(ctx, req.(*AddNamespaceRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _NamespaceService_RemoveNamespace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RemoveNamespaceRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NamespaceServiceServer).RemoveNamespace(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.NamespaceService/RemoveNamespace",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NamespaceServiceServer).RemoveNamespace(ctx, req.(*RemoveNamespaceRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _NamespaceService_RenameNamespace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RenameNamespaceRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NamespaceServiceServer).RenameNamespace(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.NamespaceService/RenameNamespace",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NamespaceServiceServer).RenameNamespace(ctx, req.(*RenameNamespaceRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _NamespaceService_NamespaceExists_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(NamespaceExistsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NamespaceServiceServer).NamespaceExists(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.NamespaceService/NamespaceExists",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NamespaceServiceServer).NamespaceExists(ctx, req.(*NamespaceExistsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _NamespaceService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.NamespaceService",
+	HandlerType: (*NamespaceServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "AddNamespace",
+			Handler:    _NamespaceService_AddNamespace_Handler,
+		},
+		{
+			MethodName: "RemoveNamespace",
+			Handler:    _NamespaceService_RemoveNamespace_Handler,
+		},
+		{
+			MethodName: "RenameNamespace",
+			Handler:    _NamespaceService_RenameNamespace_Handler,
+		},
+		{
+			MethodName: "NamespaceExists",
+			Handler:    _NamespaceService_NamespaceExists_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "namespace.proto",
+}
+
+func init() { proto.RegisterFile("namespace.proto", fileDescriptor4) }
+
+var fileDescriptor4 = []byte{
+	// 291 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xcf, 0x4b, 0xcc, 0x4d,
+	0x2d, 0x2e, 0x48, 0x4c, 0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x4b, 0xcf, 0x2c,
+	0x49, 0xcc, 0xa9, 0x54, 0xf2, 0xe1, 0x12, 0x76, 0x4c, 0x49, 0xf1, 0x83, 0xc9, 0x06, 0xa5, 0x16,
+	0x96, 0xa6, 0x16, 0x97, 0x08, 0x29, 0x72, 0xf1, 0x14, 0x97, 0xe4, 0x17, 0x25, 0xa6, 0xa7, 0xc6,
+	0x83, 0x74, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x06, 0x71, 0x43, 0xc5, 0x40, 0xca, 0x85, 0x84,
+	0xb8, 0x58, 0xc0, 0x52, 0x4c, 0x60, 0x29, 0x30, 0x5b, 0xc9, 0x9f, 0x4b, 0x2c, 0x28, 0x35, 0x37,
+	0xbf, 0x2c, 0x95, 0x5a, 0x06, 0xc6, 0x83, 0x0c, 0x04, 0xb1, 0xc8, 0x34, 0x30, 0xad, 0x28, 0x3f,
+	0x17, 0x66, 0x20, 0x88, 0x2d, 0xc4, 0xc7, 0xc5, 0x54, 0x92, 0x2f, 0xc1, 0x0c, 0x16, 0x61, 0x2a,
+	0xc9, 0x07, 0xb9, 0x18, 0x6e, 0xb4, 0x6b, 0x45, 0x66, 0x71, 0x49, 0x31, 0x85, 0x2e, 0x36, 0xe4,
+	0x12, 0xc7, 0x30, 0xb0, 0xb8, 0x20, 0x3f, 0xaf, 0x38, 0x55, 0x48, 0x8c, 0x8b, 0x2d, 0x15, 0x2c,
+	0x02, 0x36, 0x8b, 0x23, 0x08, 0xca, 0x53, 0x12, 0xe3, 0x12, 0x41, 0x8d, 0x03, 0x88, 0x7a, 0x25,
+	0x49, 0x2e, 0x71, 0x8c, 0xd0, 0x44, 0x96, 0x42, 0x0b, 0x17, 0x88, 0x94, 0xd1, 0x43, 0x26, 0x2e,
+	0x01, 0xb8, 0x68, 0x70, 0x6a, 0x51, 0x59, 0x66, 0x72, 0xaa, 0x90, 0x37, 0x17, 0x0f, 0xb2, 0x15,
+	0x42, 0xd2, 0x7a, 0x90, 0xf8, 0xd7, 0xc3, 0x12, 0xf9, 0x52, 0x32, 0xd8, 0x25, 0xa1, 0x56, 0x33,
+	0x08, 0x85, 0x70, 0xf1, 0xa3, 0xb9, 0x4b, 0x48, 0x0e, 0xa6, 0x05, 0x7b, 0xf4, 0x4b, 0xc9, 0xe3,
+	0x94, 0x47, 0x35, 0x15, 0xc5, 0x4b, 0xc8, 0xa6, 0x62, 0x4b, 0x03, 0xc8, 0xa6, 0x62, 0x0d, 0x0b,
+	0x88, 0xa9, 0x68, 0xd1, 0x81, 0x30, 0x15, 0x7b, 0xc4, 0x23, 0x4c, 0xc5, 0x11, 0x8f, 0x4a, 0x0c,
+	0x49, 0x6c, 0xe0, 0x4c, 0x64, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0xe3, 0x36, 0x4b, 0x73, 0x57,
+	0x03, 0x00, 0x00,
+}
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/notifications.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/notifications.pb.go
index 5d2e3f50f..295eb439b 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/notifications.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/notifications.pb.go
@@ -24,7 +24,7 @@ type PostReceiveRequest struct {
 func (m *PostReceiveRequest) Reset()                    { *m = PostReceiveRequest{} }
 func (m *PostReceiveRequest) String() string            { return proto.CompactTextString(m) }
 func (*PostReceiveRequest) ProtoMessage()               {}
-func (*PostReceiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{0} }
+func (*PostReceiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} }
 
 func (m *PostReceiveRequest) GetRepository() *Repository {
 	if m != nil {
@@ -39,7 +39,7 @@ type PostReceiveResponse struct {
 func (m *PostReceiveResponse) Reset()                    { *m = PostReceiveResponse{} }
 func (m *PostReceiveResponse) String() string            { return proto.CompactTextString(m) }
 func (*PostReceiveResponse) ProtoMessage()               {}
-func (*PostReceiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []int{1} }
+func (*PostReceiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1} }
 
 func init() {
 	proto.RegisterType((*PostReceiveRequest)(nil), "gitaly.PostReceiveRequest")
@@ -118,9 +118,9 @@ var _NotificationService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "notifications.proto",
 }
 
-func init() { proto.RegisterFile("notifications.proto", fileDescriptor4) }
+func init() { proto.RegisterFile("notifications.proto", fileDescriptor5) }
 
-var fileDescriptor4 = []byte{
+var fileDescriptor5 = []byte{
 	// 170 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xce, 0xcb, 0x2f, 0xc9,
 	0x4c, 0xcb, 0x4c, 0x4e, 0x2c, 0xc9, 0xcc, 0xcf, 0x2b, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17,
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ref.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ref.pb.go
index 86c3bbb61..5347bb436 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ref.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ref.pb.go
@@ -41,7 +41,36 @@ func (x FindLocalBranchesRequest_SortBy) String() string {
 	return proto.EnumName(FindLocalBranchesRequest_SortBy_name, int32(x))
 }
 func (FindLocalBranchesRequest_SortBy) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor5, []int{8, 0}
+	return fileDescriptor6, []int{8, 0}
+}
+
+type CreateBranchResponse_Status int32
+
+const (
+	CreateBranchResponse_OK                      CreateBranchResponse_Status = 0
+	CreateBranchResponse_ERR_EXISTS              CreateBranchResponse_Status = 1
+	CreateBranchResponse_ERR_INVALID             CreateBranchResponse_Status = 2
+	CreateBranchResponse_ERR_INVALID_START_POINT CreateBranchResponse_Status = 3
+)
+
+var CreateBranchResponse_Status_name = map[int32]string{
+	0: "OK",
+	1: "ERR_EXISTS",
+	2: "ERR_INVALID",
+	3: "ERR_INVALID_START_POINT",
+}
+var CreateBranchResponse_Status_value = map[string]int32{
+	"OK":                      0,
+	"ERR_EXISTS":              1,
+	"ERR_INVALID":             2,
+	"ERR_INVALID_START_POINT": 3,
+}
+
+func (x CreateBranchResponse_Status) String() string {
+	return proto.EnumName(CreateBranchResponse_Status_name, int32(x))
+}
+func (CreateBranchResponse_Status) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor6, []int{19, 0}
 }
 
 type FindDefaultBranchNameRequest struct {
@@ -51,7 +80,7 @@ type FindDefaultBranchNameRequest struct {
 func (m *FindDefaultBranchNameRequest) Reset()                    { *m = FindDefaultBranchNameRequest{} }
 func (m *FindDefaultBranchNameRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindDefaultBranchNameRequest) ProtoMessage()               {}
-func (*FindDefaultBranchNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} }
+func (*FindDefaultBranchNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} }
 
 func (m *FindDefaultBranchNameRequest) GetRepository() *Repository {
 	if m != nil {
@@ -67,7 +96,7 @@ type FindDefaultBranchNameResponse struct {
 func (m *FindDefaultBranchNameResponse) Reset()                    { *m = FindDefaultBranchNameResponse{} }
 func (m *FindDefaultBranchNameResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindDefaultBranchNameResponse) ProtoMessage()               {}
-func (*FindDefaultBranchNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1} }
+func (*FindDefaultBranchNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1} }
 
 func (m *FindDefaultBranchNameResponse) GetName() []byte {
 	if m != nil {
@@ -83,7 +112,7 @@ type FindAllBranchNamesRequest struct {
 func (m *FindAllBranchNamesRequest) Reset()                    { *m = FindAllBranchNamesRequest{} }
 func (m *FindAllBranchNamesRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindAllBranchNamesRequest) ProtoMessage()               {}
-func (*FindAllBranchNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{2} }
+func (*FindAllBranchNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{2} }
 
 func (m *FindAllBranchNamesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -99,7 +128,7 @@ type FindAllBranchNamesResponse struct {
 func (m *FindAllBranchNamesResponse) Reset()                    { *m = FindAllBranchNamesResponse{} }
 func (m *FindAllBranchNamesResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindAllBranchNamesResponse) ProtoMessage()               {}
-func (*FindAllBranchNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{3} }
+func (*FindAllBranchNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{3} }
 
 func (m *FindAllBranchNamesResponse) GetNames() [][]byte {
 	if m != nil {
@@ -115,7 +144,7 @@ type FindAllTagNamesRequest struct {
 func (m *FindAllTagNamesRequest) Reset()                    { *m = FindAllTagNamesRequest{} }
 func (m *FindAllTagNamesRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindAllTagNamesRequest) ProtoMessage()               {}
-func (*FindAllTagNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{4} }
+func (*FindAllTagNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{4} }
 
 func (m *FindAllTagNamesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -131,7 +160,7 @@ type FindAllTagNamesResponse struct {
 func (m *FindAllTagNamesResponse) Reset()                    { *m = FindAllTagNamesResponse{} }
 func (m *FindAllTagNamesResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindAllTagNamesResponse) ProtoMessage()               {}
-func (*FindAllTagNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{5} }
+func (*FindAllTagNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{5} }
 
 func (m *FindAllTagNamesResponse) GetNames() [][]byte {
 	if m != nil {
@@ -151,7 +180,7 @@ type FindRefNameRequest struct {
 func (m *FindRefNameRequest) Reset()                    { *m = FindRefNameRequest{} }
 func (m *FindRefNameRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindRefNameRequest) ProtoMessage()               {}
-func (*FindRefNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{6} }
+func (*FindRefNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{6} }
 
 func (m *FindRefNameRequest) GetRepository() *Repository {
 	if m != nil {
@@ -182,7 +211,7 @@ type FindRefNameResponse struct {
 func (m *FindRefNameResponse) Reset()                    { *m = FindRefNameResponse{} }
 func (m *FindRefNameResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindRefNameResponse) ProtoMessage()               {}
-func (*FindRefNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{7} }
+func (*FindRefNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{7} }
 
 func (m *FindRefNameResponse) GetName() []byte {
 	if m != nil {
@@ -199,7 +228,7 @@ type FindLocalBranchesRequest struct {
 func (m *FindLocalBranchesRequest) Reset()                    { *m = FindLocalBranchesRequest{} }
 func (m *FindLocalBranchesRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindLocalBranchesRequest) ProtoMessage()               {}
-func (*FindLocalBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{8} }
+func (*FindLocalBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{8} }
 
 func (m *FindLocalBranchesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -222,7 +251,7 @@ type FindLocalBranchesResponse struct {
 func (m *FindLocalBranchesResponse) Reset()                    { *m = FindLocalBranchesResponse{} }
 func (m *FindLocalBranchesResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindLocalBranchesResponse) ProtoMessage()               {}
-func (*FindLocalBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{9} }
+func (*FindLocalBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{9} }
 
 func (m *FindLocalBranchesResponse) GetBranches() []*FindLocalBranchResponse {
 	if m != nil {
@@ -242,7 +271,7 @@ type FindLocalBranchResponse struct {
 func (m *FindLocalBranchResponse) Reset()                    { *m = FindLocalBranchResponse{} }
 func (m *FindLocalBranchResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindLocalBranchResponse) ProtoMessage()               {}
-func (*FindLocalBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{10} }
+func (*FindLocalBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{10} }
 
 func (m *FindLocalBranchResponse) GetName() []byte {
 	if m != nil {
@@ -288,7 +317,7 @@ type FindLocalBranchCommitAuthor struct {
 func (m *FindLocalBranchCommitAuthor) Reset()                    { *m = FindLocalBranchCommitAuthor{} }
 func (m *FindLocalBranchCommitAuthor) String() string            { return proto.CompactTextString(m) }
 func (*FindLocalBranchCommitAuthor) ProtoMessage()               {}
-func (*FindLocalBranchCommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{11} }
+func (*FindLocalBranchCommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{11} }
 
 func (m *FindLocalBranchCommitAuthor) GetName() []byte {
 	if m != nil {
@@ -318,7 +347,7 @@ type FindAllBranchesRequest struct {
 func (m *FindAllBranchesRequest) Reset()                    { *m = FindAllBranchesRequest{} }
 func (m *FindAllBranchesRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindAllBranchesRequest) ProtoMessage()               {}
-func (*FindAllBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{12} }
+func (*FindAllBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{12} }
 
 func (m *FindAllBranchesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -334,7 +363,7 @@ type FindAllBranchesResponse struct {
 func (m *FindAllBranchesResponse) Reset()                    { *m = FindAllBranchesResponse{} }
 func (m *FindAllBranchesResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindAllBranchesResponse) ProtoMessage()               {}
-func (*FindAllBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{13} }
+func (*FindAllBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{13} }
 
 func (m *FindAllBranchesResponse) GetBranches() []*FindAllBranchesResponse_Branch {
 	if m != nil {
@@ -352,7 +381,7 @@ func (m *FindAllBranchesResponse_Branch) Reset()         { *m = FindAllBranchesR
 func (m *FindAllBranchesResponse_Branch) String() string { return proto.CompactTextString(m) }
 func (*FindAllBranchesResponse_Branch) ProtoMessage()    {}
 func (*FindAllBranchesResponse_Branch) Descriptor() ([]byte, []int) {
-	return fileDescriptor5, []int{13, 0}
+	return fileDescriptor6, []int{13, 0}
 }
 
 func (m *FindAllBranchesResponse_Branch) GetName() []byte {
@@ -376,7 +405,7 @@ type FindAllTagsRequest struct {
 func (m *FindAllTagsRequest) Reset()                    { *m = FindAllTagsRequest{} }
 func (m *FindAllTagsRequest) String() string            { return proto.CompactTextString(m) }
 func (*FindAllTagsRequest) ProtoMessage()               {}
-func (*FindAllTagsRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{14} }
+func (*FindAllTagsRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{14} }
 
 func (m *FindAllTagsRequest) GetRepository() *Repository {
 	if m != nil {
@@ -392,7 +421,7 @@ type FindAllTagsResponse struct {
 func (m *FindAllTagsResponse) Reset()                    { *m = FindAllTagsResponse{} }
 func (m *FindAllTagsResponse) String() string            { return proto.CompactTextString(m) }
 func (*FindAllTagsResponse) ProtoMessage()               {}
-func (*FindAllTagsResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{15} }
+func (*FindAllTagsResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{15} }
 
 func (m *FindAllTagsResponse) GetTags() []*FindAllTagsResponse_Tag {
 	if m != nil {
@@ -411,7 +440,7 @@ type FindAllTagsResponse_Tag struct {
 func (m *FindAllTagsResponse_Tag) Reset()                    { *m = FindAllTagsResponse_Tag{} }
 func (m *FindAllTagsResponse_Tag) String() string            { return proto.CompactTextString(m) }
 func (*FindAllTagsResponse_Tag) ProtoMessage()               {}
-func (*FindAllTagsResponse_Tag) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{15, 0} }
+func (*FindAllTagsResponse_Tag) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{15, 0} }
 
 func (m *FindAllTagsResponse_Tag) GetName() []byte {
 	if m != nil {
@@ -450,7 +479,7 @@ type RefExistsRequest struct {
 func (m *RefExistsRequest) Reset()                    { *m = RefExistsRequest{} }
 func (m *RefExistsRequest) String() string            { return proto.CompactTextString(m) }
 func (*RefExistsRequest) ProtoMessage()               {}
-func (*RefExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{16} }
+func (*RefExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{16} }
 
 func (m *RefExistsRequest) GetRepository() *Repository {
 	if m != nil {
@@ -473,7 +502,7 @@ type RefExistsResponse struct {
 func (m *RefExistsResponse) Reset()                    { *m = RefExistsResponse{} }
 func (m *RefExistsResponse) String() string            { return proto.CompactTextString(m) }
 func (*RefExistsResponse) ProtoMessage()               {}
-func (*RefExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{17} }
+func (*RefExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{17} }
 
 func (m *RefExistsResponse) GetValue() bool {
 	if m != nil {
@@ -482,6 +511,136 @@ func (m *RefExistsResponse) GetValue() bool {
 	return false
 }
 
+type CreateBranchRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	Name       []byte      `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+	StartPoint []byte      `protobuf:"bytes,3,opt,name=start_point,json=startPoint,proto3" json:"start_point,omitempty"`
+}
+
+func (m *CreateBranchRequest) Reset()                    { *m = CreateBranchRequest{} }
+func (m *CreateBranchRequest) String() string            { return proto.CompactTextString(m) }
+func (*CreateBranchRequest) ProtoMessage()               {}
+func (*CreateBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{18} }
+
+func (m *CreateBranchRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *CreateBranchRequest) GetName() []byte {
+	if m != nil {
+		return m.Name
+	}
+	return nil
+}
+
+func (m *CreateBranchRequest) GetStartPoint() []byte {
+	if m != nil {
+		return m.StartPoint
+	}
+	return nil
+}
+
+type CreateBranchResponse struct {
+	Status CreateBranchResponse_Status `protobuf:"varint,1,opt,name=status,enum=gitaly.CreateBranchResponse_Status" json:"status,omitempty"`
+	Branch *Branch                     `protobuf:"bytes,2,opt,name=branch" json:"branch,omitempty"`
+}
+
+func (m *CreateBranchResponse) Reset()                    { *m = CreateBranchResponse{} }
+func (m *CreateBranchResponse) String() string            { return proto.CompactTextString(m) }
+func (*CreateBranchResponse) ProtoMessage()               {}
+func (*CreateBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{19} }
+
+func (m *CreateBranchResponse) GetStatus() CreateBranchResponse_Status {
+	if m != nil {
+		return m.Status
+	}
+	return CreateBranchResponse_OK
+}
+
+func (m *CreateBranchResponse) GetBranch() *Branch {
+	if m != nil {
+		return m.Branch
+	}
+	return nil
+}
+
+type DeleteBranchRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	Name       []byte      `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+}
+
+func (m *DeleteBranchRequest) Reset()                    { *m = DeleteBranchRequest{} }
+func (m *DeleteBranchRequest) String() string            { return proto.CompactTextString(m) }
+func (*DeleteBranchRequest) ProtoMessage()               {}
+func (*DeleteBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{20} }
+
+func (m *DeleteBranchRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *DeleteBranchRequest) GetName() []byte {
+	if m != nil {
+		return m.Name
+	}
+	return nil
+}
+
+// Not clear if we need to do status signaling; we can add fields later.
+type DeleteBranchResponse struct {
+}
+
+func (m *DeleteBranchResponse) Reset()                    { *m = DeleteBranchResponse{} }
+func (m *DeleteBranchResponse) String() string            { return proto.CompactTextString(m) }
+func (*DeleteBranchResponse) ProtoMessage()               {}
+func (*DeleteBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{21} }
+
+type FindBranchRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	// Name can be 'master' but also 'refs/heads/master'
+	Name []byte `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+}
+
+func (m *FindBranchRequest) Reset()                    { *m = FindBranchRequest{} }
+func (m *FindBranchRequest) String() string            { return proto.CompactTextString(m) }
+func (*FindBranchRequest) ProtoMessage()               {}
+func (*FindBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{22} }
+
+func (m *FindBranchRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *FindBranchRequest) GetName() []byte {
+	if m != nil {
+		return m.Name
+	}
+	return nil
+}
+
+type FindBranchResponse struct {
+	Branch *Branch `protobuf:"bytes,1,opt,name=branch" json:"branch,omitempty"`
+}
+
+func (m *FindBranchResponse) Reset()                    { *m = FindBranchResponse{} }
+func (m *FindBranchResponse) String() string            { return proto.CompactTextString(m) }
+func (*FindBranchResponse) ProtoMessage()               {}
+func (*FindBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{23} }
+
+func (m *FindBranchResponse) GetBranch() *Branch {
+	if m != nil {
+		return m.Branch
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*FindDefaultBranchNameRequest)(nil), "gitaly.FindDefaultBranchNameRequest")
 	proto.RegisterType((*FindDefaultBranchNameResponse)(nil), "gitaly.FindDefaultBranchNameResponse")
@@ -503,7 +662,14 @@ func init() {
 	proto.RegisterType((*FindAllTagsResponse_Tag)(nil), "gitaly.FindAllTagsResponse.Tag")
 	proto.RegisterType((*RefExistsRequest)(nil), "gitaly.RefExistsRequest")
 	proto.RegisterType((*RefExistsResponse)(nil), "gitaly.RefExistsResponse")
+	proto.RegisterType((*CreateBranchRequest)(nil), "gitaly.CreateBranchRequest")
+	proto.RegisterType((*CreateBranchResponse)(nil), "gitaly.CreateBranchResponse")
+	proto.RegisterType((*DeleteBranchRequest)(nil), "gitaly.DeleteBranchRequest")
+	proto.RegisterType((*DeleteBranchResponse)(nil), "gitaly.DeleteBranchResponse")
+	proto.RegisterType((*FindBranchRequest)(nil), "gitaly.FindBranchRequest")
+	proto.RegisterType((*FindBranchResponse)(nil), "gitaly.FindBranchResponse")
 	proto.RegisterEnum("gitaly.FindLocalBranchesRequest_SortBy", FindLocalBranchesRequest_SortBy_name, FindLocalBranchesRequest_SortBy_value)
+	proto.RegisterEnum("gitaly.CreateBranchResponse_Status", CreateBranchResponse_Status_name, CreateBranchResponse_Status_value)
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -527,6 +693,9 @@ type RefServiceClient interface {
 	FindAllBranches(ctx context.Context, in *FindAllBranchesRequest, opts ...grpc.CallOption) (RefService_FindAllBranchesClient, error)
 	FindAllTags(ctx context.Context, in *FindAllTagsRequest, opts ...grpc.CallOption) (RefService_FindAllTagsClient, error)
 	RefExists(ctx context.Context, in *RefExistsRequest, opts ...grpc.CallOption) (*RefExistsResponse, error)
+	CreateBranch(ctx context.Context, in *CreateBranchRequest, opts ...grpc.CallOption) (*CreateBranchResponse, error)
+	DeleteBranch(ctx context.Context, in *DeleteBranchRequest, opts ...grpc.CallOption) (*DeleteBranchResponse, error)
+	FindBranch(ctx context.Context, in *FindBranchRequest, opts ...grpc.CallOption) (*FindBranchResponse, error)
 }
 
 type refServiceClient struct {
@@ -724,6 +893,33 @@ func (c *refServiceClient) RefExists(ctx context.Context, in *RefExistsRequest,
 	return out, nil
 }
 
+func (c *refServiceClient) CreateBranch(ctx context.Context, in *CreateBranchRequest, opts ...grpc.CallOption) (*CreateBranchResponse, error) {
+	out := new(CreateBranchResponse)
+	err := grpc.Invoke(ctx, "/gitaly.RefService/CreateBranch", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *refServiceClient) DeleteBranch(ctx context.Context, in *DeleteBranchRequest, opts ...grpc.CallOption) (*DeleteBranchResponse, error) {
+	out := new(DeleteBranchResponse)
+	err := grpc.Invoke(ctx, "/gitaly.RefService/DeleteBranch", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *refServiceClient) FindBranch(ctx context.Context, in *FindBranchRequest, opts ...grpc.CallOption) (*FindBranchResponse, error) {
+	out := new(FindBranchResponse)
+	err := grpc.Invoke(ctx, "/gitaly.RefService/FindBranch", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // Server API for RefService service
 
 type RefServiceServer interface {
@@ -737,6 +933,9 @@ type RefServiceServer interface {
 	FindAllBranches(*FindAllBranchesRequest, RefService_FindAllBranchesServer) error
 	FindAllTags(*FindAllTagsRequest, RefService_FindAllTagsServer) error
 	RefExists(context.Context, *RefExistsRequest) (*RefExistsResponse, error)
+	CreateBranch(context.Context, *CreateBranchRequest) (*CreateBranchResponse, error)
+	DeleteBranch(context.Context, *DeleteBranchRequest) (*DeleteBranchResponse, error)
+	FindBranch(context.Context, *FindBranchRequest) (*FindBranchResponse, error)
 }
 
 func RegisterRefServiceServer(s *grpc.Server, srv RefServiceServer) {
@@ -902,6 +1101,60 @@ func _RefService_RefExists_Handler(srv interface{}, ctx context.Context, dec fun
 	return interceptor(ctx, in, info, handler)
 }
 
+func _RefService_CreateBranch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CreateBranchRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RefServiceServer).CreateBranch(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.RefService/CreateBranch",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RefServiceServer).CreateBranch(ctx, req.(*CreateBranchRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _RefService_DeleteBranch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DeleteBranchRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RefServiceServer).DeleteBranch(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.RefService/DeleteBranch",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RefServiceServer).DeleteBranch(ctx, req.(*DeleteBranchRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _RefService_FindBranch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(FindBranchRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RefServiceServer).FindBranch(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.RefService/FindBranch",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RefServiceServer).FindBranch(ctx, req.(*FindBranchRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _RefService_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "gitaly.RefService",
 	HandlerType: (*RefServiceServer)(nil),
@@ -918,6 +1171,18 @@ var _RefService_serviceDesc = grpc.ServiceDesc{
 			MethodName: "RefExists",
 			Handler:    _RefService_RefExists_Handler,
 		},
+		{
+			MethodName: "CreateBranch",
+			Handler:    _RefService_CreateBranch_Handler,
+		},
+		{
+			MethodName: "DeleteBranch",
+			Handler:    _RefService_DeleteBranch_Handler,
+		},
+		{
+			MethodName: "FindBranch",
+			Handler:    _RefService_FindBranch_Handler,
+		},
 	},
 	Streams: []grpc.StreamDesc{
 		{
@@ -949,61 +1214,74 @@ var _RefService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "ref.proto",
 }
 
-func init() { proto.RegisterFile("ref.proto", fileDescriptor5) }
-
-var fileDescriptor5 = []byte{
-	// 833 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xdd, 0x6e, 0xe3, 0x44,
-	0x14, 0x5e, 0xe7, 0x6f, 0x93, 0x13, 0x6f, 0x9b, 0x0e, 0xcb, 0xe2, 0x75, 0x61, 0x9b, 0x1a, 0x0a,
-	0xed, 0x8d, 0x8b, 0x5c, 0xc1, 0x0d, 0x37, 0xe4, 0x8f, 0x16, 0x54, 0x0a, 0x9a, 0x04, 0xd4, 0x0b,
-	0xa4, 0x68, 0x92, 0x8c, 0x5d, 0xa3, 0x38, 0x0e, 0xf6, 0xa4, 0x34, 0x42, 0x3c, 0x01, 0xef, 0xc1,
-	0x5b, 0x70, 0xdd, 0xd7, 0x42, 0x99, 0x19, 0xbb, 0x4e, 0x32, 0x49, 0x91, 0xc2, 0x95, 0x7d, 0xce,
-	0x7c, 0xe7, 0x9b, 0x39, 0xff, 0x50, 0x89, 0xa8, 0x6b, 0x4f, 0xa3, 0x90, 0x85, 0xa8, 0xe4, 0xf9,
-	0x8c, 0x8c, 0xe7, 0xa6, 0x1e, 0xdf, 0x91, 0x88, 0x8e, 0x84, 0xd6, 0x3c, 0xf2, 0xc2, 0xd0, 0x1b,
-	0xd3, 0x73, 0x2e, 0x0d, 0x66, 0xee, 0x39, 0xf3, 0x03, 0x1a, 0x33, 0x12, 0x4c, 0x05, 0xc0, 0xc2,
-	0xf0, 0xe1, 0x37, 0xfe, 0x64, 0xd4, 0xa6, 0x2e, 0x99, 0x8d, 0x59, 0x33, 0x22, 0x93, 0xe1, 0xdd,
-	0x0d, 0x09, 0x28, 0xa6, 0xbf, 0xcd, 0x68, 0xcc, 0x90, 0x03, 0x10, 0xd1, 0x69, 0x18, 0xfb, 0x2c,
-	0x8c, 0xe6, 0x86, 0x56, 0xd7, 0x4e, 0xab, 0x0e, 0xb2, 0xc5, 0x5d, 0x36, 0x4e, 0x4f, 0x70, 0x06,
-	0x65, 0x5d, 0xc0, 0x47, 0x1b, 0x38, 0xe3, 0x69, 0x38, 0x89, 0x29, 0x42, 0x50, 0x98, 0x90, 0x80,
-	0x72, 0x3a, 0x1d, 0xf3, 0x7f, 0xeb, 0x07, 0x78, 0xbb, 0x30, 0x6a, 0x8c, 0xc7, 0x4f, 0x06, 0xf1,
-	0x2e, 0xaf, 0x70, 0xc0, 0x54, 0x11, 0xca, 0x27, 0xbc, 0x86, 0xe2, 0xe2, 0xda, 0xd8, 0xd0, 0xea,
-	0xf9, 0x53, 0x1d, 0x0b, 0xc1, 0xba, 0x86, 0x37, 0xd2, 0xa6, 0x47, 0xbc, 0x9d, 0x5f, 0x70, 0x0e,
-	0x1f, 0xac, 0xb1, 0x6d, 0xbd, 0xfe, 0x4f, 0x40, 0x0b, 0x03, 0x4c, 0xdd, 0x1d, 0x53, 0x80, 0x0e,
-	0xa1, 0x32, 0x0c, 0x83, 0xc0, 0x67, 0x7d, 0x7f, 0x64, 0xe4, 0xea, 0xda, 0x69, 0x05, 0x97, 0x85,
-	0xe2, 0xdb, 0x11, 0x7a, 0x03, 0xa5, 0x69, 0x44, 0x5d, 0xff, 0xc1, 0xc8, 0xf3, 0x04, 0x48, 0xc9,
-	0x3a, 0x83, 0xf7, 0x96, 0xae, 0xdf, 0x92, 0xad, 0x47, 0x0d, 0x8c, 0x05, 0xf6, 0x3a, 0x1c, 0x12,
-	0x19, 0xdf, 0x9d, 0x62, 0x85, 0xbe, 0x86, 0x97, 0x71, 0x18, 0xb1, 0xfe, 0x60, 0xce, 0x9f, 0xbb,
-	0xe7, 0x7c, 0x96, 0x18, 0x6c, 0xba, 0xc6, 0xee, 0x86, 0x11, 0x6b, 0xce, 0x71, 0x29, 0xe6, 0x5f,
-	0xeb, 0x0b, 0x28, 0x09, 0x0d, 0x2a, 0x43, 0xe1, 0xa6, 0xf1, 0x7d, 0xa7, 0xf6, 0x02, 0xed, 0x43,
-	0xf5, 0xa7, 0x1f, 0xdb, 0x8d, 0x5e, 0xa7, 0xdd, 0x6f, 0x74, 0x5b, 0x35, 0x0d, 0xd5, 0x40, 0x4f,
-	0x14, 0xed, 0x4e, 0xb7, 0x55, 0xcb, 0x59, 0xb7, 0xa2, 0xee, 0x56, 0x6e, 0x90, 0xae, 0x7f, 0x05,
-	0xe5, 0x81, 0xd4, 0xf1, 0x4c, 0x55, 0x9d, 0xa3, 0x0d, 0xcf, 0x4a, 0x4c, 0x70, 0x6a, 0x60, 0xfd,
-	0x95, 0x13, 0xf9, 0x57, 0xa0, 0x54, 0x31, 0xdd, 0x9e, 0xb3, 0x13, 0xd8, 0x93, 0x87, 0xf1, 0x6c,
-	0xf0, 0x2b, 0x1d, 0x32, 0x99, 0xbb, 0x57, 0x42, 0xdb, 0x15, 0x4a, 0x74, 0x05, 0x52, 0xd1, 0x27,
-	0x33, 0x76, 0x17, 0x46, 0x46, 0x81, 0x47, 0xff, 0xe3, 0x0d, 0xaf, 0x6e, 0x71, 0x6c, 0x83, 0x43,
-	0xb1, 0x3e, 0xcc, 0x48, 0xe8, 0x06, 0x6a, 0x92, 0x49, 0x7c, 0x18, 0x8d, 0x8c, 0xe2, 0x7f, 0x27,
-	0xdb, 0x17, 0x56, 0xad, 0xc4, 0xd6, 0xfa, 0x1d, 0x0e, 0xb7, 0xe0, 0x95, 0x01, 0x79, 0x0d, 0x45,
-	0x1a, 0x10, 0x7f, 0xcc, 0x83, 0xa1, 0x63, 0x21, 0x20, 0x1b, 0x0a, 0x23, 0xc2, 0x28, 0xf7, 0xbf,
-	0xea, 0x98, 0xb6, 0x98, 0x70, 0x76, 0x32, 0xe1, 0xec, 0x5e, 0x32, 0xe1, 0x30, 0xc7, 0x65, 0x7a,
-	0xfa, 0x7f, 0xa8, 0x53, 0xeb, 0x6f, 0x2d, 0x6d, 0xea, 0xb5, 0x6a, 0x69, 0xae, 0x55, 0xcb, 0xa7,
-	0xd9, 0x50, 0x29, 0x4c, 0x6c, 0x59, 0x16, 0xa9, 0x9d, 0x79, 0x09, 0x25, 0xa1, 0x53, 0x46, 0xe4,
-	0x0c, 0x4a, 0x8c, 0x44, 0x1e, 0x65, 0x3c, 0x24, 0x55, 0xe7, 0x20, 0xe1, 0xbf, 0x4c, 0x42, 0x8d,
-	0x25, 0xc0, 0xba, 0x12, 0xb3, 0x44, 0x0c, 0x9f, 0x9d, 0x5c, 0x7e, 0xd4, 0xc4, 0x5c, 0x48, 0xa9,
-	0xa4, 0xbb, 0x17, 0x50, 0x60, 0xc4, 0x53, 0x36, 0xc6, 0x0a, 0xd4, 0xee, 0x11, 0x0f, 0x73, 0xb0,
-	0xf9, 0x07, 0xe4, 0x7b, 0xc4, 0x53, 0x3a, 0xb7, 0x07, 0xb9, 0xb4, 0xf0, 0x73, 0xfe, 0x08, 0x7d,
-	0x09, 0xaf, 0x84, 0x2f, 0xb2, 0x02, 0x65, 0xc6, 0x15, 0x3e, 0xeb, 0x02, 0x27, 0x24, 0x64, 0xc0,
-	0xcb, 0x80, 0xc6, 0x31, 0xf1, 0x28, 0xaf, 0x7e, 0x1d, 0x27, 0xa2, 0x75, 0x0b, 0x35, 0x4c, 0xdd,
-	0xce, 0x83, 0x1f, 0xb3, 0x9d, 0x86, 0x55, 0x0d, 0xf2, 0x11, 0x75, 0x65, 0x59, 0x2e, 0x7e, 0xad,
-	0x33, 0x38, 0xc8, 0x30, 0x3f, 0x0d, 0xf9, 0x7b, 0x32, 0x9e, 0x09, 0x2f, 0xcb, 0x58, 0x08, 0xce,
-	0x3f, 0x45, 0x00, 0x4c, 0xdd, 0x2e, 0x8d, 0xee, 0xfd, 0x21, 0x45, 0x2e, 0xbc, 0xaf, 0x5c, 0x96,
-	0xe8, 0x93, 0x6c, 0x40, 0x37, 0xed, 0x67, 0xf3, 0xe4, 0x19, 0x94, 0x78, 0x8a, 0xf5, 0x02, 0xf5,
-	0xd3, 0x7a, 0xc8, 0xac, 0x43, 0x74, 0xac, 0x2c, 0xd0, 0xec, 0xe6, 0x33, 0xad, 0x6d, 0x90, 0x84,
-	0xfe, 0x73, 0x0d, 0xfd, 0x0c, 0xfb, 0x2b, 0xdb, 0x0e, 0xbd, 0x5b, 0xaf, 0x89, 0x25, 0xea, 0xa3,
-	0x8d, 0xe7, 0x19, 0xde, 0x2b, 0xa8, 0x66, 0xb6, 0x12, 0x32, 0xb3, 0x36, 0xcb, 0x9b, 0xd2, 0x3c,
-	0x54, 0x9e, 0xa5, 0x21, 0xf8, 0x05, 0x0e, 0xd6, 0x46, 0x3d, 0xaa, 0x3f, 0xb7, 0x67, 0xcc, 0xe3,
-	0x2d, 0x08, 0xa5, 0xff, 0x29, 0xf7, 0xbb, 0x8d, 0xed, 0xaf, 0xf6, 0x5f, 0xc9, 0xfb, 0x9d, 0xf0,
-	0x5f, 0xb6, 0xd4, 0xb2, 0xff, 0xcb, 0xdd, 0xbd, 0xec, 0xff, 0x4a, 0x0f, 0x72, 0xae, 0x26, 0x54,
-	0xd2, 0x32, 0x45, 0xc6, 0x53, 0x95, 0x2f, 0xf7, 0x84, 0xf9, 0x56, 0x71, 0x92, 0xb0, 0x0c, 0x4a,
-	0x7c, 0xd2, 0x5e, 0xfc, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x21, 0xf9, 0x20, 0xe0, 0x7c, 0x0a, 0x00,
-	0x00,
+func init() { proto.RegisterFile("ref.proto", fileDescriptor6) }
+
+var fileDescriptor6 = []byte{
+	// 1053 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x51, 0x73, 0x22, 0x45,
+	0x10, 0xce, 0x12, 0x6e, 0x93, 0x34, 0x1c, 0xd9, 0x4c, 0x62, 0x8e, 0x2c, 0xe7, 0x25, 0x37, 0x7a,
+	0x67, 0xf2, 0xb2, 0xb1, 0x48, 0xe9, 0x8b, 0x3e, 0x48, 0x00, 0x2f, 0x78, 0x91, 0xa4, 0x06, 0xbc,
+	0x4a, 0x95, 0x5a, 0xd4, 0x00, 0x03, 0x59, 0x0b, 0x58, 0xdc, 0x1d, 0xce, 0x4b, 0x59, 0xfa, 0x07,
+	0xfc, 0x0f, 0x3e, 0xfa, 0x57, 0xee, 0xc1, 0x3f, 0x65, 0x31, 0x33, 0xbb, 0xec, 0x92, 0x81, 0xb3,
+	0xc4, 0x7b, 0x82, 0xe9, 0xe9, 0xfe, 0x66, 0xfa, 0x9b, 0xee, 0x6f, 0x1b, 0xb6, 0x7c, 0xd6, 0x73,
+	0xc6, 0xbe, 0xc7, 0x3d, 0x64, 0xf6, 0x5d, 0x4e, 0x07, 0x77, 0x76, 0x36, 0xb8, 0xa5, 0x3e, 0xeb,
+	0x4a, 0xab, 0x7d, 0xd8, 0xf7, 0xbc, 0xfe, 0x80, 0x9d, 0x8a, 0x55, 0x7b, 0xd2, 0x3b, 0xe5, 0xee,
+	0x90, 0x05, 0x9c, 0x0e, 0xc7, 0xd2, 0x01, 0x13, 0x78, 0xfc, 0xb5, 0x3b, 0xea, 0x56, 0x58, 0x8f,
+	0x4e, 0x06, 0xfc, 0xdc, 0xa7, 0xa3, 0xce, 0x6d, 0x9d, 0x0e, 0x19, 0x61, 0x3f, 0x4f, 0x58, 0xc0,
+	0x51, 0x11, 0xc0, 0x67, 0x63, 0x2f, 0x70, 0xb9, 0xe7, 0xdf, 0xe5, 0x8d, 0x23, 0xe3, 0x38, 0x53,
+	0x44, 0x8e, 0x3c, 0xcb, 0x21, 0xd1, 0x0e, 0x89, 0x79, 0xe1, 0x33, 0xf8, 0x70, 0x01, 0x66, 0x30,
+	0xf6, 0x46, 0x01, 0x43, 0x08, 0xd2, 0x23, 0x3a, 0x64, 0x02, 0x2e, 0x4b, 0xc4, 0x7f, 0x7c, 0x05,
+	0x07, 0xd3, 0xa0, 0xd2, 0x60, 0x30, 0x0b, 0x08, 0x56, 0xb9, 0x45, 0x11, 0x6c, 0x1d, 0xa0, 0xba,
+	0xc2, 0x1e, 0x3c, 0x98, 0x1e, 0x1b, 0xe4, 0x8d, 0xa3, 0xf5, 0xe3, 0x2c, 0x91, 0x0b, 0x7c, 0x09,
+	0xfb, 0x2a, 0xa6, 0x49, 0xfb, 0x2b, 0xdf, 0xe0, 0x14, 0x1e, 0xdd, 0x43, 0x5b, 0x7a, 0xfc, 0x6f,
+	0x80, 0xa6, 0x01, 0x84, 0xf5, 0x56, 0x7c, 0x02, 0x54, 0x80, 0xad, 0x8e, 0x37, 0x1c, 0xba, 0xbc,
+	0xe5, 0x76, 0xf3, 0xa9, 0x23, 0xe3, 0x78, 0x8b, 0x6c, 0x4a, 0x43, 0xad, 0x8b, 0xf6, 0xc1, 0x1c,
+	0xfb, 0xac, 0xe7, 0xbe, 0xc9, 0xaf, 0x8b, 0x07, 0x50, 0x2b, 0x7c, 0x02, 0xbb, 0x89, 0xe3, 0x97,
+	0xbc, 0xd6, 0x5b, 0x03, 0xf2, 0x53, 0xdf, 0x4b, 0xaf, 0x43, 0x15, 0xbf, 0x2b, 0x71, 0x85, 0xbe,
+	0x82, 0x8d, 0xc0, 0xf3, 0x79, 0xab, 0x7d, 0x27, 0xae, 0x9b, 0x2b, 0x7e, 0x12, 0x06, 0x2c, 0x3a,
+	0xc6, 0x69, 0x78, 0x3e, 0x3f, 0xbf, 0x23, 0x66, 0x20, 0x7e, 0xf1, 0x67, 0x60, 0x4a, 0x0b, 0xda,
+	0x84, 0x74, 0xbd, 0xf4, 0x6d, 0xd5, 0x5a, 0x43, 0xdb, 0x90, 0xf9, 0xee, 0xba, 0x52, 0x6a, 0x56,
+	0x2b, 0xad, 0x52, 0xa3, 0x6c, 0x19, 0xc8, 0x82, 0x6c, 0x68, 0xa8, 0x54, 0x1b, 0x65, 0x2b, 0x85,
+	0x6f, 0x64, 0xdd, 0xcd, 0x9d, 0xa0, 0x52, 0xff, 0x02, 0x36, 0xdb, 0xca, 0x26, 0x5e, 0x2a, 0x53,
+	0x3c, 0x5c, 0x70, 0xad, 0x30, 0x84, 0x44, 0x01, 0xf8, 0x8f, 0x94, 0x7c, 0x7f, 0x8d, 0x97, 0x8e,
+	0xd3, 0xe5, 0x6f, 0xf6, 0x0c, 0x72, 0x6a, 0x33, 0x98, 0xb4, 0x7f, 0x62, 0x1d, 0xae, 0xde, 0xee,
+	0xa1, 0xb4, 0x36, 0xa4, 0x11, 0x5d, 0x80, 0x32, 0xb4, 0xe8, 0x84, 0xdf, 0x7a, 0x7e, 0x3e, 0x2d,
+	0xd8, 0xff, 0x68, 0xc1, 0xad, 0xcb, 0xc2, 0xb7, 0x24, 0x5c, 0x49, 0xb6, 0x13, 0x5b, 0xa1, 0x3a,
+	0x58, 0x0a, 0x49, 0xfe, 0x70, 0xe6, 0xe7, 0x1f, 0xfc, 0x7b, 0xb0, 0x6d, 0x19, 0x55, 0x0e, 0x63,
+	0xf1, 0x2f, 0x50, 0x58, 0xe2, 0xaf, 0x25, 0x64, 0x0f, 0x1e, 0xb0, 0x21, 0x75, 0x07, 0x82, 0x8c,
+	0x2c, 0x91, 0x0b, 0xe4, 0x40, 0xba, 0x4b, 0x39, 0x13, 0xf9, 0x67, 0x8a, 0xb6, 0x23, 0x15, 0xce,
+	0x09, 0x15, 0xce, 0x69, 0x86, 0x0a, 0x47, 0x84, 0x5f, 0xac, 0xa7, 0xff, 0x87, 0x3a, 0xc5, 0x7f,
+	0x19, 0x51, 0x53, 0xdf, 0xab, 0x96, 0xf3, 0x7b, 0xd5, 0xf2, 0x3c, 0x4e, 0x95, 0x26, 0xc4, 0x51,
+	0x65, 0x11, 0xc5, 0xd9, 0x2f, 0xc0, 0x94, 0x36, 0x2d, 0x23, 0x27, 0x60, 0x72, 0xea, 0xf7, 0x19,
+	0x17, 0x94, 0x64, 0x8a, 0x3b, 0x21, 0xfe, 0x8b, 0x90, 0x6a, 0xa2, 0x1c, 0xf0, 0x85, 0xd4, 0x12,
+	0x29, 0x3e, 0x2b, 0xa5, 0xfc, 0xd6, 0x90, 0xba, 0x10, 0x41, 0xa9, 0x74, 0xcf, 0x20, 0xcd, 0x69,
+	0x5f, 0xdb, 0x18, 0x73, 0xae, 0x4e, 0x93, 0xf6, 0x89, 0x70, 0xb6, 0x7f, 0x85, 0xf5, 0x26, 0xed,
+	0x6b, 0x93, 0xcb, 0x41, 0x2a, 0x2a, 0xfc, 0x94, 0xdb, 0x45, 0x9f, 0xc3, 0x43, 0x99, 0x8b, 0xaa,
+	0x40, 0xf5, 0xe2, 0x9a, 0x9c, 0xb3, 0xd2, 0x4f, 0xae, 0x50, 0x1e, 0x36, 0x86, 0x2c, 0x08, 0x68,
+	0x9f, 0x89, 0xea, 0xcf, 0x92, 0x70, 0x89, 0x6f, 0xc0, 0x22, 0xac, 0x57, 0x7d, 0xe3, 0x06, 0x7c,
+	0x25, 0xb1, 0xb2, 0x60, 0xdd, 0x67, 0x3d, 0x55, 0x96, 0xd3, 0xbf, 0xf8, 0x04, 0x76, 0x62, 0xc8,
+	0x33, 0x91, 0x7f, 0x4d, 0x07, 0x13, 0x99, 0xe5, 0x26, 0x91, 0x0b, 0xfc, 0x3b, 0xec, 0x96, 0x7d,
+	0x46, 0x39, 0x0b, 0x25, 0xe1, 0xbf, 0xdf, 0x23, 0x64, 0x31, 0x15, 0x63, 0xf1, 0x10, 0x32, 0x01,
+	0xa7, 0x3e, 0x6f, 0x8d, 0x3d, 0x77, 0x14, 0xaa, 0x04, 0x08, 0xd3, 0xf5, 0xd4, 0x82, 0xff, 0x36,
+	0x60, 0x2f, 0x79, 0x81, 0x48, 0xec, 0xcc, 0x80, 0x53, 0x3e, 0x09, 0xc4, 0xe9, 0xb9, 0x59, 0x9f,
+	0xeb, 0xbc, 0x9d, 0x86, 0x70, 0x25, 0x2a, 0x04, 0x3d, 0x07, 0x53, 0xd6, 0xb0, 0xaa, 0xcc, 0x5c,
+	0x18, 0xac, 0xc2, 0xd4, 0x2e, 0xae, 0x83, 0x29, 0x23, 0x91, 0x09, 0xa9, 0xab, 0x97, 0xd6, 0x1a,
+	0xca, 0x01, 0x54, 0x09, 0x69, 0x55, 0x6f, 0x6a, 0x8d, 0x66, 0xc3, 0x32, 0xa6, 0x9a, 0x3d, 0x5d,
+	0xd7, 0xea, 0xaf, 0x4a, 0x97, 0xb5, 0x8a, 0x95, 0x42, 0x05, 0x78, 0x14, 0x33, 0xb4, 0x1a, 0xcd,
+	0x12, 0x69, 0xb6, 0xae, 0xaf, 0x6a, 0xf5, 0xa6, 0xb5, 0x8e, 0x7f, 0x84, 0xdd, 0x0a, 0x1b, 0xb0,
+	0xf7, 0xc4, 0x26, 0xde, 0x87, 0xbd, 0x24, 0xbc, 0xcc, 0x1e, 0x7f, 0x0f, 0x3b, 0xd3, 0x3a, 0x7f,
+	0x3f, 0x87, 0x7e, 0x29, 0x5b, 0x77, 0xee, 0x79, 0x66, 0x0c, 0x1b, 0xcb, 0x18, 0x2e, 0xfe, 0xb9,
+	0x01, 0x40, 0x58, 0xaf, 0xc1, 0xfc, 0xd7, 0x6e, 0x87, 0xa1, 0x1e, 0x7c, 0xa0, 0x1d, 0xc6, 0xd0,
+	0xc7, 0xf1, 0x86, 0x5d, 0x34, 0xff, 0xd9, 0xcf, 0xde, 0xe1, 0xa5, 0xf8, 0x58, 0x43, 0xad, 0x48,
+	0x6f, 0x62, 0xe3, 0x16, 0x7a, 0xaa, 0x15, 0xc0, 0xf8, 0x64, 0x65, 0xe3, 0x65, 0x2e, 0x21, 0xfc,
+	0xa7, 0x06, 0x7a, 0x05, 0xdb, 0x73, 0xd3, 0x14, 0x7a, 0x72, 0x5f, 0x73, 0x12, 0xd0, 0x87, 0x0b,
+	0xf7, 0x63, 0xb8, 0x17, 0x90, 0x89, 0x4d, 0x3d, 0xc8, 0x8e, 0xc7, 0x24, 0x27, 0x31, 0xbb, 0xa0,
+	0xdd, 0x8b, 0x28, 0xf8, 0x41, 0x16, 0x45, 0x62, 0x94, 0x40, 0x47, 0xef, 0x9a, 0x63, 0xec, 0xa7,
+	0x4b, 0x3c, 0xb4, 0xf9, 0x47, 0xd8, 0x4f, 0x16, 0x7e, 0x5e, 0xf4, 0xf9, 0x6b, 0x71, 0xbf, 0x91,
+	0xf9, 0x2b, 0xc9, 0x4e, 0xe6, 0x9f, 0xfc, 0x7a, 0x24, 0xf3, 0x9f, 0xd3, 0x78, 0x81, 0x75, 0x0e,
+	0x5b, 0x91, 0x0c, 0xa2, 0xfc, 0xac, 0xf4, 0x93, 0x9a, 0x6b, 0x1f, 0x68, 0x76, 0x22, 0x16, 0x5f,
+	0x42, 0x36, 0x2e, 0x38, 0xa8, 0xa0, 0x97, 0x21, 0x89, 0xf4, 0x78, 0x99, 0x46, 0x49, 0xb0, 0x78,
+	0xff, 0xce, 0xc0, 0x34, 0xa2, 0x31, 0x03, 0xd3, 0xb6, 0xfc, 0x1a, 0xaa, 0x02, 0xcc, 0xfa, 0x12,
+	0x1d, 0xc4, 0xc9, 0x48, 0x02, 0xd9, 0xba, 0xad, 0x10, 0xa6, 0x6d, 0x8a, 0x51, 0xe5, 0xec, 0x9f,
+	0x00, 0x00, 0x00, 0xff, 0xff, 0xf3, 0x6c, 0xba, 0xd7, 0xbd, 0x0d, 0x00, 0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/repository-service.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/repository-service.pb.go
index 73dff671a..2fde609d1 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/repository-service.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/repository-service.pb.go
@@ -24,7 +24,7 @@ type RepositoryExistsRequest struct {
 func (m *RepositoryExistsRequest) Reset()                    { *m = RepositoryExistsRequest{} }
 func (m *RepositoryExistsRequest) String() string            { return proto.CompactTextString(m) }
 func (*RepositoryExistsRequest) ProtoMessage()               {}
-func (*RepositoryExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{0} }
+func (*RepositoryExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{0} }
 
 func (m *RepositoryExistsRequest) GetRepository() *Repository {
 	if m != nil {
@@ -40,7 +40,7 @@ type RepositoryExistsResponse struct {
 func (m *RepositoryExistsResponse) Reset()                    { *m = RepositoryExistsResponse{} }
 func (m *RepositoryExistsResponse) String() string            { return proto.CompactTextString(m) }
 func (*RepositoryExistsResponse) ProtoMessage()               {}
-func (*RepositoryExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1} }
+func (*RepositoryExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{1} }
 
 func (m *RepositoryExistsResponse) GetExists() bool {
 	if m != nil {
@@ -56,7 +56,7 @@ type RepackIncrementalRequest struct {
 func (m *RepackIncrementalRequest) Reset()                    { *m = RepackIncrementalRequest{} }
 func (m *RepackIncrementalRequest) String() string            { return proto.CompactTextString(m) }
 func (*RepackIncrementalRequest) ProtoMessage()               {}
-func (*RepackIncrementalRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{2} }
+func (*RepackIncrementalRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{2} }
 
 func (m *RepackIncrementalRequest) GetRepository() *Repository {
 	if m != nil {
@@ -71,7 +71,7 @@ type RepackIncrementalResponse struct {
 func (m *RepackIncrementalResponse) Reset()                    { *m = RepackIncrementalResponse{} }
 func (m *RepackIncrementalResponse) String() string            { return proto.CompactTextString(m) }
 func (*RepackIncrementalResponse) ProtoMessage()               {}
-func (*RepackIncrementalResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{3} }
+func (*RepackIncrementalResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{3} }
 
 type RepackFullRequest struct {
 	Repository   *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -81,7 +81,7 @@ type RepackFullRequest struct {
 func (m *RepackFullRequest) Reset()                    { *m = RepackFullRequest{} }
 func (m *RepackFullRequest) String() string            { return proto.CompactTextString(m) }
 func (*RepackFullRequest) ProtoMessage()               {}
-func (*RepackFullRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{4} }
+func (*RepackFullRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{4} }
 
 func (m *RepackFullRequest) GetRepository() *Repository {
 	if m != nil {
@@ -103,7 +103,7 @@ type RepackFullResponse struct {
 func (m *RepackFullResponse) Reset()                    { *m = RepackFullResponse{} }
 func (m *RepackFullResponse) String() string            { return proto.CompactTextString(m) }
 func (*RepackFullResponse) ProtoMessage()               {}
-func (*RepackFullResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{5} }
+func (*RepackFullResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{5} }
 
 type GarbageCollectRequest struct {
 	Repository   *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -113,7 +113,7 @@ type GarbageCollectRequest struct {
 func (m *GarbageCollectRequest) Reset()                    { *m = GarbageCollectRequest{} }
 func (m *GarbageCollectRequest) String() string            { return proto.CompactTextString(m) }
 func (*GarbageCollectRequest) ProtoMessage()               {}
-func (*GarbageCollectRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{6} }
+func (*GarbageCollectRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{6} }
 
 func (m *GarbageCollectRequest) GetRepository() *Repository {
 	if m != nil {
@@ -135,7 +135,7 @@ type GarbageCollectResponse struct {
 func (m *GarbageCollectResponse) Reset()                    { *m = GarbageCollectResponse{} }
 func (m *GarbageCollectResponse) String() string            { return proto.CompactTextString(m) }
 func (*GarbageCollectResponse) ProtoMessage()               {}
-func (*GarbageCollectResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{7} }
+func (*GarbageCollectResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{7} }
 
 type RepositorySizeRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -144,7 +144,7 @@ type RepositorySizeRequest struct {
 func (m *RepositorySizeRequest) Reset()                    { *m = RepositorySizeRequest{} }
 func (m *RepositorySizeRequest) String() string            { return proto.CompactTextString(m) }
 func (*RepositorySizeRequest) ProtoMessage()               {}
-func (*RepositorySizeRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{8} }
+func (*RepositorySizeRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{8} }
 
 func (m *RepositorySizeRequest) GetRepository() *Repository {
 	if m != nil {
@@ -161,7 +161,7 @@ type RepositorySizeResponse struct {
 func (m *RepositorySizeResponse) Reset()                    { *m = RepositorySizeResponse{} }
 func (m *RepositorySizeResponse) String() string            { return proto.CompactTextString(m) }
 func (*RepositorySizeResponse) ProtoMessage()               {}
-func (*RepositorySizeResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{9} }
+func (*RepositorySizeResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{9} }
 
 func (m *RepositorySizeResponse) GetSize() int64 {
 	if m != nil {
@@ -178,7 +178,7 @@ type ApplyGitattributesRequest struct {
 func (m *ApplyGitattributesRequest) Reset()                    { *m = ApplyGitattributesRequest{} }
 func (m *ApplyGitattributesRequest) String() string            { return proto.CompactTextString(m) }
 func (*ApplyGitattributesRequest) ProtoMessage()               {}
-func (*ApplyGitattributesRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{10} }
+func (*ApplyGitattributesRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{10} }
 
 func (m *ApplyGitattributesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -200,7 +200,7 @@ type ApplyGitattributesResponse struct {
 func (m *ApplyGitattributesResponse) Reset()                    { *m = ApplyGitattributesResponse{} }
 func (m *ApplyGitattributesResponse) String() string            { return proto.CompactTextString(m) }
 func (*ApplyGitattributesResponse) ProtoMessage()               {}
-func (*ApplyGitattributesResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{11} }
+func (*ApplyGitattributesResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{11} }
 
 type FetchRemoteRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
@@ -215,7 +215,7 @@ type FetchRemoteRequest struct {
 func (m *FetchRemoteRequest) Reset()                    { *m = FetchRemoteRequest{} }
 func (m *FetchRemoteRequest) String() string            { return proto.CompactTextString(m) }
 func (*FetchRemoteRequest) ProtoMessage()               {}
-func (*FetchRemoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{12} }
+func (*FetchRemoteRequest) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{12} }
 
 func (m *FetchRemoteRequest) GetRepository() *Repository {
 	if m != nil {
@@ -272,7 +272,7 @@ type FetchRemoteResponse struct {
 func (m *FetchRemoteResponse) Reset()                    { *m = FetchRemoteResponse{} }
 func (m *FetchRemoteResponse) String() string            { return proto.CompactTextString(m) }
 func (*FetchRemoteResponse) ProtoMessage()               {}
-func (*FetchRemoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{13} }
+func (*FetchRemoteResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{13} }
 
 func init() {
 	proto.RegisterType((*RepositoryExistsRequest)(nil), "gitaly.RepositoryExistsRequest")
@@ -596,9 +596,9 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "repository-service.proto",
 }
 
-func init() { proto.RegisterFile("repository-service.proto", fileDescriptor6) }
+func init() { proto.RegisterFile("repository-service.proto", fileDescriptor7) }
 
-var fileDescriptor6 = []byte{
+var fileDescriptor7 = []byte{
 	// 558 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xcd, 0x6e, 0xd3, 0x40,
 	0x10, 0x6e, 0x68, 0x93, 0x94, 0x49, 0x40, 0x30, 0x34, 0xa9, 0xe3, 0x02, 0x0d, 0xe6, 0xd2, 0x03,
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/shared.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/shared.pb.go
index 27ec0bb96..e814dd606 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/shared.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/shared.pb.go
@@ -27,7 +27,7 @@ type Repository struct {
 func (m *Repository) Reset()                    { *m = Repository{} }
 func (m *Repository) String() string            { return proto.CompactTextString(m) }
 func (*Repository) ProtoMessage()               {}
-func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{0} }
+func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{0} }
 
 func (m *Repository) GetStorageName() string {
 	if m != nil {
@@ -70,7 +70,7 @@ type GitCommit struct {
 func (m *GitCommit) Reset()                    { *m = GitCommit{} }
 func (m *GitCommit) String() string            { return proto.CompactTextString(m) }
 func (*GitCommit) ProtoMessage()               {}
-func (*GitCommit) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{1} }
+func (*GitCommit) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{1} }
 
 func (m *GitCommit) GetId() string {
 	if m != nil {
@@ -123,7 +123,7 @@ type CommitAuthor struct {
 func (m *CommitAuthor) Reset()                    { *m = CommitAuthor{} }
 func (m *CommitAuthor) String() string            { return proto.CompactTextString(m) }
 func (*CommitAuthor) ProtoMessage()               {}
-func (*CommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{2} }
+func (*CommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{2} }
 
 func (m *CommitAuthor) GetName() []byte {
 	if m != nil {
@@ -153,7 +153,7 @@ type ExitStatus struct {
 func (m *ExitStatus) Reset()                    { *m = ExitStatus{} }
 func (m *ExitStatus) String() string            { return proto.CompactTextString(m) }
 func (*ExitStatus) ProtoMessage()               {}
-func (*ExitStatus) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{3} }
+func (*ExitStatus) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{3} }
 
 func (m *ExitStatus) GetValue() int32 {
 	if m != nil {
@@ -171,7 +171,7 @@ type Branch struct {
 func (m *Branch) Reset()                    { *m = Branch{} }
 func (m *Branch) String() string            { return proto.CompactTextString(m) }
 func (*Branch) ProtoMessage()               {}
-func (*Branch) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{4} }
+func (*Branch) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{4} }
 
 func (m *Branch) GetName() []byte {
 	if m != nil {
@@ -195,9 +195,9 @@ func init() {
 	proto.RegisterType((*Branch)(nil), "gitaly.Branch")
 }
 
-func init() { proto.RegisterFile("shared.proto", fileDescriptor7) }
+func init() { proto.RegisterFile("shared.proto", fileDescriptor8) }
 
-var fileDescriptor7 = []byte{
+var fileDescriptor8 = []byte{
 	// 428 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x52, 0x4d, 0x6f, 0xd3, 0x40,
 	0x10, 0x95, 0xd3, 0xc4, 0xe0, 0x89, 0x8b, 0x60, 0x95, 0x83, 0x55, 0xa9, 0x22, 0x98, 0x4b, 0x0f,
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/smarthttp.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/smarthttp.pb.go
index ce4691806..aabb3f766 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/smarthttp.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/smarthttp.pb.go
@@ -24,7 +24,7 @@ type InfoRefsRequest struct {
 func (m *InfoRefsRequest) Reset()                    { *m = InfoRefsRequest{} }
 func (m *InfoRefsRequest) String() string            { return proto.CompactTextString(m) }
 func (*InfoRefsRequest) ProtoMessage()               {}
-func (*InfoRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{0} }
+func (*InfoRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{0} }
 
 func (m *InfoRefsRequest) GetRepository() *Repository {
 	if m != nil {
@@ -40,7 +40,7 @@ type InfoRefsResponse struct {
 func (m *InfoRefsResponse) Reset()                    { *m = InfoRefsResponse{} }
 func (m *InfoRefsResponse) String() string            { return proto.CompactTextString(m) }
 func (*InfoRefsResponse) ProtoMessage()               {}
-func (*InfoRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{1} }
+func (*InfoRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{1} }
 
 func (m *InfoRefsResponse) GetData() []byte {
 	if m != nil {
@@ -59,7 +59,7 @@ type PostUploadPackRequest struct {
 func (m *PostUploadPackRequest) Reset()                    { *m = PostUploadPackRequest{} }
 func (m *PostUploadPackRequest) String() string            { return proto.CompactTextString(m) }
 func (*PostUploadPackRequest) ProtoMessage()               {}
-func (*PostUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{2} }
+func (*PostUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{2} }
 
 func (m *PostUploadPackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -83,7 +83,7 @@ type PostUploadPackResponse struct {
 func (m *PostUploadPackResponse) Reset()                    { *m = PostUploadPackResponse{} }
 func (m *PostUploadPackResponse) String() string            { return proto.CompactTextString(m) }
 func (*PostUploadPackResponse) ProtoMessage()               {}
-func (*PostUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{3} }
+func (*PostUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{3} }
 
 func (m *PostUploadPackResponse) GetData() []byte {
 	if m != nil {
@@ -106,7 +106,7 @@ type PostReceivePackRequest struct {
 func (m *PostReceivePackRequest) Reset()                    { *m = PostReceivePackRequest{} }
 func (m *PostReceivePackRequest) String() string            { return proto.CompactTextString(m) }
 func (*PostReceivePackRequest) ProtoMessage()               {}
-func (*PostReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{4} }
+func (*PostReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{4} }
 
 func (m *PostReceivePackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -144,7 +144,7 @@ type PostReceivePackResponse struct {
 func (m *PostReceivePackResponse) Reset()                    { *m = PostReceivePackResponse{} }
 func (m *PostReceivePackResponse) String() string            { return proto.CompactTextString(m) }
 func (*PostReceivePackResponse) ProtoMessage()               {}
-func (*PostReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{5} }
+func (*PostReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{5} }
 
 func (m *PostReceivePackResponse) GetData() []byte {
 	if m != nil {
@@ -459,9 +459,9 @@ var _SmartHTTPService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "smarthttp.proto",
 }
 
-func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor8) }
+func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor9) }
 
-var fileDescriptor8 = []byte{
+var fileDescriptor9 = []byte{
 	// 327 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x53, 0x4d, 0x4b, 0xc3, 0x40,
 	0x10, 0x75, 0x6b, 0x2d, 0x38, 0x56, 0x5b, 0xa6, 0x68, 0x4b, 0x40, 0x2d, 0x11, 0xa4, 0x07, 0x2d,
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ssh.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ssh.pb.go
index 1da05a62b..eda632e27 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ssh.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/ssh.pb.go
@@ -29,7 +29,7 @@ type SSHUploadPackRequest struct {
 func (m *SSHUploadPackRequest) Reset()                    { *m = SSHUploadPackRequest{} }
 func (m *SSHUploadPackRequest) String() string            { return proto.CompactTextString(m) }
 func (*SSHUploadPackRequest) ProtoMessage()               {}
-func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{0} }
+func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{0} }
 
 func (m *SSHUploadPackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -65,7 +65,7 @@ type SSHUploadPackResponse struct {
 func (m *SSHUploadPackResponse) Reset()                    { *m = SSHUploadPackResponse{} }
 func (m *SSHUploadPackResponse) String() string            { return proto.CompactTextString(m) }
 func (*SSHUploadPackResponse) ProtoMessage()               {}
-func (*SSHUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{1} }
+func (*SSHUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{1} }
 
 func (m *SSHUploadPackResponse) GetStdout() []byte {
 	if m != nil {
@@ -102,7 +102,7 @@ type SSHReceivePackRequest struct {
 func (m *SSHReceivePackRequest) Reset()                    { *m = SSHReceivePackRequest{} }
 func (m *SSHReceivePackRequest) String() string            { return proto.CompactTextString(m) }
 func (*SSHReceivePackRequest) ProtoMessage()               {}
-func (*SSHReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{2} }
+func (*SSHReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{2} }
 
 func (m *SSHReceivePackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -145,7 +145,7 @@ type SSHReceivePackResponse struct {
 func (m *SSHReceivePackResponse) Reset()                    { *m = SSHReceivePackResponse{} }
 func (m *SSHReceivePackResponse) String() string            { return proto.CompactTextString(m) }
 func (*SSHReceivePackResponse) ProtoMessage()               {}
-func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{3} }
+func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor10, []int{3} }
 
 func (m *SSHReceivePackResponse) GetStdout() []byte {
 	if m != nil {
@@ -348,9 +348,9 @@ var _SSHService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "ssh.proto",
 }
 
-func init() { proto.RegisterFile("ssh.proto", fileDescriptor9) }
+func init() { proto.RegisterFile("ssh.proto", fileDescriptor10) }
 
-var fileDescriptor9 = []byte{
+var fileDescriptor10 = []byte{
 	// 360 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x93, 0xc1, 0x4e, 0xf2, 0x40,
 	0x10, 0xc7, 0xbf, 0xfd, 0x28, 0xe4, 0x63, 0x28, 0x5f, 0xc8, 0x0a, 0xa4, 0x21, 0x6a, 0x48, 0xbd,
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 6fac67208..39d4bb516 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -191,12 +191,12 @@
 			"revisionTime": "2017-01-30T11:31:45Z"
 		},
 		{
-			"checksumSHA1": "n36XcjMQ023hikSz5ZuhA8tYhl8=",
+			"checksumSHA1": "h9qIl7zL7oDn97SjEQJhqNoMT5k=",
 			"path": "gitlab.com/gitlab-org/gitaly-proto/go",
-			"revision": "d79e71bde0be917f75b19d10206565c72db42b49",
-			"revisionTime": "2017-08-24T12:44:40Z",
-			"version": "v0.31.0",
-			"versionExact": "v0.31.0"
+			"revision": "8f90115d335d7914708491e81c94b535f982594c",
+			"revisionTime": "2017-08-30T07:53:26Z",
+			"version": "v0.32.0",
+			"versionExact": "v0.32.0"
 		},
 		{
 			"checksumSHA1": "Y+HGqEkYM15ir+J93MEaHdyFy0c=",