Merge branch '315-conversation-commits_between' into 'master'

Commit::CommitsBetween server implementation

See merge request !197

26 files changed, 1155 insertions, 325 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 960b6eeb2..c410525bc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,8 @@ UNRELEASED
 
 - Ensure that sub-processes inherit TZ environment variable
   https://gitlab.com/gitlab-org/gitaly/merge_requests/201
+- Implement CommitService::CommitsBetween
+  https://gitlab.com/gitlab-org/gitaly/merge_requests/197
 
 v0.14.0
 
diff --git a/internal/git/helper.go b/internal/git/helper.go
new file mode 100644
index 000000000..37e341393
--- /dev/null
+++ b/internal/git/helper.go
@@ -0,0 +1,40 @@
+package git
+
+import (
+	"time"
+
+	"github.com/golang/protobuf/ptypes/timestamp"
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+)
+
+// NewCommit creates a commit based on the given elements
+func NewCommit(id, subject, authorName, authorEmail, authorDate,
+	committerName, committerEmail, committerDate []byte) (*pb.GitCommit, error) {
+	authorDateTime, err := time.Parse(time.RFC3339, string(authorDate))
+	if err != nil {
+		return nil, err
+	}
+
+	committerDateTime, err := time.Parse(time.RFC3339, string(committerDate))
+	if err != nil {
+		return nil, err
+	}
+
+	author := pb.CommitAuthor{
+		Name:  authorName,
+		Email: authorEmail,
+		Date:  &timestamp.Timestamp{Seconds: authorDateTime.Unix()},
+	}
+	committer := pb.CommitAuthor{
+		Name:  committerName,
+		Email: committerEmail,
+		Date:  &timestamp.Timestamp{Seconds: committerDateTime.Unix()},
+	}
+
+	return &pb.GitCommit{
+		Id:        string(id),
+		Subject:   subject,
+		Author:    &author,
+		Committer: &committer,
+	}, nil
+}
diff --git a/internal/helper/lines/send.go b/internal/helper/lines/send.go
new file mode 100644
index 000000000..804c799b1
--- /dev/null
+++ b/internal/helper/lines/send.go
@@ -0,0 +1,81 @@
+package lines
+
+import (
+	"bufio"
+	"io"
+)
+
+// MaxMsgSize establishes the threshold to flush the buffer when using the
+// `Send` function. It's a variable instead of a constant to make it easier to
+// override in tests.
+var MaxMsgSize = 1024 * 128 // 128 KiB
+
+// Sender handles a buffer of lines from a Git command
+type Sender func([][]byte) error
+
+type writer struct {
+	sender Sender
+	size   int
+	lines  [][]byte
+}
+
+// CopyAndAppend adds a newly allocated copy of `e` to the `s` slice. Useful to
+// avoid io buffer shennanigans
+func CopyAndAppend(s [][]byte, e []byte) ([][]byte, int) {
+	line := make([]byte, len(e))
+	size := copy(line, e)
+	return append(s, line), size
+}
+
+// flush calls the `sender` handler function with the accumulated lines and
+// clears the lines buffer.
+func (w *writer) flush() error {
+	if len(w.lines) == 0 { // No message to send, just return
+		return nil
+	}
+
+	if err := w.sender(w.lines); err != nil {
+		return err
+	}
+
+	// Reset the message
+	w.lines = nil
+	w.size = 0
+
+	return nil
+}
+
+// addLine adds a new line to the writer buffer, and flushes if the maximum
+// size has been achieved
+func (w *writer) addLine(p []byte) error {
+	lines, size := CopyAndAppend(w.lines, p)
+	w.size += size
+	w.lines = lines
+
+	if w.size > MaxMsgSize {
+		return w.flush()
+	}
+
+	return nil
+}
+
+// consume reads from an `io.Reader` and writes each line to the buffer. It
+// flushes after being done reading.
+func (w *writer) consume(r io.Reader) error {
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		if err := w.addLine(scanner.Bytes()); err != nil {
+			return err
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return err
+	}
+	return w.flush()
+}
+
+// Send reads from `r` and handles the buffered lines using `sender`
+func Send(r io.Reader, sender Sender) error {
+	writer := &writer{sender: sender}
+	return writer.consume(r)
+}
diff --git a/internal/service/commit/between.go b/internal/service/commit/between.go
new file mode 100644
index 000000000..2e6ba842a
--- /dev/null
+++ b/internal/service/commit/between.go
@@ -0,0 +1,81 @@
+package commit
+
+import (
+	"fmt"
+	"strings"
+
+	log "github.com/Sirupsen/logrus"
+
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+	"gitlab.com/gitlab-org/gitaly/internal/helper"
+	"gitlab.com/gitlab-org/gitaly/internal/helper/lines"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+)
+
+var commitLogFormatFields = []string{
+	"%H",  // commit hash
+	"%s",  // subject
+	"%an", // author name
+	"%ae", // author email
+	"%aI", // author date, strict ISO 8601 format
+	"%cn", // committer name
+	"%ce", // committer email
+	"%cI", // committer date, strict ISO 8601 format
+}
+
+func gitLog(writer lines.Sender, repo *pb.Repository, from string, to string) error {
+	repoPath, err := helper.GetRepoPath(repo)
+	if err != nil {
+		return err
+	}
+
+	log.WithFields(log.Fields{
+		"RepoPath": repoPath,
+		"From":     from,
+		"To":       to,
+	}).Debug("GitLog")
+
+	revisionRange := string(from) + ".." + string(to)
+	formatFlag := "--pretty=format:" + strings.Join(commitLogFormatFields, "%x00")
+
+	cmd, err := helper.GitCommandReader("--git-dir", repoPath, "log", revisionRange, formatFlag)
+	if err != nil {
+		return err
+	}
+	defer cmd.Kill()
+
+	if err := lines.Send(cmd, writer); err != nil {
+		return err
+	}
+
+	if err := cmd.Wait(); err != nil {
+		// We expect this error to be caused by non-existing references. In that
+		// case, we just log the error and send no commits to the `writer`.
+		log.WithFields(log.Fields{"error": err}).Info("ignoring git-log error")
+	}
+
+	return nil
+}
+
+func validateCommitsBetweenRequest(in *pb.CommitsBetweenRequest) error {
+	if len(in.GetFrom()) == 0 {
+		return fmt.Errorf("empty From")
+	}
+
+	if len(in.GetTo()) == 0 {
+		return fmt.Errorf("empty To")
+	}
+
+	return nil
+}
+
+func (s *server) CommitsBetween(in *pb.CommitsBetweenRequest, stream pb.CommitService_CommitsBetweenServer) error {
+	if err := validateCommitsBetweenRequest(in); err != nil {
+		return grpc.Errorf(codes.InvalidArgument, "CommitsBetween: %v", err)
+	}
+
+	writer := newCommitsBetweenWriter(stream)
+
+	return gitLog(writer, in.GetRepository(), string(in.GetFrom()), string(in.GetTo()))
+}
diff --git a/internal/service/commit/between_test.go b/internal/service/commit/between_test.go
new file mode 100644
index 000000000..c8e20b54a
--- /dev/null
+++ b/internal/service/commit/between_test.go
@@ -0,0 +1,215 @@
+package commit
+
+import (
+	"io"
+	"testing"
+
+	"github.com/golang/protobuf/ptypes/timestamp"
+
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
+	"golang.org/x/net/context"
+	"google.golang.org/grpc/codes"
+)
+
+func TestSuccessfulCommitsBetween(t *testing.T) {
+	client := newCommitServiceClient(t)
+	from := []byte("498214de67004b1da3d820901307bed2a68a8ef6") // branch-merged
+	to := []byte("e63f41fe459e62e1228fcef60d7189127aeba95a")   // master
+	fakeHash := []byte("f63f41fe459e62e1228fcef60d7189127aeba95a")
+	fakeRef := []byte("non-existing-ref")
+	expectedCommits := []*pb.GitCommit{
+		{
+			Id:      "e63f41fe459e62e1228fcef60d7189127aeba95a",
+			Subject: []byte("Merge branch 'gitlab-test-usage-dev-testing-docs' into 'master'"),
+			Author: &pb.CommitAuthor{
+				Name:  []byte("Sean McGivern"),
+				Email: []byte("sean@mcgivern.me.uk"),
+				Date:  &timestamp.Timestamp{Seconds: 1491906794},
+			},
+			Committer: &pb.CommitAuthor{
+				Name:  []byte("Sean McGivern"),
+				Email: []byte("sean@mcgivern.me.uk"),
+				Date:  &timestamp.Timestamp{Seconds: 1491906794},
+			},
+		},
+		{
+			Id:      "4a24d82dbca5c11c61556f3b35ca472b7463187e",
+			Subject: []byte("Update README.md to include `Usage in testing and development`"),
+			Author: &pb.CommitAuthor{
+				Name:  []byte("Luke \"Jared\" Bennett"),
+				Email: []byte("lbennett@gitlab.com"),
+				Date:  &timestamp.Timestamp{Seconds: 1491905339},
+			},
+			Committer: &pb.CommitAuthor{
+				Name:  []byte("Luke \"Jared\" Bennett"),
+				Email: []byte("lbennett@gitlab.com"),
+				Date:  &timestamp.Timestamp{Seconds: 1491905339},
+			},
+		},
+		{
+			Id:      "b83d6e391c22777fca1ed3012fce84f633d7fed0",
+			Subject: []byte("Merge branch 'branch-merged' into 'master'"),
+			Author: &pb.CommitAuthor{
+				Name:  []byte("Job van der Voort"),
+				Email: []byte("job@gitlab.com"),
+				Date:  &timestamp.Timestamp{Seconds: 1474987066},
+			},
+			Committer: &pb.CommitAuthor{
+				Name:  []byte("Job van der Voort"),
+				Email: []byte("job@gitlab.com"),
+				Date:  &timestamp.Timestamp{Seconds: 1474987066},
+			},
+		},
+	}
+	testCases := []struct {
+		description     string
+		from            []byte
+		to              []byte
+		expectedCommits []*pb.GitCommit
+	}{
+		{
+			description:     "From hash to hash",
+			from:            from,
+			to:              to,
+			expectedCommits: expectedCommits,
+		},
+		{
+			description:     "From hash to ref",
+			from:            from,
+			to:              []byte("master"),
+			expectedCommits: expectedCommits,
+		},
+		{
+			description:     "From ref to hash",
+			from:            []byte("branch-merged"),
+			to:              to,
+			expectedCommits: expectedCommits,
+		},
+		{
+			description:     "From ref to ref",
+			from:            []byte("branch-merged"),
+			to:              []byte("master"),
+			expectedCommits: expectedCommits,
+		},
+		{
+			description:     "To hash doesn't exist",
+			from:            from,
+			to:              fakeHash,
+			expectedCommits: []*pb.GitCommit{},
+		},
+		{
+			description:     "From hash doesn't exist",
+			from:            fakeHash,
+			to:              to,
+			expectedCommits: []*pb.GitCommit{},
+		},
+		{
+			description:     "To ref doesn't exist",
+			from:            from,
+			to:              fakeRef,
+			expectedCommits: []*pb.GitCommit{},
+		},
+		{
+			description:     "From ref doesn't exist",
+			from:            fakeRef,
+			to:              to,
+			expectedCommits: []*pb.GitCommit{},
+		},
+	}
+	for _, tc := range testCases {
+		commits := []*pb.GitCommit{}
+		t.Logf("test case: %v", tc.description)
+		rpcRequest := pb.CommitsBetweenRequest{
+			Repository: testRepo, From: tc.from, To: tc.to,
+		}
+
+		c, err := client.CommitsBetween(context.Background(), &rpcRequest)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		for {
+			resp, err := c.Recv()
+			if err == io.EOF {
+				break
+			} else if err != nil {
+				t.Fatal(err)
+			}
+			commits = append(commits, resp.GetCommits()...)
+		}
+
+		for i, commit := range commits {
+			if !testhelper.CommitsEqual(commit, expectedCommits[i]) {
+				t.Fatalf("Expected commit\n%v\ngot\n%v", expectedCommits[i], commit)
+			}
+		}
+	}
+}
+
+func TestFailedCommitsBetweenRequest(t *testing.T) {
+	client := newCommitServiceClient(t)
+	invalidRepo := &pb.Repository{StorageName: "fake", RelativePath: "path"}
+	from := []byte("498214de67004b1da3d820901307bed2a68a8ef6")
+	to := []byte("e63f41fe459e62e1228fcef60d7189127aeba95a")
+
+	testCases := []struct {
+		description string
+		repository  *pb.Repository
+		from        []byte
+		to          []byte
+		code        codes.Code
+	}{
+		{
+			description: "Invalid repository",
+			repository:  invalidRepo,
+			from:        from,
+			to:          to,
+			code:        codes.InvalidArgument,
+		},
+		{
+			description: "Repository is nil",
+			repository:  nil,
+			from:        from,
+			to:          to,
+			code:        codes.InvalidArgument,
+		},
+		{
+			description: "From is empty",
+			repository:  testRepo,
+			from:        nil,
+			to:          to,
+			code:        codes.InvalidArgument,
+		},
+		{
+			description: "To is empty",
+			repository:  testRepo,
+			from:        from,
+			to:          nil,
+			code:        codes.InvalidArgument,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Logf("test case: %v", tc.description)
+		rpcRequest := pb.CommitsBetweenRequest{
+			Repository: tc.repository, From: tc.from, To: tc.to,
+		}
+
+		c, err := client.CommitsBetween(context.Background(), &rpcRequest)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		err = drainCommitsBetweenResponse(c)
+		testhelper.AssertGrpcError(t, err, tc.code, "")
+	}
+}
+
+func drainCommitsBetweenResponse(c pb.CommitService_CommitsBetweenClient) error {
+	var err error
+	for err == nil {
+		_, err = c.Recv()
+	}
+	return err
+}
diff --git a/internal/service/commit/server.go b/internal/service/commit/server.go
index d90448984..79f1b5e08 100644
--- a/internal/service/commit/server.go
+++ b/internal/service/commit/server.go
@@ -4,7 +4,7 @@ import pb "gitlab.com/gitlab-org/gitaly-proto/go"
 
 type server struct{}
 
-// NewServer creates a new instance of a grpc CommitServer
+// NewServer creates a new instance of a grpc CommitServiceServer
 func NewServer() pb.CommitServiceServer {
 	return &server{}
 }
diff --git a/internal/service/commit/testhelper_test.go b/internal/service/commit/testhelper_test.go
index 6ead8ea2a..0dc2f0cea 100644
--- a/internal/service/commit/testhelper_test.go
+++ b/internal/service/commit/testhelper_test.go
@@ -21,8 +21,9 @@ import (
 const scratchDir = "testdata/scratch"
 
 var (
-	serverSocketPath = path.Join(scratchDir, "gitaly.sock")
-	testRepo         *pb.Repository
+	serverSocketPath  = path.Join(scratchDir, "gitaly.sock")
+	serviceSocketPath = path.Join(scratchDir, "service.sock")
+	testRepo          *pb.Repository
 )
 
 func TestMain(m *testing.M) {
@@ -40,6 +41,13 @@ func TestMain(m *testing.M) {
 			os.Remove(serverSocketPath)
 		}()
 
+		os.Remove(serviceSocketPath)
+		service := runCommitServiceServer(m)
+		defer func() {
+			service.Stop()
+			os.Remove(serviceSocketPath)
+		}()
+
 		return m.Run()
 	}())
 }
