Merge branch '1071-server-implementation-sshservice-sshuploadarchive' into 'master'

Resolve "Server Implementation SSHService::SSHUploadArchive"

Closes #1071

See merge request gitlab-org/gitaly!621

10 files changed, 424 insertions, 31 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9e4d0068f..a882f6cff 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,8 @@
 
 UNRELEASED
 
+- Implement SSHService.SSHUploadArchive RPC
+  https://gitlab.com/gitlab-org/gitaly/merge_requests/621
 - Sanitize URLs before logging them
   https://gitlab.com/gitlab-org/gitaly/merge_requests/624
 - Clean stale worktrees before performing garbage collection
diff --git a/client/upload_archive.go b/client/upload_archive.go
new file mode 100644
index 000000000..6b4d68216
--- /dev/null
+++ b/client/upload_archive.go
@@ -0,0 +1,40 @@
+package client
+
+import (
+	"io"
+
+	"gitlab.com/gitlab-org/gitaly/streamio"
+
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+
+	"golang.org/x/net/context"
+	"google.golang.org/grpc"
+)
+
+// UploadArchive proxies an SSH git-upload-archive (git archive --remote) session to Gitaly
+func UploadArchive(ctx context.Context, conn *grpc.ClientConn, stdin io.Reader, stdout, stderr io.Writer, req *pb.SSHUploadArchiveRequest) (int32, error) {
+	ctx2, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	ssh := pb.NewSSHServiceClient(conn)
+	stream, err := ssh.SSHUploadArchive(ctx2)
+	if err != nil {
+		return 0, err
+	}
+
+	if err = stream.Send(req); err != nil {
+		return 0, err
+	}
+
+	inWriter := streamio.NewWriter(func(p []byte) error {
+		return stream.Send(&pb.SSHUploadArchiveRequest{Stdin: p})
+	})
+
+	return streamHandler(func() (stdoutStderrResponse, error) {
+		return stream.Recv()
+	}, func(errC chan error) {
+		_, errRecv := io.Copy(inWriter, stdin)
+		stream.CloseSend()
+		errC <- errRecv
+	}, stdout, stderr)
+}
diff --git a/cmd/gitaly-ssh/main.go b/cmd/gitaly-ssh/main.go
index 195d6370f..048174133 100644
--- a/cmd/gitaly-ssh/main.go
+++ b/cmd/gitaly-ssh/main.go
@@ -29,6 +29,8 @@ func main() {
 		packer = uploadPack
 	case "receive-pack":
 		packer = receivePack
+	case "upload-archive":
+		packer = uploadArchive
 	default:
 		log.Fatalf("invalid pack command: %q", os.Args[1])
 	}
diff --git a/cmd/gitaly-ssh/upload_archive.go b/cmd/gitaly-ssh/upload_archive.go
new file mode 100644
index 000000000..0e5c3d3df
--- /dev/null
+++ b/cmd/gitaly-ssh/upload_archive.go
@@ -0,0 +1,33 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/golang/protobuf/jsonpb"
+
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+	"gitlab.com/gitlab-org/gitaly/client"
+)
+
+func uploadArchive(url, req string) (int32, error) {
+	var request pb.SSHUploadArchiveRequest
+	if err := jsonpb.UnmarshalString(req, &request); err != nil {
+		return 0, fmt.Errorf("json unmarshal: %v", err)
+	}
+
+	if url == "" {
+		return 0, fmt.Errorf("gitaly address can not be empty")
+	}
+	conn, err := client.Dial(url, dialOpts())
+	if err != nil {
+		return 0, fmt.Errorf("dial %q: %v", url, err)
+	}
+	defer conn.Close()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	return client.UploadArchive(ctx, conn, os.Stdin, os.Stdout, os.Stderr, &request)
+}
diff --git a/internal/service/ssh/upload_archive.go b/internal/service/ssh/upload_archive.go
new file mode 100644
index 000000000..480cde388
--- /dev/null
+++ b/internal/service/ssh/upload_archive.go
@@ -0,0 +1,71 @@
+package ssh
+
+import (
+	"os/exec"
+
+	"github.com/grpc-ecosystem/go-grpc-middleware/logging/logrus"
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+	"gitlab.com/gitlab-org/gitaly/internal/command"
+	"gitlab.com/gitlab-org/gitaly/internal/helper"
+	"gitlab.com/gitlab-org/gitaly/streamio"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func (s *server) SSHUploadArchive(stream pb.SSHService_SSHUploadArchiveServer) error {
+	grpc_logrus.Extract(stream.Context()).Debug("SSHUploadArchive")
+
+	req, err := stream.Recv() // First request contains Repository only
+	if err != nil {
+		return err
+	}
+	if err = validateFirstUploadArchiveRequest(req); err != nil {
+		return err
+	}
+
+	repoPath, err := helper.GetRepoPath(req.Repository)
+	if err != nil {
+		return err
+	}
+	stdin := streamio.NewReader(func() ([]byte, error) {
+		request, err := stream.Recv()
+		return request.GetStdin(), err
+	})
+	stdout := streamio.NewWriter(func(p []byte) error {
+		return stream.Send(&pb.SSHUploadArchiveResponse{Stdout: p})
+	})
+	stderr := streamio.NewWriter(func(p []byte) error {
+		return stream.Send(&pb.SSHUploadArchiveResponse{Stderr: p})
+	})
+
+	osCommand := exec.Command(command.GitPath(), "upload-archive", repoPath)
+
+	cmd, err := command.New(stream.Context(), osCommand, stdin, stdout, stderr)
+
+	if err != nil {
+		return status.Errorf(codes.Unavailable, "SSHUploadArchive: cmd: %v", err)
+	}
+
+	if err := cmd.Wait(); err != nil {
+		if status, ok := command.ExitStatus(err); ok {
+			return helper.DecorateError(
+				codes.Internal,
+				stream.Send(&pb.SSHUploadArchiveResponse{ExitStatus: &pb.ExitStatus{Value: int32(status)}}),
+			)
+		}
+		return status.Errorf(codes.Unavailable, "SSHUploadArchive: %v", err)
+	}
+
+	return helper.DecorateError(
+		codes.Internal,
+		stream.Send(&pb.SSHUploadArchiveResponse{ExitStatus: &pb.ExitStatus{Value: 0}}),
+	)
+}
+
+func validateFirstUploadArchiveRequest(req *pb.SSHUploadArchiveRequest) error {
+	if req.Stdin != nil {
+		return status.Errorf(codes.InvalidArgument, "SSHUploadArchive: non-empty stdin")
+	}
+
+	return nil
+}
diff --git a/internal/service/ssh/upload_archive_test.go b/internal/service/ssh/upload_archive_test.go
new file mode 100644
index 000000000..9b0cea4a9
--- /dev/null
+++ b/internal/service/ssh/upload_archive_test.go
@@ -0,0 +1,110 @@
+package ssh
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"testing"
+
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/stretchr/testify/require"
+
+	"gitlab.com/gitlab-org/gitaly/internal/testhelper"
+
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+
+	"golang.org/x/net/context"
+	"google.golang.org/grpc/codes"
+)
+
+func TestFailedUploadArchiveRequestDueToValidationError(t *testing.T) {
+	server, serverSocketPath := runSSHServer(t)
+	defer server.Stop()
+
+	client, conn := newSSHClient(t, serverSocketPath)
+	defer conn.Close()
+
+	tests := []struct {
+		Desc string
+		Req  *pb.SSHUploadArchiveRequest
+		Code codes.Code
+	}{
+		{
+			Desc: "Repository.RelativePath is empty",
+			Req:  &pb.SSHUploadArchiveRequest{Repository: &pb.Repository{StorageName: "default", RelativePath: ""}},
+			Code: codes.InvalidArgument,
+		},
+		{
+			Desc: "Repository is nil",
+			Req:  &pb.SSHUploadArchiveRequest{Repository: nil},
+			Code: codes.InvalidArgument,
+		},
+		{
+			Desc: "Data exists on first request",
+			Req:  &pb.SSHUploadArchiveRequest{Repository: &pb.Repository{StorageName: "default", RelativePath: "path/to/repo"}, Stdin: []byte("Fail")},
+			Code: codes.InvalidArgument,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.Desc, func(t *testing.T) {
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			stream, err := client.SSHUploadArchive(ctx)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if err = stream.Send(test.Req); err != nil {
+				t.Fatal(err)
+			}
+			stream.CloseSend()
+
+			err = drainUploadArchiveResponse(stream)
+			testhelper.AssertGrpcError(t, err, test.Code, "")
+		})
+	}
+}
+
+func TestUploadArchiveSuccess(t *testing.T) {
+	server, serverSocketPath := runSSHServer(t)
+	defer server.Stop()
+
+	cmd := exec.Command("git", "archive", "master", "--remote=git@localhost:test/test.git")
+
+	err := testArchive(t, serverSocketPath, testRepo, cmd)
+	require.NoError(t, err)
+}
+
+func testArchive(t *testing.T, serverSocketPath string, testRepo *pb.Repository, cmd *exec.Cmd) error {
+	req := &pb.SSHUploadArchiveRequest{Repository: testRepo}
+	pbMarshaler := &jsonpb.Marshaler{}
+	payload, err := pbMarshaler.MarshalToString(req)
+
+	require.NoError(t, err)
+
+	cmd.Env = []string{
+		fmt.Sprintf("GITALY_ADDRESS=unix:%s", serverSocketPath),
+		fmt.Sprintf("GITALY_PAYLOAD=%s", payload),
+		fmt.Sprintf("PATH=%s", ".:"+os.Getenv("PATH")),
+		fmt.Sprintf(`GIT_SSH_COMMAND=%s upload-archive`, gitalySSHPath),
+	}
+
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("%v: %q", err, out)
+	}
+	if !cmd.ProcessState.Success() {
+		return fmt.Errorf("Failed to run `git archive`: %q", out)
+	}
+
+	return nil
+}
+
+func drainUploadArchiveResponse(stream pb.SSHService_SSHUploadArchiveClient) error {
+	var err error
+	for err == nil {
+		_, err = stream.Recv()
+	}
+	return err
+}
diff --git a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION
index fe6d01c1a..5aee1345c 100644
--- a/vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION
+++ b/vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION
@@ -1 +1 @@
-0.88.0
+0.89.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 28190a135..b4584fc89 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
@@ -226,6 +226,8 @@ It has these top-level messages:
 	SSHUploadPackResponse
 	SSHReceivePackRequest
 	SSHReceivePackResponse