@@ -59,6 +67,21 @@ func runCommitServer(m *testing.M) *grpc.Server {
 	return server
 }
 
+func runCommitServiceServer(m *testing.M) *grpc.Server {
+	server := grpc.NewServer()
+	listener, err := net.Listen("unix", serviceSocketPath)
+	if err != nil {
+		log.WithError(err).Fatal("failed to start server")
+	}
+
+	pb.RegisterCommitServiceServer(server, NewServer())
+	reflection.Register(server)
+
+	go server.Serve(listener)
+
+	return server
+}
+
 func newCommitClient(t *testing.T) pb.CommitClient {
 	connOpts := []grpc.DialOption{
 		grpc.WithInsecure(),
@@ -73,3 +96,18 @@ func newCommitClient(t *testing.T) pb.CommitClient {
 
 	return pb.NewCommitClient(conn)
 }
+
+func newCommitServiceClient(t *testing.T) pb.CommitServiceClient {
+	connOpts := []grpc.DialOption{
+		grpc.WithInsecure(),
+		grpc.WithDialer(func(addr string, _ time.Duration) (net.Conn, error) {
+			return net.Dial("unix", addr)
+		}),
+	}
+	conn, err := grpc.Dial(serviceSocketPath, connOpts...)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	return pb.NewCommitServiceClient(conn)
+}
diff --git a/internal/service/commit/util.go b/internal/service/commit/util.go
new file mode 100644
index 000000000..3e9261d6c
--- /dev/null
+++ b/internal/service/commit/util.go
@@ -0,0 +1,33 @@
+package commit
+
+import (
+	"bytes"
+
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+	"gitlab.com/gitlab-org/gitaly/internal/git"
+	"gitlab.com/gitlab-org/gitaly/internal/helper/lines"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+)
+
+func newCommitsBetweenWriter(stream pb.CommitService_CommitsBetweenServer) lines.Sender {
+	return func(refs [][]byte) error {
+		var commits []*pb.GitCommit
+
+		for _, ref := range refs {
+			elements := bytes.Split(ref, []byte("\x00"))
+			if len(elements) != 8 {
+				return grpc.Errorf(codes.Internal, "error parsing ref %q", ref)
+			}
+
+			commit, err := git.NewCommit(elements[0], elements[1], elements[2],
+				elements[3], elements[4], elements[5], elements[6], elements[7])
+			if err != nil {
+				return err
+			}
+
+			commits = append(commits, commit)
+		}
+		return stream.Send(&pb.CommitsBetweenResponse{Commits: commits})
+	}
+}
diff --git a/internal/service/ref/main_test.go b/internal/service/ref/main_test.go
index 0185a63f6..00e6116e0 100644
--- a/internal/service/ref/main_test.go
+++ b/internal/service/ref/main_test.go
@@ -10,6 +10,7 @@ import (
 	log "github.com/Sirupsen/logrus"
 
 	"gitlab.com/gitlab-org/gitaly/internal/helper"
+	"gitlab.com/gitlab-org/gitaly/internal/helper/lines"
 	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
 
 	"google.golang.org/grpc"
@@ -40,6 +41,10 @@ func TestMain(m *testing.M) {
 		log.Fatal(err)
 	}
 
+	// Use 100 bytes as the maximum message size to test that fragmenting the
+	// ref list works correctly
+	lines.MaxMsgSize = 100
+
 	os.Exit(func() int {
 		return m.Run()
 	}())
@@ -53,8 +58,7 @@ func runRefServer(t *testing.T) *grpc.Server {
 		t.Fatal(err)
 	}
 
-	// Use 100 bytes as the maximum message size to test that fragmenting the ref list works correctly
-	pb.RegisterRefServer(grpcServer, renameadapter.NewRefAdapter(&server{MaxMsgSize: 100}))
+	pb.RegisterRefServer(grpcServer, renameadapter.NewRefAdapter(&server{}))
 	reflection.Register(grpcServer)
 
 	go grpcServer.Serve(listener)
diff --git a/internal/service/ref/refs.go b/internal/service/ref/refs.go
index 5e0818816..97d63b5fc 100644
--- a/internal/service/ref/refs.go
+++ b/internal/service/ref/refs.go
@@ -4,7 +4,6 @@ import (
 	"bufio"
 	"bytes"
 	"fmt"
-	"io"
 	"strings"
 
 	log "github.com/Sirupsen/logrus"
@@ -13,6 +12,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"
 	"golang.org/x/net/context"
 )
 
@@ -23,20 +23,7 @@ var (
 	headReference   = _headReference
 )
 
-func handleGitCommand(w refsWriter, r io.Reader) error {
-	scanner := bufio.NewScanner(r)
-	for scanner.Scan() {
-		if err := w.AddRef(scanner.Bytes()); err != nil {
-			return err
-		}
-	}
-	if err := scanner.Err(); err != nil {
-		return err
-	}
-	return w.Flush()
-}
-
-func findRefs(writer refsWriter, repo *pb.Repository, pattern string, args ...string) error {
+func findRefs(writer lines.Sender, repo *pb.Repository, pattern string, args ...string) error {
 	repoPath, err := helper.GetRepoPath(repo)
 	if err != nil {
 		return err
@@ -61,7 +48,7 @@ func findRefs(writer refsWriter, repo *pb.Repository, pattern string, args ...st
 	}
 	defer cmd.Kill()
 
-	if err := handleGitCommand(writer, cmd); err != nil {
+	if err := lines.Send(cmd, writer); err != nil {
 		return err
 	}
 
@@ -70,12 +57,12 @@ func findRefs(writer refsWriter, repo *pb.Repository, pattern string, args ...st
 
 // FindAllBranchNames creates a stream of ref names for all branches in the given repository
 func (s *server) FindAllBranchNames(in *pb.FindAllBranchNamesRequest, stream pb.RefService_FindAllBranchNamesServer) error {
-	return findRefs(newFindAllBranchNamesWriter(stream, s.MaxMsgSize), in.Repository, "refs/heads")
+	return findRefs(newFindAllBranchNamesWriter(stream), in.Repository, "refs/heads")
 }
 
 // FindAllTagNames creates a stream of ref names for all tags in the given repository
 func (s *server) FindAllTagNames(in *pb.FindAllTagNamesRequest, stream pb.RefService_FindAllTagNamesServer) error {
-	return findRefs(newFindAllTagNamesWriter(stream, s.MaxMsgSize), in.Repository, "refs/tags")
+	return findRefs(newFindAllTagNamesWriter(stream), in.Repository, "refs/tags")
 }
 
 func _findBranchNames(repoPath string) ([][]byte, error) {
@@ -89,7 +76,7 @@ func _findBranchNames(repoPath string) ([][]byte, error) {
 
 	scanner := bufio.NewScanner(cmd)
 	for scanner.Scan() {
-		names, _ = appendRef(names, scanner.Bytes())
+		names, _ = lines.CopyAndAppend(names, scanner.Bytes())
 	}
 	if err := scanner.Err(); err != nil {
 		return nil, fmt.Errorf("reading standard input: %v", err)
@@ -208,7 +195,7 @@ func (s *server) FindLocalBranches(in *pb.FindLocalBranchesRequest, stream pb.Re
 	// %00 inserts the null character into the output (see for-each-ref docs)
 	formatFlag := "--format=" + strings.Join(localBranchFormatFields, "%00")
 	sortFlag := "--sort=" + parseSortKey(in.GetSortBy())
-	writer := newFindLocalBranchesWriter(stream, s.MaxMsgSize)
+	writer := newFindLocalBranchesWriter(stream)
 
 	return findRefs(writer, in.Repository, "refs/heads", formatFlag, sortFlag)
 }
diff --git a/internal/service/ref/refs_test.go b/internal/service/ref/refs_test.go
index 9210adef9..db169f546 100644
--- a/internal/service/ref/refs_test.go
+++ b/internal/service/ref/refs_test.go
@@ -8,6 +8,7 @@ import (
 
 	"github.com/golang/protobuf/ptypes/timestamp"
 	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
 	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
@@ -363,23 +364,10 @@ func localBranches() []*pb.FindLocalBranchResponse {
 	}
 }
 
-func authorsEqual(a *pb.FindLocalBranchCommitAuthor, b *pb.FindLocalBranchCommitAuthor) bool {
-	return bytes.Equal(a.Name, b.Name) &&
-		bytes.Equal(a.Email, b.Email) &&
-		a.Date.Seconds == b.Date.Seconds
-}
-
-func branchesEqual(a *pb.FindLocalBranchResponse, b *pb.FindLocalBranchResponse) bool {
-	return a.CommitId == b.CommitId &&
-		bytes.Equal(a.CommitSubject, b.CommitSubject) &&
-		authorsEqual(a.CommitAuthor, b.CommitAuthor) &&
-		authorsEqual(a.CommitCommitter, b.CommitCommitter)
-}
-
 func validateContainsBranch(t *testing.T, branches []*pb.FindLocalBranchResponse, branch *pb.FindLocalBranchResponse) {
 	for _, b := range branches {
 		if bytes.Equal(branch.Name, b.Name) {
-			if !branchesEqual(branch, b) {
+			if !testhelper.FindLocalBranchResponsesEqual(branch, b) {
 				t.Fatalf("Expected branch\n%v\ngot\n%v", branch, b)
 			}
 			return // Found the branch and it maches. Success!
diff --git a/internal/service/ref/server.go b/internal/service/ref/server.go
index ea400f9a9..217c0200e 100644
--- a/internal/service/ref/server.go
+++ b/internal/service/ref/server.go
@@ -2,13 +2,9 @@ package ref
 
 import pb "gitlab.com/gitlab-org/gitaly-proto/go"
 
-const maxMsgSize = 1024
-
-type server struct {
-	MaxMsgSize int
-}
+type server struct{}
 
 // NewServer creates a new instance of a grpc RefServer
 func NewServer() pb.RefServiceServer {
-	return &server{MaxMsgSize: maxMsgSize}
+	return &server{}
 }
diff --git a/internal/service/ref/util.go b/internal/service/ref/util.go
index e3ab44615..f60da17c8 100644
--- a/internal/service/ref/util.go
+++ b/internal/service/ref/util.go
@@ -2,10 +2,10 @@ package ref
 
 import (
 	"bytes"
-	"time"
 
-	"github.com/golang/protobuf/ptypes/timestamp"
 	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+	"gitlab.com/gitlab-org/gitaly/internal/git"
+	"gitlab.com/gitlab-org/gitaly/internal/helper/lines"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 )
@@ -16,136 +16,60 @@ var localBranchFormatFields = []string{
 	"%(committeremail)", "%(committerdate:iso-strict)",
 }
 
-func appendRef(refs [][]byte, p []byte) ([][]byte, int) {
-	ref := make([]byte, len(p))
-	size := copy(ref, p)
-	return append(refs, ref), size
-}
-
-type refsSender interface {
-	sendRefs([][]byte) error
-}
-
-type refsWriter struct {
-	refsSender
-	MaxMsgSize int
-	refsSize   int
-	refs       [][]byte
-}
-
-func (w *refsWriter) Flush() error {
-	if len(w.refs) == 0 { // No message to send, just return
-		return nil
-	}
-
-	if err := w.refsSender.sendRefs(w.refs); err != nil {
-		return err
-	}
-
-	// Reset the message
-	w.refs = nil
-	w.refsSize = 0
-
-	return nil
-}
-
-func (w *refsWriter) AddRef(p []byte) error {
-	refs, size := appendRef(w.refs, p)
-	w.refsSize += size
-	w.refs = refs
-
-	if w.refsSize > w.MaxMsgSize {
-		return w.Flush()
-	}
-
-	return nil
-}
-
-type branchesSender struct {
-	stream pb.Ref_FindAllBranchNamesServer
-}
-
-func (w branchesSender) sendRefs(refs [][]byte) error {
-	return w.stream.Send(&pb.FindAllBranchNamesResponse{Names: refs})
-}
-
-type tagsSender struct {
-	stream pb.Ref_FindAllTagNamesServer
-}
-
-func (w tagsSender) sendRefs(refs [][]byte) error {
-	return w.stream.Send(&pb.FindAllTagNamesResponse{Names: refs})
-}
-
-type localBranchesSender struct {
-	stream pb.Ref_FindLocalBranchesServer
-}
-
 func buildBranch(elements [][]byte) (*pb.FindLocalBranchResponse, error) {
-	authorDate, err := time.Parse(time.RFC3339, string(elements[5]))
-	if err != nil {
-		return nil, err
+	target, err := git.NewCommit(elements[1], elements[2], elements[3],
+		elements[4], elements[5], elements[6], elements[7], elements[8])
+	author := pb.FindLocalBranchCommitAuthor{
+		Name:  target.Author.Name,
+		Email: target.Author.Email,
+		Date:  target.Author.Date,
+	}
+	committer := pb.FindLocalBranchCommitAuthor{
+		Name:  target.Committer.Name,
+		Email: target.Committer.Email,
+		Date:  target.Committer.Date,
 	}
 
-	committerDate, err := time.Parse(time.RFC3339, string(elements[8]))
 	if err != nil {
 		return nil, err
 	}
 
-	author := pb.FindLocalBranchCommitAuthor{
-		Name:  elements[3],
-		Email: elements[4],
-		Date:  &timestamp.Timestamp{Seconds: authorDate.Unix()},
-	}
-	committer := pb.FindLocalBranchCommitAuthor{
-		Name:  elements[6],
-		Email: elements[7],
-		Date:  &timestamp.Timestamp{Seconds: committerDate.Unix()},
-	}
-
 	return &pb.FindLocalBranchResponse{
 		Name:            elements[0],
-		CommitId:        string(elements[1]),
-		CommitSubject:   elements[2],
+		CommitId:        target.Id,
+		CommitSubject:   target.Subject,
 		CommitAuthor:    &author,
 		CommitCommitter: &committer,
 	}, nil
 }
 
-func (w localBranchesSender) sendRefs(refs [][]byte) error {
-	var branches []*pb.FindLocalBranchResponse
-
-	for _, ref := range refs {
-		elements := bytes.Split(ref, []byte("\x00"))
-		if len(elements) != 9 {
-			return grpc.Errorf(codes.Internal, "error parsing ref %q", ref)
-		}
-		branch, err := buildBranch(elements)
-		if err != nil {
-			return err
-		}
-		branches = append(branches, branch)
+func newFindAllBranchNamesWriter(stream pb.Ref_FindAllBranchNamesServer) lines.Sender {
+	return func(refs [][]byte) error {
+		return stream.Send(&pb.FindAllBranchNamesResponse{Names: refs})
 	}
-	return w.stream.Send(&pb.FindLocalBranchesResponse{Branches: branches})
 }
 
-func newFindAllBranchNamesWriter(stream pb.Ref_FindAllBranchNamesServer, maxMsgSize int) refsWriter {
-	return refsWriter{
-		refsSender: branchesSender{stream},
-		MaxMsgSize: maxMsgSize,
+func newFindAllTagNamesWriter(stream pb.Ref_FindAllTagNamesServer) lines.Sender {
+	return func(refs [][]byte) error {
+		return stream.Send(&pb.FindAllTagNamesResponse{Names: refs})
 	}
 }
 
-func newFindAllTagNamesWriter(stream pb.Ref_FindAllTagNamesServer, maxMsgSize int) refsWriter {
-	return refsWriter{
-		refsSender: tagsSender{stream},
-		MaxMsgSize: maxMsgSize,
-	}
-}
-
-func newFindLocalBranchesWriter(stream pb.Ref_FindLocalBranchesServer, maxMsgSize int) refsWriter {
-	return refsWriter{
-		refsSender: localBranchesSender{stream},
-		MaxMsgSize: maxMsgSize,
+func newFindLocalBranchesWriter(stream pb.Ref_FindLocalBranchesServer) lines.Sender {
+	return func(refs [][]byte) error {
+		var branches []*pb.FindLocalBranchResponse
+
+		for _, ref := range refs {
+			elements := bytes.Split(ref, []byte("\x00"))
+			if len(elements) != 9 {
+				return grpc.Errorf(codes.Internal, "error parsing ref %q", ref)
+			}
+			branch, err := buildBranch(elements)
+			if err != nil {
+				return err
+			}
+			branches = append(branches, branch)
+		}
+		return stream.Send(&pb.FindLocalBranchesResponse{Branches: branches})
 	}
 }
diff --git a/internal/testhelper/testhelper.go b/internal/testhelper/testhelper.go
index 15107681c..15e484bf0 100644
--- a/internal/testhelper/testhelper.go
+++ b/internal/testhelper/testhelper.go
@@ -1,6 +1,7 @@
 package testhelper
 
 import (
+	"bytes"
 	"io"
 	"io/ioutil"
 	"os"
@@ -108,3 +109,33 @@ func MustRunCommand(t *testing.T, stdin io.Reader, name string, args ...string)
 
 	return output
 }
+
+// AuthorsEqual tests if two `CommitAuthor`s are equal
+func AuthorsEqual(a *pb.CommitAuthor, b *pb.CommitAuthor) bool {
+	return bytes.Equal(a.Name, b.Name) &&
+		bytes.Equal(a.Email, b.Email) &&
+		a.Date.Seconds == b.Date.Seconds
+}
+
+// CommitsEqual tests if two `GitCommit`s are equal
+func CommitsEqual(a *pb.GitCommit, b *pb.GitCommit) bool {
+	return a.Id == b.Id &&
+		bytes.Equal(a.Subject, b.Subject) &&
+		AuthorsEqual(a.Author, b.Author) &&
+		AuthorsEqual(a.Committer, b.Committer)
+}
+
+// FindLocalBranchCommitAuthorsEqual tests if two `FindLocalBranchCommitAuthor`s are equal
+func FindLocalBranchCommitAuthorsEqual(a *pb.FindLocalBranchCommitAuthor, b *pb.FindLocalBranchCommitAuthor) bool {
+	return bytes.Equal(a.Name, b.Name) &&
+		bytes.Equal(a.Email, b.Email) &&
+		a.Date.Seconds == b.Date.Seconds
+}
+
+// FindLocalBranchResponsesEqual tests if two `FindLocalBranchResponse`s are equal
+func FindLocalBranchResponsesEqual(a *pb.FindLocalBranchResponse, b *pb.FindLocalBranchResponse) bool {
+	return a.CommitId == b.CommitId &&
+		bytes.Equal(a.CommitSubject, b.CommitSubject) &&
+		FindLocalBranchCommitAuthorsEqual(a.CommitAuthor, b.CommitAuthor) &&
+		FindLocalBranchCommitAuthorsEqual(a.CommitCommitter, b.CommitCommitter)
+}
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION
index 78bc1abd1..ac454c6a1 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION
@@ -1 +1 @@
-0.10.0
+0.12.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
new file mode 100644
index 000000000..14080d781
--- /dev/null
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/blob.pb.go
@@ -0,0 +1,261 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: blob.proto
+
+/*
+Package gitaly is a generated protocol buffer package.
+
+It is generated from these files:
+	blob.proto
+	commit.proto
+	deprecated-services.proto
+	diff.proto
+	notifications.proto
+	ref.proto
+	repository-service.proto
+	shared.proto
+	smarthttp.proto
+	ssh.proto
+
+It has these top-level messages:
+	GetBlobRequest
+	GetBlobResponse
+	CommitIsAncestorRequest
+	CommitIsAncestorResponse
+	TreeEntryRequest
+	TreeEntryResponse
+	CommitsBetweenRequest
+	CommitsBetweenResponse
+	CommitDiffRequest
+	CommitDiffResponse
+	CommitDeltaRequest
+	CommitDelta
+	CommitDeltaResponse
+	PostReceiveRequest
+	PostReceiveResponse
+	FindDefaultBranchNameRequest
+	FindDefaultBranchNameResponse
+	FindAllBranchNamesRequest
+	FindAllBranchNamesResponse
+	FindAllTagNamesRequest
+	FindAllTagNamesResponse
+	FindRefNameRequest
+	FindRefNameResponse
+	FindLocalBranchesRequest
+	FindLocalBranchesResponse
+	FindLocalBranchResponse
+	FindLocalBranchCommitAuthor
+	RepositoryExistsRequest
+	RepositoryExistsResponse
+	Repository
+	GitCommit
+	CommitAuthor
+	ExitStatus
+	InfoRefsRequest
+	InfoRefsResponse
+	PostUploadPackRequest
+	PostUploadPackResponse
+	PostReceivePackRequest
+	PostReceivePackResponse
+	SSHUploadPackRequest
+	SSHUploadPackResponse
+	SSHReceivePackRequest
+	SSHReceivePackResponse
+*/
+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
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type GetBlobRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	Oid        string      `protobuf:"bytes,2,opt,name=oid" json:"oid,omitempty"`
+}
+
+func (m *GetBlobRequest) Reset()                    { *m = GetBlobRequest{} }
+func (m *GetBlobRequest) String() string            { return proto.CompactTextString(m) }
+func (*GetBlobRequest) ProtoMessage()               {}
+func (*GetBlobRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *GetBlobRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *GetBlobRequest) GetOid() string {
+	if m != nil {
+		return m.Oid
+	}
+	return ""
+}
+
+type GetBlobResponse struct {
+	Size int64  `protobuf:"varint,1,opt,name=size" json:"size,omitempty"`
+	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *GetBlobResponse) Reset()                    { *m = GetBlobResponse{} }
+func (m *GetBlobResponse) String() string            { return proto.CompactTextString(m) }
+func (*GetBlobResponse) ProtoMessage()               {}
+func (*GetBlobResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *GetBlobResponse) GetSize() int64 {
+	if m != nil {
+		return m.Size
+	}
+	return 0
+}
+
+func (m *GetBlobResponse) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*GetBlobRequest)(nil), "gitaly.GetBlobRequest")
+	proto.RegisterType((*GetBlobResponse)(nil), "gitaly.GetBlobResponse")
+}
+
+// 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 BlobService service
+
+type BlobServiceClient interface {
+	// GetBlob returns the contents of a blob object referenced by its object
+	// ID. We use a stream to return a chunked arbitrarily large binary
+	// response
+	GetBlob(ctx context.Context, in *GetBlobRequest, opts ...grpc.CallOption) (BlobService_GetBlobClient, error)
+}
+
+type blobServiceClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewBlobServiceClient(cc *grpc.ClientConn) BlobServiceClient {
+	return &blobServiceClient{cc}
+}
+
+func (c *blobServiceClient) GetBlob(ctx context.Context, in *GetBlobRequest, opts ...grpc.CallOption) (BlobService_GetBlobClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_BlobService_serviceDesc.Streams[0], c.cc, "/gitaly.BlobService/GetBlob", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &blobServiceGetBlobClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type BlobService_GetBlobClient interface {
+	Recv() (*GetBlobResponse, error)
+	grpc.ClientStream
+}
+
+type blobServiceGetBlobClient struct {
+	grpc.ClientStream
+}
+
+func (x *blobServiceGetBlobClient) Recv() (*GetBlobResponse, error) {
+	m := new(GetBlobResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Server API for BlobService service
+
+type BlobServiceServer interface {
+	// GetBlob returns the contents of a blob object referenced by its object
+	// ID. We use a stream to return a chunked arbitrarily large binary
+	// response
+	GetBlob(*GetBlobRequest, BlobService_GetBlobServer) error
+}
+
+func RegisterBlobServiceServer(s *grpc.Server, srv BlobServiceServer) {
+	s.RegisterService(&_BlobService_serviceDesc, srv)
+}
+
+func _BlobService_GetBlob_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(GetBlobRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(BlobServiceServer).GetBlob(m, &blobServiceGetBlobServer{stream})
+}
+
+type BlobService_GetBlobServer interface {
+	Send(*GetBlobResponse) error
+	grpc.ServerStream
+}
+
+type blobServiceGetBlobServer struct {
+	grpc.ServerStream
+}
+
+func (x *blobServiceGetBlobServer) Send(m *GetBlobResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+var _BlobService_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "gitaly.BlobService",
+	HandlerType: (*BlobServiceServer)(nil),
+	Methods:     []grpc.MethodDesc{},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "GetBlob",
+			Handler:       _BlobService_GetBlob_Handler,
+			ServerStreams: true,
+		},
+	},
+	Metadata: "blob.proto",
+}
+
+func init() { proto.RegisterFile("blob.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 198 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x4a, 0xca, 0xc9, 0x4f,
+	0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x4b, 0xcf, 0x2c, 0x49, 0xcc, 0xa9, 0x94, 0xe2,
+	0x29, 0xce, 0x48, 0x2c, 0x4a, 0x4d, 0x81, 0x88, 0x2a, 0x85, 0x71, 0xf1, 0xb9, 0xa7, 0x96, 0x38,
+	0xe5, 0xe4, 0x27, 0x05, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97, 0x08, 0x19, 0x71, 0x71, 0x15, 0xa5,
+	0x16, 0xe4, 0x17, 0x67, 0x96, 0xe4, 0x17, 0x55, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x1b, 0x09,
+	0xe9, 0x41, 0x34, 0xeb, 0x05, 0xc1, 0x65, 0x82, 0x90, 0x54, 0x09, 0x09, 0x70, 0x31, 0xe7, 0x67,
+	0xa6, 0x48, 0x30, 0x29, 0x30, 0x6a, 0x70, 0x06, 0x81, 0x98, 0x4a, 0x96, 0x5c, 0xfc, 0x70, 0x73,
+	0x8b, 0x0b, 0xf2, 0xf3, 0x8a, 0x53, 0x85, 0x84, 0xb8, 0x58, 0x8a, 0x33, 0xab, 0x52, 0xc1, 0x46,
+	0x32, 0x07, 0x81, 0xd9, 0x20, 0xb1, 0x94, 0xc4, 0x92, 0x44, 0xb0, 0x4e, 0x9e, 0x20, 0x30, 0xdb,
+	0xc8, 0x97, 0x8b, 0x1b, 0xa4, 0x2f, 0x38, 0xb5, 0xa8, 0x2c, 0x33, 0x39, 0x55, 0xc8, 0x8e, 0x8b,
+	0x1d, 0x6a, 0x92, 0x90, 0x18, 0xcc, 0x19, 0xa8, 0x4e, 0x96, 0x12, 0xc7, 0x10, 0x87, 0x58, 0xa9,
+	0xc4, 0x60, 0xc0, 0x98, 0xc4, 0x06, 0xf6, 0xa8, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0xe0, 0xec,
+	0x47, 0x7e, 0x0c, 0x01, 0x00, 0x00,
+}
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/commit.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/commit.pb.go
index f6721a336..0399593ab 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/commit.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/commit.pb.go
@@ -1,59 +1,6 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // source: commit.proto
 
-/*
-Package gitaly is a generated protocol buffer package.
-
-It is generated from these files:
-	commit.proto
-	deprecated-services.proto
-	diff.proto
-	notifications.proto
-	ref.proto
-	repository-service.proto
-	shared.proto
-	smarthttp.proto
-	ssh.proto
-
-It has these top-level messages:
-	CommitIsAncestorRequest
-	CommitIsAncestorResponse
-	TreeEntryRequest
-	TreeEntryResponse
-	CommitDiffRequest
-	CommitDiffResponse
-	CommitDeltaRequest
-	CommitDelta
-	CommitDeltaResponse
-	PostReceiveRequest
-	PostReceiveResponse
-	FindDefaultBranchNameRequest
-	FindDefaultBranchNameResponse
-	FindAllBranchNamesRequest
-	FindAllBranchNamesResponse
-	FindAllTagNamesRequest
-	FindAllTagNamesResponse
-	FindRefNameRequest
-	FindRefNameResponse
-	FindLocalBranchesRequest
-	FindLocalBranchesResponse
-	FindLocalBranchResponse
-	FindLocalBranchCommitAuthor
-	RepositoryExistsRequest
-	RepositoryExistsResponse
-	Repository
-	ExitStatus
-	InfoRefsRequest
-	InfoRefsResponse
-	PostUploadPackRequest
-	PostUploadPackResponse
-	PostReceivePackRequest
-	PostReceivePackResponse
-	SSHUploadPackRequest
-	SSHUploadPackResponse
-	SSHReceivePackRequest
-	SSHReceivePackResponse
-*/
 package gitaly
 
 import proto "github.com/golang/protobuf/proto"
@@ -70,12 +17,6 @@ var _ = proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
 type TreeEntryResponse_ObjectType int32
 
 const (
@@ -102,7 +43,7 @@ func (x TreeEntryResponse_ObjectType) String() string {
 	return proto.EnumName(TreeEntryResponse_ObjectType_name, int32(x))
 }
 func (TreeEntryResponse_ObjectType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor0, []int{3, 0}
+	return fileDescriptor1, []int{3, 0}
 }
 
 type CommitIsAncestorRequest struct {
@@ -114,7 +55,7 @@ type CommitIsAncestorRequest struct {
 func (m *CommitIsAncestorRequest) Reset()                    { *m = CommitIsAncestorRequest{} }
 func (m *CommitIsAncestorRequest) String() string            { return proto.CompactTextString(m) }
 func (*CommitIsAncestorRequest) ProtoMessage()               {}
-func (*CommitIsAncestorRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+func (*CommitIsAncestorRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
 
 func (m *CommitIsAncestorRequest) GetRepository() *Repository {
 	if m != nil {
@@ -144,7 +85,7 @@ type CommitIsAncestorResponse struct {
 func (m *CommitIsAncestorResponse) Reset()                    { *m = CommitIsAncestorResponse{} }
 func (m *CommitIsAncestorResponse) String() string            { return proto.CompactTextString(m) }
 func (*CommitIsAncestorResponse) ProtoMessage()               {}
-func (*CommitIsAncestorResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+func (*CommitIsAncestorResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
 
 func (m *CommitIsAncestorResponse) GetValue() bool {
 	if m != nil {
@@ -163,7 +104,7 @@ type TreeEntryRequest struct {
 func (m *TreeEntryRequest) Reset()                    { *m = TreeEntryRequest{} }
 func (m *TreeEntryRequest) String() string            { return proto.CompactTextString(m) }
 func (*TreeEntryRequest) ProtoMessage()               {}
-func (*TreeEntryRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+func (*TreeEntryRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} }
 
 func (m *TreeEntryRequest) GetRepository() *Repository {
 	if m != nil {
@@ -204,7 +145,7 @@ type TreeEntryResponse struct {
 func (m *TreeEntryResponse) Reset()                    { *m = TreeEntryResponse{} }
 func (m *TreeEntryResponse) String() string            { return proto.CompactTextString(m) }
 func (*TreeEntryResponse) ProtoMessage()               {}
-func (*TreeEntryResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+func (*TreeEntryResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} }
 
 func (m *TreeEntryResponse) GetType() TreeEntryResponse_ObjectType {
 	if m != nil {
@@ -241,11 +182,61 @@ func (m *TreeEntryResponse) GetData() []byte {
 	return nil
 }
 
+type CommitsBetweenRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	From       []byte      `protobuf:"bytes,2,opt,name=from,proto3" json:"from,omitempty"`
+	To         []byte      `protobuf:"bytes,3,opt,name=to,proto3" json:"to,omitempty"`
+}
+
+func (m *CommitsBetweenRequest) Reset()                    { *m = CommitsBetweenRequest{} }
+func (m *CommitsBetweenRequest) String() string            { return proto.CompactTextString(m) }
+func (*CommitsBetweenRequest) ProtoMessage()               {}
+func (*CommitsBetweenRequest) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{4} }
+
+func (m *CommitsBetweenRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *CommitsBetweenRequest) GetFrom() []byte {
+	if m != nil {
+		return m.From
+	}
+	return nil
+}
+
+func (m *CommitsBetweenRequest) GetTo() []byte {
+	if m != nil {
+		return m.To
+	}
+	return nil
+}
+
+type CommitsBetweenResponse struct {
+	Commits []*GitCommit `protobuf:"bytes,1,rep,name=commits" json:"commits,omitempty"`
+}
+
+func (m *CommitsBetweenResponse) Reset()                    { *m = CommitsBetweenResponse{} }
+func (m *CommitsBetweenResponse) String() string            { return proto.CompactTextString(m) }
+func (*CommitsBetweenResponse) ProtoMessage()               {}
+func (*CommitsBetweenResponse) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{5} }
+
+func (m *CommitsBetweenResponse) GetCommits() []*GitCommit {
+	if m != nil {
+		return m.Commits
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*CommitIsAncestorRequest)(nil), "gitaly.CommitIsAncestorRequest")
 	proto.RegisterType((*CommitIsAncestorResponse)(nil), "gitaly.CommitIsAncestorResponse")
 	proto.RegisterType((*TreeEntryRequest)(nil), "gitaly.TreeEntryRequest")
 	proto.RegisterType((*TreeEntryResponse)(nil), "gitaly.TreeEntryResponse")
+	proto.RegisterType((*CommitsBetweenRequest)(nil), "gitaly.CommitsBetweenRequest")
+	proto.RegisterType((*CommitsBetweenResponse)(nil), "gitaly.CommitsBetweenResponse")
 	proto.RegisterEnum("gitaly.TreeEntryResponse_ObjectType", TreeEntryResponse_ObjectType_name, TreeEntryResponse_ObjectType_value)
 }
 
@@ -262,6 +253,7 @@ const _ = grpc.SupportPackageIsVersion4
 type CommitServiceClient interface {
 	CommitIsAncestor(ctx context.Context, in *CommitIsAncestorRequest, opts ...grpc.CallOption) (*CommitIsAncestorResponse, error)
 	TreeEntry(ctx context.Context, in *TreeEntryRequest, opts ...grpc.CallOption) (CommitService_TreeEntryClient, error)
+	CommitsBetween(ctx context.Context, in *CommitsBetweenRequest, opts ...grpc.CallOption) (CommitService_CommitsBetweenClient, error)
 }
 
 type commitServiceClient struct {
@@ -313,11 +305,44 @@ func (x *commitServiceTreeEntryClient) Recv() (*TreeEntryResponse, error) {
 	return m, nil
 }
 
+func (c *commitServiceClient) CommitsBetween(ctx context.Context, in *CommitsBetweenRequest, opts ...grpc.CallOption) (CommitService_CommitsBetweenClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_CommitService_serviceDesc.Streams[1], c.cc, "/gitaly.CommitService/CommitsBetween", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &commitServiceCommitsBetweenClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type CommitService_CommitsBetweenClient interface {
+	Recv() (*CommitsBetweenResponse, error)
+	grpc.ClientStream
+}
+
+type commitServiceCommitsBetweenClient struct {
+	grpc.ClientStream
+}
+
+func (x *commitServiceCommitsBetweenClient) Recv() (*CommitsBetweenResponse, error) {
+	m := new(CommitsBetweenResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // Server API for CommitService service
 
 type CommitServiceServer interface {
 	CommitIsAncestor(context.Context, *CommitIsAncestorRequest) (*CommitIsAncestorResponse, error)
 	TreeEntry(*TreeEntryRequest, CommitService_TreeEntryServer) error
+	CommitsBetween(*CommitsBetweenRequest, CommitService_CommitsBetweenServer) error
 }
 
 func RegisterCommitServiceServer(s *grpc.Server, srv CommitServiceServer) {
@@ -363,6 +388,27 @@ func (x *commitServiceTreeEntryServer) Send(m *TreeEntryResponse) error {
 	return x.ServerStream.SendMsg(m)
 }
 
+func _CommitService_CommitsBetween_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(CommitsBetweenRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(CommitServiceServer).CommitsBetween(m, &commitServiceCommitsBetweenServer{stream})
+}
+
+type CommitService_CommitsBetweenServer interface {
+	Send(*CommitsBetweenResponse) error
+	grpc.ServerStream
+}
+
+type commitServiceCommitsBetweenServer struct {
+	grpc.ServerStream
+}
+
+func (x *commitServiceCommitsBetweenServer) Send(m *CommitsBetweenResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
 var _CommitService_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "gitaly.CommitService",
 	HandlerType: (*CommitServiceServer)(nil),
@@ -378,38 +424,48 @@ var _CommitService_serviceDesc = grpc.ServiceDesc{
 			Handler:       _CommitService_TreeEntry_Handler,
 			ServerStreams: true,
 		},
+		{
+			StreamName:    "CommitsBetween",
+			Handler:       _CommitService_CommitsBetween_Handler,
+			ServerStreams: true,
+		},
 	},
 	Metadata: "commit.proto",
 }
 
-func init() { proto.RegisterFile("commit.proto", fileDescriptor0) }
-
-var fileDescriptor0 = []byte{
-	// 410 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x92, 0xc1, 0x6a, 0xdb, 0x40,
-	0x10, 0x86, 0xbd, 0x91, 0xed, 0x38, 0x13, 0xb7, 0xa8, 0x43, 0xa1, 0x8a, 0x2f, 0x31, 0xa2, 0x07,
-	0x9f, 0x44, 0x50, 0x29, 0xf4, 0x9a, 0xa4, 0xa6, 0x08, 0x1a, 0x0c, 0x5b, 0x41, 0x8f, 0x45, 0x91,
-	0x86, 0x7a, 0x8b, 0xa4, 0x55, 0x77, 0x37, 0x06, 0xf5, 0x0d, 0x0a, 0x7d, 0x96, 0x3e, 0x4c, 0x9f,
-	0xa8, 0xec, 0x6e, 0xac, 0x86, 0xa6, 0x3e, 0xf5, 0xf6, 0xcf, 0xcc, 0xaf, 0xd1, 0xb7, 0xff, 0x2e,
-	0xcc, 0x4b, 0xd9, 0x34, 0xc2, 0x24, 0x9d, 0x92, 0x46, 0xe2, 0xf4, 0xb3, 0x30, 0x45, 0xdd, 0x2f,
-	0xe6, 0x7a, 0x5b, 0x28, 0xaa, 0x7c, 0x37, 0xfe, 0xce, 0xe0, 0xc5, 0xb5, 0xb3, 0x65, 0xfa, 0xb2,
-	0x2d, 0x49, 0x1b, 0xa9, 0x38, 0x7d, 0xbd, 0x23, 0x6d, 0x30, 0x05, 0x50, 0xd4, 0x49, 0x2d, 0x8c,
-	0x54, 0x7d, 0xc4, 0x96, 0x6c, 0x75, 0x9a, 0x62, 0xe2, 0xd7, 0x24, 0x7c, 0x98, 0xf0, 0x07, 0x2e,
-	0x3c, 0x87, 0xd3, 0xe2, 0x7e, 0xcd, 0x27, 0x51, 0x45, 0x47, 0x4b, 0xb6, 0x3a, 0xe1, 0xb0, 0x6f,
-	0x65, 0x15, 0x9e, 0xc1, 0xac, 0xdc, 0x8a, 0xba, 0xb2, 0xd3, 0xc0, 0x4d, 0x8f, 0x5d, 0x9d, 0x55,
-	0xf1, 0x05, 0x44, 0x8f, 0x51, 0x74, 0x27, 0x5b, 0x4d, 0xf8, 0x1c, 0x26, 0xbb, 0xa2, 0xbe, 0x23,
-	0x87, 0x31, 0xe3, 0xbe, 0x88, 0x7f, 0x30, 0x08, 0x73, 0x45, 0xb4, 0x6e, 0x8d, 0xea, 0xff, 0x07,
-	0x7b, 0x01, 0x33, 0x45, 0x3b, 0xa1, 0x85, 0x6c, 0x1d, 0xf3, 0x9c, 0x0f, 0x35, 0x22, 0x8c, 0xbb,
-	0xc2, 0x6c, 0x1d, 0xed, 0x9c, 0x3b, 0x6d, 0x71, 0x6a, 0xd1, 0x08, 0x13, 0x8d, 0x97, 0x6c, 0x15,
-	0x70, 0x5f, 0xc4, 0xbf, 0x18, 0x3c, 0x7b, 0x80, 0x73, 0x8f, 0xfe, 0x06, 0xc6, 0xa6, 0xef, 0x3c,
-	0xf9, 0xd3, 0xf4, 0xe5, 0x9e, 0xe4, 0x91, 0x31, 0xd9, 0xdc, 0x7e, 0xa1, 0xd2, 0xe4, 0x7d, 0x47,
-	0xdc, 0x7d, 0x81, 0x21, 0x04, 0x72, 0x08, 0xd1, 0x4a, 0xcb, 0xa2, 0xc5, 0x37, 0x72, 0x2c, 0x01,
-	0x77, 0xda, 0xf6, 0x1a, 0x59, 0x91, 0x43, 0x99, 0x70, 0xa7, 0x6d, 0xaf, 0x2a, 0x4c, 0x11, 0x4d,
-	0x3c, 0xb3, 0xd5, 0xf1, 0x6b, 0x80, 0x3f, 0x7f, 0x40, 0x80, 0xe9, 0xf5, 0xe6, 0xe6, 0x26, 0xcb,
-	0xc3, 0x11, 0xce, 0x60, 0x7c, 0xf5, 0x7e, 0x73, 0x15, 0x32, 0xab, 0x72, 0xbe, 0x5e, 0x87, 0x47,
-	0x78, 0x0c, 0x41, 0x7e, 0xf9, 0x2e, 0x0c, 0xd2, 0x9f, 0x0c, 0x9e, 0xf8, 0x6b, 0xf9, 0x40, 0x6a,
-	0x27, 0x4a, 0xc2, 0x8f, 0x10, 0xfe, 0x7d, 0x4f, 0x78, 0xbe, 0x3f, 0xd6, 0x81, 0xc7, 0xb4, 0x58,
-	0x1e, 0x36, 0xf8, 0xe3, 0xc7, 0x23, 0x7c, 0x0b, 0x27, 0x43, 0x2a, 0x18, 0xfd, 0x23, 0x28, 0xbf,
-	0xea, 0xec, 0x60, 0x84, 0xf1, 0xe8, 0x82, 0xdd, 0x4e, 0xdd, 0xcb, 0x7e, 0xf5, 0x3b, 0x00, 0x00,
-	0xff, 0xff, 0x1a, 0xd6, 0xf0, 0x08, 0xff, 0x02, 0x00, 0x00,
+func init() { proto.RegisterFile("commit.proto", fileDescriptor1) }
+
+var fileDescriptor1 = []byte{
+	// 487 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x93, 0x5b, 0x6b, 0xdb, 0x30,
+	0x14, 0xc7, 0xab, 0x38, 0xb7, 0x9e, 0x64, 0xc1, 0x3d, 0xec, 0xe2, 0x06, 0xb6, 0x1a, 0xb3, 0x87,
+	0xc0, 0x20, 0x14, 0x8f, 0xc1, 0x5e, 0x9b, 0x2e, 0x94, 0xc0, 0x4a, 0x40, 0x35, 0xec, 0x71, 0xb8,
+	0xb6, 0xb6, 0x68, 0xc4, 0x96, 0x27, 0xa9, 0x19, 0xde, 0xeb, 0x9e, 0x06, 0xfb, 0x74, 0xfb, 0x44,
+	0xc3, 0x92, 0x9d, 0xb6, 0xe9, 0xf2, 0xd4, 0xb7, 0xff, 0xb9, 0xe8, 0x9c, 0x9f, 0xce, 0x91, 0x60,
+	0x98, 0x88, 0x2c, 0xe3, 0x7a, 0x5a, 0x48, 0xa1, 0x05, 0x76, 0xbf, 0x72, 0x1d, 0xaf, 0xcb, 0xf1,
+	0x50, 0xad, 0x62, 0xc9, 0x52, 0xeb, 0x0d, 0x7e, 0x13, 0x78, 0x71, 0x6e, 0xd2, 0x16, 0xea, 0x2c,
+	0x4f, 0x98, 0xd2, 0x42, 0x52, 0xf6, 0xfd, 0x86, 0x29, 0x8d, 0x21, 0x80, 0x64, 0x85, 0x50, 0x5c,
+	0x0b, 0x59, 0x7a, 0xc4, 0x27, 0x93, 0x41, 0x88, 0x53, 0x5b, 0x66, 0x4a, 0xb7, 0x11, 0x7a, 0x27,
+	0x0b, 0x4f, 0x60, 0x10, 0xd7, 0x65, 0x3e, 0xf3, 0xd4, 0x6b, 0xf9, 0x64, 0x72, 0x48, 0xa1, 0x71,
+	0x2d, 0x52, 0x3c, 0x86, 0x7e, 0xb2, 0xe2, 0xeb, 0xb4, 0x8a, 0x3a, 0x26, 0xda, 0x33, 0xf6, 0x22,
+	0x0d, 0x4e, 0xc1, 0x7b, 0x88, 0xa2, 0x0a, 0x91, 0x2b, 0x86, 0x4f, 0xa1, 0xb3, 0x89, 0xd7, 0x37,
+	0xcc, 0x60, 0xf4, 0xa9, 0x35, 0x82, 0x3f, 0x04, 0xdc, 0x48, 0x32, 0x36, 0xcf, 0xb5, 0x2c, 0x1f,
+	0x83, 0x3d, 0x86, 0xbe, 0x64, 0x1b, 0xae, 0xb8, 0xc8, 0x0d, 0xf3, 0x90, 0x6e, 0x6d, 0x44, 0x68,
+	0x17, 0xb1, 0x5e, 0x19, 0xda, 0x21, 0x35, 0xba, 0xc2, 0x59, 0xf3, 0x8c, 0x6b, 0xaf, 0xed, 0x93,
+	0x89, 0x43, 0xad, 0x11, 0xfc, 0x25, 0x70, 0x74, 0x07, 0xa7, 0x46, 0x7f, 0x0f, 0x6d, 0x5d, 0x16,
+	0x96, 0x7c, 0x14, 0xbe, 0x6e, 0x48, 0x1e, 0x24, 0x4e, 0x97, 0xd7, 0xdf, 0x58, 0xa2, 0xa3, 0xb2,
+	0x60, 0xd4, 0x9c, 0x40, 0x17, 0x1c, 0xb1, 0x1d, 0x62, 0x25, 0x2b, 0x16, 0xc5, 0x7f, 0x32, 0xc3,
+	0xe2, 0x50, 0xa3, 0x2b, 0x5f, 0x26, 0x52, 0x66, 0x50, 0x3a, 0xd4, 0xe8, 0xca, 0x97, 0xc6, 0x3a,
+	0xf6, 0x3a, 0x96, 0xb9, 0xd2, 0xc1, 0x3b, 0x80, 0xdb, 0x0e, 0x08, 0xd0, 0x3d, 0x5f, 0x5e, 0x5e,
+	0x2e, 0x22, 0xf7, 0x00, 0xfb, 0xd0, 0x9e, 0x7d, 0x5c, 0xce, 0x5c, 0x52, 0xa9, 0x88, 0xce, 0xe7,
+	0x6e, 0x0b, 0x7b, 0xe0, 0x44, 0x67, 0x17, 0xae, 0x13, 0x08, 0x78, 0x66, 0xb7, 0xa2, 0x66, 0x4c,
+	0xff, 0x60, 0x2c, 0x7f, 0xcc, 0x9c, 0x11, 0xda, 0x5f, 0xa4, 0xc8, 0xea, 0x19, 0x1b, 0x8d, 0x23,
+	0x68, 0x69, 0x51, 0x4f, 0xb7, 0xa5, 0x45, 0x30, 0x87, 0xe7, 0xbb, 0x0d, 0xeb, 0x49, 0xbe, 0x81,
+	0x9e, 0x7d, 0xd2, 0xca, 0x23, 0xbe, 0x33, 0x19, 0x84, 0x47, 0x4d, 0xbb, 0x0b, 0xae, 0xed, 0x19,
+	0xda, 0x64, 0x84, 0xbf, 0x5a, 0xf0, 0xc4, 0xfa, 0xae, 0x98, 0xdc, 0xf0, 0x84, 0xe1, 0x27, 0x70,
+	0x77, 0xdf, 0x17, 0x9e, 0x34, 0x15, 0xf6, 0x7c, 0x82, 0xb1, 0xbf, 0x3f, 0xc1, 0x52, 0x05, 0x07,
+	0xf8, 0x01, 0x0e, 0xb7, 0xdb, 0x44, 0xef, 0x3f, 0x0b, 0xb6, 0xa5, 0x8e, 0xf7, 0xae, 0x3e, 0x38,
+	0x38, 0x25, 0x78, 0x05, 0xa3, 0xfb, 0xf7, 0xc6, 0x97, 0xf7, 0x7b, 0xef, 0x2c, 0x60, 0xfc, 0x6a,
+	0x5f, 0xf8, 0xb6, 0xe8, 0x75, 0xd7, 0x7c, 0xf3, 0xb7, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x6f,
+	0x0a, 0x91, 0xcb, 0x0c, 0x04, 0x00, 0x00,
 }
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/deprecated-services.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/deprecated-services.pb.go
index cc4c7563f..1996d5b39 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/deprecated-services.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/deprecated-services.pb.go
@@ -1105,9 +1105,9 @@ var _SSH_serviceDesc = grpc.ServiceDesc{
 	Metadata: "deprecated-services.proto",
 }
 
-func init() { proto.RegisterFile("deprecated-services.proto", fileDescriptor1) }
+func init() { proto.RegisterFile("deprecated-services.proto", fileDescriptor2) }
 
-var fileDescriptor1 = []byte{
+var fileDescriptor2 = []byte{
 	// 534 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x94, 0x5d, 0x6e, 0xd3, 0x40,
 	0x10, 0x80, 0x31, 0x41, 0x91, 0x32, 0xa1, 0x0d, 0x6c, 0x85, 0x68, 0x0c, 0x4d, 0xda, 0x0a, 0x24,
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/diff.pb.go b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/diff.pb.go
index 1dcc5365c..aa5f42881 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/diff.pb.go
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/diff.pb.go
@@ -28,7 +28,7 @@ type CommitDiffRequest struct {
 func (m *CommitDiffRequest) Reset()                    { *m = CommitDiffRequest{} }
 func (m *CommitDiffRequest) String() string            { return proto.CompactTextString(m) }
 func (*CommitDiffRequest) ProtoMessage()               {}
-func (*CommitDiffRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} }
+func (*CommitDiffRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{0} }
 
 func (m *CommitDiffRequest) GetRepository() *Repository {
 	if m != nil {
@@ -82,7 +82,7 @@ type CommitDiffResponse struct {
 func (m *CommitDiffResponse) Reset()                    { *m = CommitDiffResponse{} }
 func (m *CommitDiffResponse) String() string            { return proto.CompactTextString(m) }
 func (*CommitDiffResponse) ProtoMessage()               {}
-func (*CommitDiffResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} }
+func (*CommitDiffResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{1} }
 
 func (m *CommitDiffResponse) GetFromPath() []byte {
 	if m != nil {
@@ -157,7 +157,7 @@ type CommitDeltaRequest struct {
 func (m *CommitDeltaRequest) Reset()                    { *m = CommitDeltaRequest{} }
 func (m *CommitDeltaRequest) String() string            { return proto.CompactTextString(m) }
 func (*CommitDeltaRequest) ProtoMessage()               {}
-func (*CommitDeltaRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{2} }
+func (*CommitDeltaRequest) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{2} }
 
 func (m *CommitDeltaRequest) GetRepository() *Repository {
 	if m != nil {
@@ -200,7 +200,7 @@ type CommitDelta struct {
 func (m *CommitDelta) Reset()                    { *m = CommitDelta{} }
 func (m *CommitDelta) String() string            { return proto.CompactTextString(m) }
 func (*CommitDelta) ProtoMessage()               {}
-func (*CommitDelta) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{3} }
+func (*CommitDelta) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{3} }
 
 func (m *CommitDelta) GetFromPath() []byte {
 	if m != nil {
@@ -251,7 +251,7 @@ type CommitDeltaResponse struct {
 func (m *CommitDeltaResponse) Reset()                    { *m = CommitDeltaResponse{} }
 func (m *CommitDeltaResponse) String() string            { return proto.CompactTextString(m) }
 func (*CommitDeltaResponse) ProtoMessage()               {}
-func (*CommitDeltaResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{4} }
+func (*CommitDeltaResponse) Descriptor() ([]byte, []int) { return fileDescriptor3, []int{4} }
 
 func (m *CommitDeltaResponse) GetDeltas() []*CommitDelta {
 	if m != nil {
@@ -431,9 +431,9 @@ var _DiffService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "diff.proto",
 }
 
-func init() { proto.RegisterFile("diff.proto", fileDescriptor2) }
+func init() { proto.RegisterFile("diff.proto", fileDescriptor3) }
 
-var fileDescriptor2 = []byte{
+var fileDescriptor3 = []byte{
 	// 481 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x94, 0x4f, 0x8e, 0xd3, 0x30,
 	0x14, 0xc6, 0x71, 0xdb, 0xa4, 0xe9, 0x6b, 0xf8, 0xe7, 0xa2, 0xc1, 0xd3, 0xd9, 0x44, 0x11, 0x42,
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 e0948dc59..5d2e3f50f 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 fileDescriptor3, []int{0} }
+func (*PostReceiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor4, []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 fileDescriptor3, []int{1} }
+func (*PostReceiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor4, []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", fileDescriptor3) }
+func init() { proto.RegisterFile("notifications.proto", fileDescriptor4) }
 
-var fileDescriptor3 = []byte{
+var fileDescriptor4 = []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 bd8ed75a8..1ce9b0f4b 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,7 @@ func (x FindLocalBranchesRequest_SortBy) String() string {
 	return proto.EnumName(FindLocalBranchesRequest_SortBy_name, int32(x))
 }
 func (FindLocalBranchesRequest_SortBy) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor4, []int{8, 0}
+	return fileDescriptor5, []int{8, 0}
 }
 
 type FindDefaultBranchNameRequest struct {
@@ -51,7 +51,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 fileDescriptor4, []int{0} }
+func (*FindDefaultBranchNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{0} }
 
 func (m *FindDefaultBranchNameRequest) GetRepository() *Repository {
 	if m != nil {
@@ -67,7 +67,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 fileDescriptor4, []int{1} }
+func (*FindDefaultBranchNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1} }
 
 func (m *FindDefaultBranchNameResponse) GetName() []byte {
 	if m != nil {
@@ -83,7 +83,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 fileDescriptor4, []int{2} }
+func (*FindAllBranchNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{2} }
 
 func (m *FindAllBranchNamesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -99,7 +99,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 fileDescriptor4, []int{3} }
+func (*FindAllBranchNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{3} }
 
 func (m *FindAllBranchNamesResponse) GetNames() [][]byte {
 	if m != nil {
@@ -115,7 +115,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 fileDescriptor4, []int{4} }
+func (*FindAllTagNamesRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{4} }
 
 func (m *FindAllTagNamesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -131,7 +131,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 fileDescriptor4, []int{5} }
+func (*FindAllTagNamesResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{5} }
 
 func (m *FindAllTagNamesResponse) GetNames() [][]byte {
 	if m != nil {
@@ -151,7 +151,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 fileDescriptor4, []int{6} }
+func (*FindRefNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{6} }
 
 func (m *FindRefNameRequest) GetRepository() *Repository {
 	if m != nil {
@@ -182,7 +182,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 fileDescriptor4, []int{7} }
+func (*FindRefNameResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{7} }
 
 func (m *FindRefNameResponse) GetName() []byte {
 	if m != nil {
@@ -199,7 +199,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 fileDescriptor4, []int{8} }
+func (*FindLocalBranchesRequest) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{8} }
 
 func (m *FindLocalBranchesRequest) GetRepository() *Repository {
 	if m != nil {
@@ -222,7 +222,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 fileDescriptor4, []int{9} }
+func (*FindLocalBranchesResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{9} }
 
 func (m *FindLocalBranchesResponse) GetBranches() []*FindLocalBranchResponse {
 	if m != nil {
@@ -242,7 +242,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 fileDescriptor4, []int{10} }
+func (*FindLocalBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{10} }
 
 func (m *FindLocalBranchResponse) GetName() []byte {
 	if m != nil {
@@ -288,7 +288,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 fileDescriptor4, []int{11} }
+func (*FindLocalBranchCommitAuthor) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{11} }
 
 func (m *FindLocalBranchCommitAuthor) GetName() []byte {
 	if m != nil {
@@ -617,9 +617,9 @@ var _RefService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "ref.proto",
 }
 
-func init() { proto.RegisterFile("ref.proto", fileDescriptor4) }
+func init() { proto.RegisterFile("ref.proto", fileDescriptor5) }
 
-var fileDescriptor4 = []byte{
+var fileDescriptor5 = []byte{
 	// 620 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0xc1, 0x6e, 0xd3, 0x40,
 	0x10, 0xad, 0xdb, 0x34, 0xb4, 0x13, 0xd3, 0x86, 0xa5, 0x14, 0xe3, 0x02, 0x4d, 0x0d, 0x15, 0xe5,
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 9a213f26c..2ddbb28d5 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 fileDescriptor5, []int{0} }
+func (*RepositoryExistsRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []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 fileDescriptor5, []int{1} }
+func (*RepositoryExistsResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{1} }
 
 func (m *RepositoryExistsResponse) GetExists() bool {
 	if m != nil {
@@ -126,9 +126,9 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "repository-service.proto",
 }
 
-func init() { proto.RegisterFile("repository-service.proto", fileDescriptor5) }
+func init() { proto.RegisterFile("repository-service.proto", fileDescriptor6) }
 
-var fileDescriptor5 = []byte{
+var fileDescriptor6 = []byte{
 	// 172 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x28, 0x4a, 0x2d, 0xc8,
 	0x2f, 0xce, 0x2c, 0xc9, 0x2f, 0xaa, 0xd4, 0x2d, 0x4e, 0x2d, 0x2a, 0xcb, 0x4c, 0x4e, 0xd5, 0x2b,
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 71598846d..55138c1f9 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
@@ -6,6 +6,7 @@ package gitaly
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
 import math "math"
+import google_protobuf "github.com/golang/protobuf/ptypes/timestamp"
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
@@ -20,7 +21,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 fileDescriptor6, []int{0} }
+func (*Repository) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{0} }
 
 func (m *Repository) GetStorageName() string {
 	if m != nil {
@@ -36,6 +37,86 @@ func (m *Repository) GetRelativePath() string {
 	return ""
 }
 
+type GitCommit struct {
+	Id        string        `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
+	Subject   []byte        `protobuf:"bytes,2,opt,name=subject,proto3" json:"subject,omitempty"`
+	Author    *CommitAuthor `protobuf:"bytes,4,opt,name=author" json:"author,omitempty"`
+	Committer *CommitAuthor `protobuf:"bytes,5,opt,name=committer" json:"committer,omitempty"`
+	ParentIds []string      `protobuf:"bytes,6,rep,name=parent_ids,json=parentIds" json:"parent_ids,omitempty"`
+}
+
+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 (m *GitCommit) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *GitCommit) GetSubject() []byte {
+	if m != nil {
+		return m.Subject
+	}
+	return nil
+}
+
+func (m *GitCommit) GetAuthor() *CommitAuthor {
+	if m != nil {
+		return m.Author
+	}
+	return nil
+}
+
+func (m *GitCommit) GetCommitter() *CommitAuthor {
+	if m != nil {
+		return m.Committer
+	}
+	return nil
+}
+
+func (m *GitCommit) GetParentIds() []string {
+	if m != nil {
+		return m.ParentIds
+	}
+	return nil
+}
+
+type CommitAuthor struct {
+	Name  []byte                     `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	Email []byte                     `protobuf:"bytes,2,opt,name=email,proto3" json:"email,omitempty"`
+	Date  *google_protobuf.Timestamp `protobuf:"bytes,3,opt,name=date" json:"date,omitempty"`
+}
+
+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 (m *CommitAuthor) GetName() []byte {
+	if m != nil {
+		return m.Name
+	}
+	return nil
+}
+
+func (m *CommitAuthor) GetEmail() []byte {
+	if m != nil {
+		return m.Email
+	}
+	return nil
+}
+
+func (m *CommitAuthor) GetDate() *google_protobuf.Timestamp {
+	if m != nil {
+		return m.Date
+	}
+	return nil
+}
+
 type ExitStatus struct {
 	Value int32 `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
 }
@@ -43,7 +124,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 fileDescriptor6, []int{1} }
+func (*ExitStatus) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{3} }
 
 func (m *ExitStatus) GetValue() int32 {
 	if m != nil {
@@ -54,22 +135,34 @@ func (m *ExitStatus) GetValue() int32 {
 
 func init() {
 	proto.RegisterType((*Repository)(nil), "gitaly.Repository")
+	proto.RegisterType((*GitCommit)(nil), "gitaly.GitCommit")
+	proto.RegisterType((*CommitAuthor)(nil), "gitaly.CommitAuthor")
 	proto.RegisterType((*ExitStatus)(nil), "gitaly.ExitStatus")
 }
 
-func init() { proto.RegisterFile("shared.proto", fileDescriptor6) }
-
-var fileDescriptor6 = []byte{
-	// 164 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x34, 0xce, 0x31, 0x0f, 0x82, 0x30,
-	0x10, 0x05, 0xe0, 0x14, 0x81, 0xe8, 0x89, 0x89, 0x69, 0x1c, 0x18, 0x11, 0x17, 0x26, 0x17, 0x7f,
-	0x83, 0x8b, 0x83, 0x31, 0xf5, 0x07, 0xe0, 0x19, 0x2f, 0xd0, 0xa4, 0xd8, 0xa6, 0x3d, 0x88, 0xfc,
-	0x7b, 0x23, 0xea, 0xf8, 0xbe, 0xf7, 0x86, 0x07, 0x59, 0x68, 0xd1, 0xd3, 0x63, 0xef, 0xbc, 0x65,
-	0x2b, 0xd3, 0x46, 0x33, 0x9a, 0xb1, 0xbc, 0x01, 0x28, 0x72, 0x36, 0x68, 0xb6, 0x7e, 0x94, 0x5b,
-	0xc8, 0x02, 0x5b, 0x8f, 0x0d, 0xd5, 0x4f, 0xec, 0x28, 0x8f, 0x0a, 0x51, 0x2d, 0xd4, 0xf2, 0x67,
-	0x67, 0xec, 0x48, 0xee, 0x60, 0xe5, 0xc9, 0x20, 0xeb, 0x81, 0x6a, 0x87, 0xdc, 0xe6, 0xb3, 0x69,
-	0x93, 0xfd, 0xf1, 0x82, 0xdc, 0x9e, 0xe2, 0xb9, 0x58, 0x47, 0x2a, 0xfe, 0xf4, 0x65, 0x09, 0x70,
-	0x7c, 0x69, 0xbe, 0x32, 0x72, 0x1f, 0xe4, 0x06, 0x92, 0x01, 0x4d, 0x4f, 0xb9, 0x28, 0x44, 0x95,
-	0xa8, 0x6f, 0xb8, 0xa7, 0xd3, 0xa9, 0xc3, 0x3b, 0x00, 0x00, 0xff, 0xff, 0xfe, 0x53, 0x2c, 0xb6,
-	0xa4, 0x00, 0x00, 0x00,
+func init() { proto.RegisterFile("shared.proto", fileDescriptor7) }
+
+var fileDescriptor7 = []byte{
+	// 326 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x51, 0xc1, 0x4a, 0xc3, 0x40,
+	0x10, 0x25, 0x69, 0x1a, 0xcd, 0x34, 0x8a, 0x2c, 0x3d, 0x84, 0x82, 0x58, 0xe3, 0xa5, 0x07, 0x49,
+	0xa1, 0x7e, 0x81, 0x88, 0x88, 0x1e, 0x44, 0x56, 0xef, 0x75, 0xda, 0xac, 0xc9, 0x4a, 0xb6, 0x1b,
+	0x76, 0x27, 0xc5, 0xfe, 0x98, 0xdf, 0x27, 0xdd, 0x6d, 0xd0, 0x93, 0xb7, 0x7d, 0x6f, 0xde, 0x9b,
+	0x99, 0x9d, 0x07, 0xa9, 0xad, 0xd1, 0x88, 0xb2, 0x68, 0x8d, 0x26, 0xcd, 0xe2, 0x4a, 0x12, 0x36,
+	0xbb, 0xc9, 0x45, 0xa5, 0x75, 0xd5, 0x88, 0xb9, 0x63, 0x57, 0xdd, 0xc7, 0x9c, 0xa4, 0x12, 0x96,
+	0x50, 0xb5, 0x5e, 0x98, 0xbf, 0x03, 0x70, 0xd1, 0x6a, 0x2b, 0x49, 0x9b, 0x1d, 0xbb, 0x84, 0xd4,
+	0x92, 0x36, 0x58, 0x89, 0xe5, 0x06, 0x95, 0xc8, 0xc2, 0x69, 0x30, 0x4b, 0xf8, 0xe8, 0xc0, 0x3d,
+	0xa3, 0x12, 0xec, 0x0a, 0x4e, 0x8c, 0x68, 0x90, 0xe4, 0x56, 0x2c, 0x5b, 0xa4, 0x3a, 0x1b, 0x38,
+	0x4d, 0xda, 0x93, 0x2f, 0x48, 0xf5, 0x53, 0x74, 0x1c, 0x9c, 0x85, 0x3c, 0xda, 0xd7, 0xf3, 0xef,
+	0x00, 0x92, 0x07, 0x49, 0x77, 0x5a, 0x29, 0x49, 0xec, 0x14, 0x42, 0x59, 0x66, 0x81, 0xf3, 0x84,
+	0xb2, 0x64, 0x19, 0x1c, 0xd9, 0x6e, 0xf5, 0x29, 0xd6, 0xe4, 0x86, 0xa5, 0xbc, 0x87, 0xec, 0x1a,
+	0x62, 0xec, 0xa8, 0xd6, 0x26, 0x8b, 0xa6, 0xc1, 0x6c, 0xb4, 0x18, 0x17, 0xfe, 0x4f, 0x85, 0xef,
+	0x74, 0xeb, 0x6a, 0xfc, 0xa0, 0x61, 0x0b, 0x48, 0xd6, 0x8e, 0x27, 0x61, 0xb2, 0xe1, 0x3f, 0x86,
+	0x5f, 0x19, 0x3b, 0x07, 0x68, 0xd1, 0x88, 0x0d, 0x2d, 0x65, 0x69, 0xb3, 0x78, 0x3a, 0x98, 0x25,
+	0x3c, 0xf1, 0xcc, 0x63, 0x69, 0xf3, 0x1a, 0xd2, 0xbf, 0x4e, 0xc6, 0x20, 0x72, 0x47, 0x09, 0xdc,
+	0x9e, 0xee, 0xcd, 0xc6, 0x30, 0x14, 0x0a, 0x65, 0x73, 0x58, 0xde, 0x03, 0x56, 0x40, 0x54, 0x22,
+	0x09, 0x77, 0x9a, 0xd1, 0x62, 0x52, 0xf8, 0x10, 0x8a, 0x3e, 0x84, 0xe2, 0xad, 0x0f, 0x81, 0x3b,
+	0x5d, 0x9e, 0x03, 0xdc, 0x7f, 0x49, 0x7a, 0x25, 0xa4, 0xce, 0xee, 0x7b, 0x6e, 0xb1, 0xe9, 0xfc,
+	0xa0, 0x21, 0xf7, 0x60, 0x15, 0x3b, 0xf7, 0xcd, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xcc, 0xb5,
+	0x59, 0xd6, 0xe8, 0x01, 0x00, 0x00,
 }
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 46802c2c4..ce4691806 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 fileDescriptor7, []int{0} }
+func (*InfoRefsRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []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 fileDescriptor7, []int{1} }
+func (*InfoRefsResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []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 fileDescriptor7, []int{2} }
+func (*PostUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []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 fileDescriptor7, []int{3} }
+func (*PostUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []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 fileDescriptor7, []int{4} }
+func (*PostReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []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 fileDescriptor7, []int{5} }
+func (*PostReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []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", fileDescriptor7) }
+func init() { proto.RegisterFile("smarthttp.proto", fileDescriptor8) }
 
-var fileDescriptor7 = []byte{
+var fileDescriptor8 = []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 453786795..3d9286165 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
@@ -27,7 +27,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 fileDescriptor8, []int{0} }
+func (*SSHUploadPackRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{0} }
 
 func (m *SSHUploadPackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -56,7 +56,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 fileDescriptor8, []int{1} }
+func (*SSHUploadPackResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{1} }
 
 func (m *SSHUploadPackResponse) GetStdout() []byte {
 	if m != nil {
@@ -93,7 +93,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 fileDescriptor8, []int{2} }
+func (*SSHReceivePackRequest) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{2} }
 
 func (m *SSHReceivePackRequest) GetRepository() *Repository {
 	if m != nil {
@@ -136,7 +136,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 fileDescriptor8, []int{3} }
+func (*SSHReceivePackResponse) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{3} }
 
 func (m *SSHReceivePackResponse) GetStdout() []byte {
 	if m != nil {
@@ -339,9 +339,9 @@ var _SSHService_serviceDesc = grpc.ServiceDesc{
 	Metadata: "ssh.proto",
 }
 
-func init() { proto.RegisterFile("ssh.proto", fileDescriptor8) }
+func init() { proto.RegisterFile("ssh.proto", fileDescriptor9) }
 
-var fileDescriptor8 = []byte{
+var fileDescriptor9 = []byte{
 	// 307 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x52, 0xcf, 0x4e, 0x32, 0x31,
 	0x10, 0xff, 0xfa, 0x09, 0x24, 0x0c, 0x8b, 0x87, 0x11, 0x09, 0x21, 0x6a, 0xc8, 0x7a, 0xe1, 0x44,
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 5f421c97d..fb63c968d 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -191,20 +191,20 @@
 			"revisionTime": "2017-01-30T11:31:45Z"
 		},
 		{
-			"checksumSHA1": "FLmxR5JvjKDRngzvCIQtBmgsssA=",
+			"checksumSHA1": "P/ZK+KQcyfxAAlpOQqcnutYxOIc=",
 			"path": "gitlab.com/gitlab-org/gitaly-proto/go",
-			"revision": "caef1404f9c28e1a2e12a79bb313ee0a89addac4",
-			"revisionTime": "2017-06-26T11:11:20Z",
-			"version": "=v0.10.0",
-			"versionExact": "v0.10.0"
+			"revision": "9d7cce7a7f2e71a031a101073296d21482c801ea",
+			"revisionTime": "2017-07-04T15:20:55Z",
+			"version": "v0.12.0",
+			"versionExact": "v0.12.0"
 		},
 		{
 			"checksumSHA1": "GkeSZfXVbtAkBZOrswot19GJZqQ=",
 			"path": "gitlab.com/gitlab-org/gitaly-proto/go/helper",
-			"revision": "caef1404f9c28e1a2e12a79bb313ee0a89addac4",
-			"revisionTime": "2017-06-26T11:11:20Z",
-			"version": "=v0.10.0",
-			"versionExact": "v0.10.0"
+			"revision": "9d7cce7a7f2e71a031a101073296d21482c801ea",
+			"revisionTime": "2017-07-04T15:20:55Z",
+			"version": "v0.12.0",
+			"versionExact": "v0.12.0"
 		},
 		{
 			"checksumSHA1": "Y+HGqEkYM15ir+J93MEaHdyFy0c=",