+	SSHUploadArchiveRequest
+	SSHUploadArchiveResponse
 	WikiCommitDetails
 	WikiPageVersion
 	WikiPage
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 d924a4704..ea8809734 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
@@ -176,11 +176,74 @@ func (m *SSHReceivePackResponse) GetExitStatus() *ExitStatus {
 	return nil
 }
 
+type SSHUploadArchiveRequest struct {
+	// 'repository' must be present in the first message.
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	// A chunk of raw data to be copied to 'git upload-archive' standard input
+	Stdin []byte `protobuf:"bytes,2,opt,name=stdin,proto3" json:"stdin,omitempty"`
+}
+
+func (m *SSHUploadArchiveRequest) Reset()                    { *m = SSHUploadArchiveRequest{} }
+func (m *SSHUploadArchiveRequest) String() string            { return proto.CompactTextString(m) }
+func (*SSHUploadArchiveRequest) ProtoMessage()               {}
+func (*SSHUploadArchiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{4} }
+
+func (m *SSHUploadArchiveRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *SSHUploadArchiveRequest) GetStdin() []byte {
+	if m != nil {
+		return m.Stdin
+	}
+	return nil
+}
+
+type SSHUploadArchiveResponse struct {
+	// A chunk of raw data from 'git upload-archive' standard output
+	Stdout []byte `protobuf:"bytes,1,opt,name=stdout,proto3" json:"stdout,omitempty"`
+	// A chunk of raw data from 'git upload-archive' standard error
+	Stderr []byte `protobuf:"bytes,2,opt,name=stderr,proto3" json:"stderr,omitempty"`
+	// This value will only be set on the last message
+	ExitStatus *ExitStatus `protobuf:"bytes,3,opt,name=exit_status,json=exitStatus" json:"exit_status,omitempty"`
+}
+
+func (m *SSHUploadArchiveResponse) Reset()                    { *m = SSHUploadArchiveResponse{} }
+func (m *SSHUploadArchiveResponse) String() string            { return proto.CompactTextString(m) }
+func (*SSHUploadArchiveResponse) ProtoMessage()               {}
+func (*SSHUploadArchiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor14, []int{5} }
+
+func (m *SSHUploadArchiveResponse) GetStdout() []byte {
+	if m != nil {
+		return m.Stdout
+	}
+	return nil
+}
+
+func (m *SSHUploadArchiveResponse) GetStderr() []byte {
+	if m != nil {
+		return m.Stderr
+	}
+	return nil
+}
+
+func (m *SSHUploadArchiveResponse) GetExitStatus() *ExitStatus {
+	if m != nil {
+		return m.ExitStatus
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*SSHUploadPackRequest)(nil), "gitaly.SSHUploadPackRequest")
 	proto.RegisterType((*SSHUploadPackResponse)(nil), "gitaly.SSHUploadPackResponse")
 	proto.RegisterType((*SSHReceivePackRequest)(nil), "gitaly.SSHReceivePackRequest")
 	proto.RegisterType((*SSHReceivePackResponse)(nil), "gitaly.SSHReceivePackResponse")
+	proto.RegisterType((*SSHUploadArchiveRequest)(nil), "gitaly.SSHUploadArchiveRequest")
+	proto.RegisterType((*SSHUploadArchiveResponse)(nil), "gitaly.SSHUploadArchiveResponse")
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -198,6 +261,8 @@ type SSHServiceClient interface {
 	SSHUploadPack(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHUploadPackClient, error)
 	// To forward 'git receive-pack' to Gitaly for SSH sessions
 	SSHReceivePack(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHReceivePackClient, error)
+	// To forward 'git upload-archive' to Gitaly for SSH sessions
+	SSHUploadArchive(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHUploadArchiveClient, error)
 }
 
 type sSHServiceClient struct {
@@ -270,6 +335,37 @@ func (x *sSHServiceSSHReceivePackClient) Recv() (*SSHReceivePackResponse, error)
 	return m, nil
 }
 
+func (c *sSHServiceClient) SSHUploadArchive(ctx context.Context, opts ...grpc.CallOption) (SSHService_SSHUploadArchiveClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_SSHService_serviceDesc.Streams[2], c.cc, "/gitaly.SSHService/SSHUploadArchive", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &sSHServiceSSHUploadArchiveClient{stream}
+	return x, nil
+}
+
+type SSHService_SSHUploadArchiveClient interface {
+	Send(*SSHUploadArchiveRequest) error
+	Recv() (*SSHUploadArchiveResponse, error)
+	grpc.ClientStream
+}
+
+type sSHServiceSSHUploadArchiveClient struct {
+	grpc.ClientStream
+}
+
+func (x *sSHServiceSSHUploadArchiveClient) Send(m *SSHUploadArchiveRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *sSHServiceSSHUploadArchiveClient) Recv() (*SSHUploadArchiveResponse, error) {
+	m := new(SSHUploadArchiveResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // Server API for SSHService service
 
 type SSHServiceServer interface {
@@ -277,6 +373,8 @@ type SSHServiceServer interface {
 	SSHUploadPack(SSHService_SSHUploadPackServer) error
 	// To forward 'git receive-pack' to Gitaly for SSH sessions
 	SSHReceivePack(SSHService_SSHReceivePackServer) error
+	// To forward 'git upload-archive' to Gitaly for SSH sessions
+	SSHUploadArchive(SSHService_SSHUploadArchiveServer) error
 }
 
 func RegisterSSHServiceServer(s *grpc.Server, srv SSHServiceServer) {
@@ -335,6 +433,32 @@ func (x *sSHServiceSSHReceivePackServer) Recv() (*SSHReceivePackRequest, error)
 	return m, nil
 }
 
+func _SSHService_SSHUploadArchive_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(SSHServiceServer).SSHUploadArchive(&sSHServiceSSHUploadArchiveServer{stream})
+}
+
+type SSHService_SSHUploadArchiveServer interface {
+	Send(*SSHUploadArchiveResponse) error
+	Recv() (*SSHUploadArchiveRequest, error)
+	grpc.ServerStream
+}
+
+type sSHServiceSSHUploadArchiveServer struct {
+	grpc.ServerStream
+}
+
+func (x *sSHServiceSSHUploadArchiveServer) Send(m *SSHUploadArchiveResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *sSHServiceSSHUploadArchiveServer) Recv() (*SSHUploadArchiveRequest, error) {
+	m := new(SSHUploadArchiveRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 var _SSHService_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "gitaly.SSHService",
 	HandlerType: (*SSHServiceServer)(nil),
@@ -352,6 +476,12 @@ var _SSHService_serviceDesc = grpc.ServiceDesc{
 			ServerStreams: true,
 			ClientStreams: true,
 		},
+		{
+			StreamName:    "SSHUploadArchive",
+			Handler:       _SSHService_SSHUploadArchive_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
 	},
 	Metadata: "ssh.proto",
 }
@@ -359,29 +489,32 @@ var _SSHService_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("ssh.proto", fileDescriptor14) }
 
 var fileDescriptor14 = []byte{
-	// 377 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x53, 0xcd, 0xce, 0xd2, 0x40,
-	0x14, 0x75, 0xa4, 0x10, 0xb9, 0xf4, 0x33, 0x64, 0x04, 0xd2, 0x10, 0x7f, 0x48, 0xdd, 0x74, 0x61,
-	0x88, 0x81, 0x47, 0x30, 0x26, 0xe8, 0x46, 0x33, 0x0d, 0xeb, 0x66, 0x6c, 0xaf, 0xc3, 0xc4, 0xa1,
-	0x53, 0x67, 0xa6, 0x04, 0x12, 0x7d, 0x22, 0x1f, 0xc0, 0x8d, 0x0f, 0x67, 0x32, 0xad, 0x58, 0x50,
-	0x96, 0xba, 0xeb, 0x3d, 0xe7, 0xfe, 0x9c, 0x73, 0x6f, 0x07, 0x86, 0xd6, 0xee, 0x96, 0x95, 0xd1,
-	0x4e, 0xd3, 0x81, 0x90, 0x8e, 0xab, 0xd3, 0x3c, 0xb4, 0x3b, 0x6e, 0xb0, 0x68, 0xd0, 0xf8, 0x1b,
-	0x81, 0x49, 0x9a, 0x6e, 0xb6, 0x95, 0xd2, 0xbc, 0x78, 0xcf, 0xf3, 0x4f, 0x0c, 0x3f, 0xd7, 0x68,
-	0x1d, 0x5d, 0x01, 0x18, 0xac, 0xb4, 0x95, 0x4e, 0x9b, 0x53, 0x44, 0x16, 0x24, 0x19, 0xad, 0xe8,
-	0xb2, 0xe9, 0xb1, 0x64, 0x67, 0x86, 0x75, 0xb2, 0xe8, 0x04, 0xfa, 0xd6, 0x15, 0xb2, 0x8c, 0xee,
-	0x2f, 0x48, 0x12, 0xb2, 0x26, 0xa0, 0x2f, 0x80, 0x0a, 0xe9, 0xb2, 0x5c, 0x97, 0x1f, 0xa5, 0xc8,
-	0x74, 0xe5, 0xa4, 0x2e, 0x6d, 0x14, 0x2c, 0x7a, 0xc9, 0x90, 0x8d, 0x85, 0x74, 0xaf, 0x3c, 0xf1,
-	0xae, 0xc1, 0xdf, 0x06, 0x0f, 0x7a, 0xe3, 0x80, 0x4d, 0x3b, 0x15, 0x15, 0x37, 0x7c, 0x8f, 0x0e,
-	0x8d, 0x8d, 0xbf, 0xc0, 0xf4, 0x4a, 0xac, 0xad, 0x74, 0x69, 0x91, 0xce, 0x60, 0x60, 0x5d, 0xa1,
-	0x6b, 0xe7, 0x95, 0x86, 0xac, 0x8d, 0x5a, 0x1c, 0x8d, 0x69, 0x25, 0xb5, 0x11, 0x5d, 0xc3, 0x08,
-	0x8f, 0xd2, 0x65, 0xd6, 0x71, 0x57, 0xdb, 0xa8, 0x77, 0x69, 0xef, 0xf5, 0x51, 0xba, 0xd4, 0x33,
-	0x0c, 0xf0, 0xfc, 0x1d, 0xff, 0x20, 0x7e, 0x3c, 0xc3, 0x1c, 0xe5, 0x01, 0xff, 0xcd, 0xb2, 0x1e,
-	0x41, 0x5f, 0xa8, 0x4c, 0x16, 0x5e, 0xd2, 0x90, 0x05, 0x42, 0xbd, 0x29, 0xe8, 0x73, 0xb8, 0x13,
-	0x2a, 0xeb, 0x4c, 0x08, 0x3c, 0x19, 0x0a, 0xf5, 0xbb, 0x37, 0x7d, 0x06, 0x23, 0xa1, 0xb2, 0xda,
-	0xa2, 0x29, 0xf9, 0x1e, 0xa3, 0xbe, 0x4f, 0x01, 0xa1, 0xb6, 0x2d, 0x12, 0x7f, 0x85, 0xd9, 0xb5,
-	0xfa, 0xff, 0xb8, 0xbd, 0xd5, 0x77, 0x02, 0x90, 0xa6, 0x9b, 0x14, 0xcd, 0x41, 0xe6, 0x48, 0x19,
-	0xdc, 0x5d, 0x9c, 0x92, 0x3e, 0xfe, 0x55, 0xff, 0xb7, 0xdf, 0x71, 0xfe, 0xe4, 0x06, 0xdb, 0x38,
-	0x88, 0xef, 0x25, 0xe4, 0x25, 0xa1, 0x5b, 0x78, 0x78, 0xe9, 0x90, 0x76, 0xcb, 0xfe, 0xbc, 0xdb,
-	0xfc, 0xe9, 0x2d, 0xba, 0xdb, 0xf6, 0xc3, 0xc0, 0x3f, 0x95, 0xf5, 0xcf, 0x00, 0x00, 0x00, 0xff,
-	0xff, 0x1b, 0x65, 0x3d, 0xab, 0x4d, 0x03, 0x00, 0x00,
+	// 423 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x54, 0xcd, 0x6e, 0xd3, 0x40,
+	0x10, 0xc6, 0x8d, 0x13, 0x91, 0x89, 0x8b, 0xa2, 0xa5, 0x2d, 0x96, 0x05, 0xd4, 0x32, 0x17, 0x1f,
+	0x50, 0x84, 0xd2, 0x27, 0x40, 0x08, 0xa9, 0x70, 0x01, 0xad, 0x95, 0x13, 0x07, 0x6b, 0xb1, 0x87,
+	0xcd, 0x8a, 0xad, 0xd7, 0xec, 0xae, 0xa3, 0x56, 0x02, 0xf1, 0x12, 0xbc, 0x05, 0xaf, 0xc0, 0xc3,
+	0x21, 0xad, 0x4d, 0xb0, 0x13, 0x72, 0xa3, 0xbd, 0x79, 0xe6, 0x9b, 0x9f, 0x6f, 0xbe, 0x19, 0x2f,
+	0x4c, 0x8d, 0x59, 0x2f, 0x6a, 0xad, 0xac, 0x22, 0x13, 0x2e, 0x2c, 0x93, 0x37, 0x51, 0x60, 0xd6,
+	0x4c, 0x63, 0xd9, 0x7a, 0x93, 0x9f, 0x1e, 0x9c, 0x64, 0xd9, 0xe5, 0xaa, 0x96, 0x8a, 0x95, 0xef,
+	0x59, 0xf1, 0x99, 0xe2, 0x97, 0x06, 0x8d, 0x25, 0x4b, 0x00, 0x8d, 0xb5, 0x32, 0xc2, 0x2a, 0x7d,
+	0x13, 0x7a, 0xb1, 0x97, 0xce, 0x96, 0x64, 0xd1, 0xd6, 0x58, 0xd0, 0x2d, 0x42, 0x7b, 0x51, 0xe4,
+	0x04, 0xc6, 0xc6, 0x96, 0xa2, 0x0a, 0x8f, 0x62, 0x2f, 0x0d, 0x68, 0x6b, 0x90, 0xe7, 0x40, 0xb8,
+	0xb0, 0x79, 0xa1, 0xaa, 0x4f, 0x82, 0xe7, 0xaa, 0xb6, 0x42, 0x55, 0x26, 0xf4, 0xe3, 0x51, 0x3a,
+	0xa5, 0x73, 0x2e, 0xec, 0x2b, 0x07, 0xbc, 0x6b, 0xfd, 0x6f, 0xfd, 0xfb, 0xa3, 0xb9, 0x4f, 0x4f,
+	0x7b, 0x19, 0x35, 0xd3, 0xec, 0x0a, 0x2d, 0x6a, 0x93, 0x7c, 0x85, 0xd3, 0x1d, 0xb2, 0xa6, 0x56,
+	0x95, 0x41, 0x72, 0x06, 0x13, 0x63, 0x4b, 0xd5, 0x58, 0xc7, 0x34, 0xa0, 0x9d, 0xd5, 0xf9, 0x51,
+	0xeb, 0x8e, 0x52, 0x67, 0x91, 0x0b, 0x98, 0xe1, 0xb5, 0xb0, 0xb9, 0xb1, 0xcc, 0x36, 0x26, 0x1c,
+	0x0d, 0xc7, 0x7b, 0x7d, 0x2d, 0x6c, 0xe6, 0x10, 0x0a, 0xb8, 0xfd, 0x4e, 0x7e, 0x79, 0xae, 0x3d,
+	0xc5, 0x02, 0xc5, 0x06, 0x6f, 0x47, 0xac, 0x87, 0x30, 0xe6, 0x32, 0x17, 0xa5, 0xa3, 0x34, 0xa5,
+	0x3e, 0x97, 0x6f, 0x4a, 0xf2, 0x0c, 0x8e, 0xb9, 0xcc, 0x7b, 0x1d, 0x7c, 0x07, 0x06, 0x5c, 0xfe,
+	0xad, 0x4d, 0xce, 0x61, 0xc6, 0x65, 0xde, 0x18, 0xd4, 0x15, 0xbb, 0xc2, 0x70, 0xec, 0x42, 0x80,
+	0xcb, 0x55, 0xe7, 0x49, 0xbe, 0xc1, 0xd9, 0x2e, 0xfb, 0xbb, 0x54, 0xaf, 0x80, 0x47, 0xdb, 0xdd,
+	0xbd, 0xd4, 0xc5, 0x5a, 0x6c, 0xf0, 0xbf, 0xcb, 0x97, 0x7c, 0x87, 0x70, 0xbf, 0xc9, 0x1d, 0x4e,
+	0xb9, 0xfc, 0x71, 0x04, 0x90, 0x65, 0x97, 0x19, 0xea, 0x8d, 0x28, 0x90, 0x50, 0x38, 0x1e, 0x1c,
+	0x2c, 0x79, 0xfc, 0x27, 0xff, 0x5f, 0x3f, 0x5d, 0xf4, 0xe4, 0x00, 0xda, 0x4e, 0x90, 0xdc, 0x4b,
+	0xbd, 0x17, 0x1e, 0x59, 0xc1, 0x83, 0xe1, 0x1e, 0x49, 0x3f, 0x6d, 0xff, 0x3a, 0xa3, 0xa7, 0x87,
+	0xe0, 0x41, 0xd9, 0x0f, 0x30, 0xdf, 0x95, 0x8e, 0x9c, 0xef, 0xf1, 0x19, 0x6e, 0x2e, 0x8a, 0x0f,
+	0x07, 0xf4, 0x8b, 0x7f, 0x9c, 0xb8, 0xd7, 0xe6, 0xe2, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe6,
+	0xa6, 0x53, 0xee, 0x90, 0x04, 0x00, 0x00,
 }
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 054b04f63..7cbe63704 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -201,12 +201,12 @@
 			"revisionTime": "2017-12-31T12:27:32Z"
 		},
 		{
-			"checksumSHA1": "6rhb7Co+LU7N7p7es+y+79D8nwY=",
+			"checksumSHA1": "1Wl8zKKHxWE55uB6OouC5Ztz0lY=",
 			"path": "gitlab.com/gitlab-org/gitaly-proto/go",
-			"revision": "481b76004a78263bc5dc3827ed48767c5f1533ac",
-			"revisionTime": "2018-03-01T20:06:59Z",
-			"version": "v0.88.0",
-			"versionExact": "v0.88.0"
+			"revision": "4d256c2c6403d420c598c1649b1d26fa4384bb1d",
+			"revisionTime": "2018-03-08T23:20:01Z",
+			"version": "v0.89.0",
+			"versionExact": "v0.89.0"
 		},
 		{
 			"checksumSHA1": "nqWNlnMmVpt628zzvyo6Yv2CX5Q=",