Implement Gitaly call for archive requests

CHANGELOG

@@ -2,6 +2,10 @@
 
 Formerly known as 'gitlab-git-http-server'.
 
+UNRELEASED
+
+- Implement Gitaly call for archive requests !199
+
 v3.1.0
 
 - Add histograms to routes !184

gitaly_test.go

@@ -371,6 +371,62 @@ func TestGetBlobProxiedToGitalyInterruptedStream(t *testing.T) {
 	}
 }
 
+func TestGetArchiveProxiedToGitalySuccessfully(t *testing.T) {
+	gitalyServer, socketPath := startGitalyServer(t, codes.OK)
+	defer gitalyServer.Stop()
+
+	gitalyAddress := "unix://" + socketPath
+	repoStorage := "default"
+	oid := "54fcc214b94e78d7a41a9a8fe6d87a5e59500e51"
+	repoRelativePath := "foo/bar.git"
+	archivePath := "my/path"
+	archivePrefix := "repo-1"
+	jsonParams := fmt.Sprintf(`{"GitalyServer":{"Address":"%s","Token":""},"GitalyRepository":{"storage_name":"%s","relative_path":"%s"},"ArchivePath":"%s","ArchivePrefix":"%s","CommitId":"%s"}`,
+		gitalyAddress, repoStorage, repoRelativePath, archivePath, archivePrefix, oid)
+	expectedBody := testhelper.GitalyGetArchiveResponseMock
+	archiveLength := len(expectedBody)
+
+	resp, body, err := doSendDataRequest("/archive.tar.gz", "git-archive", jsonParams)
+	require.NoError(t, err)
+
+	assert.Equal(t, 200, resp.StatusCode, "GET %q: status code", resp.Request.URL)
+	assert.Equal(t, expectedBody, string(body), "GET %q: response body", resp.Request.URL)
+	assert.Equal(t, archiveLength, len(body), "GET %q: body size", resp.Request.URL)
+}
+
+func TestGetArchiveProxiedToGitalyInterruptedStream(t *testing.T) {
+	gitalyServer, socketPath := startGitalyServer(t, codes.OK)
+	defer gitalyServer.Stop()
+
+	gitalyAddress := "unix://" + socketPath
+	repoStorage := "default"
+	oid := "54fcc214b94e78d7a41a9a8fe6d87a5e59500e51"
+	repoRelativePath := "foo/bar.git"
+	archivePath := "my/path"
+	archivePrefix := "repo-1"
+	jsonParams := fmt.Sprintf(`{"GitalyServer":{"Address":"%s","Token":""},"GitalyRepository":{"storage_name":"%s","relative_path":"%s"},"ArchivePath":"%s","ArchivePrefix":"%s","CommitId":"%s"}`,
+		gitalyAddress, repoStorage, repoRelativePath, archivePath, archivePrefix, oid)
+
+	resp, _, err := doSendDataRequest("/archive.tar.gz", "git-archive", jsonParams)
+	require.NoError(t, err)
+
+	// This causes the server stream to be interrupted instead of consumed entirely.
+	resp.Body.Close()
+
+	done := make(chan struct{})
+	go func() {
+		gitalyServer.WaitGroup.Wait()
+		close(done)
+	}()
+
+	select {
+	case <-done:
+		return
+	case <-time.After(10 * time.Second):
+		t.Fatal("time out waiting for gitaly handler to return")
+	}
+}
+
 type combinedServer struct {
 	*grpc.Server
 	*testhelper.GitalyTestServer
@@ -388,6 +444,7 @@ func startGitalyServer(t *testing.T, finalMessageCode codes.Code) (*combinedServ
 	gitalyServer := testhelper.NewGitalyServer(finalMessageCode)
 	pb.RegisterSmartHTTPServiceServer(server, gitalyServer)
 	pb.RegisterBlobServiceServer(server, gitalyServer)
+	pb.RegisterRepositoryServiceServer(server, gitalyServer)
 
 	go server.Serve(listener)
 

internal/git/archive.go

@@ -14,6 +14,8 @@ import (
 	"path/filepath"
 	"time"
 
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+	"gitlab.com/gitlab-org/gitlab-workhorse/internal/gitaly"
 	"gitlab.com/gitlab-org/gitlab-workhorse/internal/helper"
 	"gitlab.com/gitlab-org/gitlab-workhorse/internal/senddata"
 
@@ -22,10 +24,12 @@ import (
 
 type archive struct{ senddata.Prefix }
 type archiveParams struct {
-	RepoPath      string
-	ArchivePath   string
-	ArchivePrefix string
-	CommitId      string
+	RepoPath         string
+	ArchivePath      string
+	ArchivePrefix    string
+	CommitId         string
+	GitalyServer     gitaly.Server
+	GitalyRepository pb.Repository
 }
 
 var (
@@ -84,7 +88,16 @@ func (a *archive) Inject(w http.ResponseWriter, r *http.Request, sendData string
 	defer tempFile.Close()
 	defer os.Remove(tempFile.Name())
 
-	archiveReader, err := newArchiveReader(r.Context(), params.RepoPath, format, params.ArchivePrefix, params.CommitId)
+	var archiveReader io.Reader
+	if params.GitalyServer.Address != "" {
+		archiveReader, err = handleArchiveWithGitaly(r, params, format)
+
+		if err != nil {
+			err = fmt.Errorf("operations.GetArchive: %v", err)
+		}
+	} else {
+		archiveReader, err = newArchiveReader(r.Context(), params.RepoPath, format, params.ArchivePrefix, params.CommitId)
+	}
 	if err != nil {
 		helper.Fail500(w, r, err)
 		return
@@ -106,10 +119,26 @@ func (a *archive) Inject(w http.ResponseWriter, r *http.Request, sendData string
 	}
 }
 
-func setArchiveHeaders(w http.ResponseWriter, format ArchiveFormat, archiveFilename string) {
+func handleArchiveWithGitaly(r *http.Request, params archiveParams, format pb.GetArchiveRequest_Format) (io.Reader, error) {
+	c, err := gitaly.NewRepositoryClient(params.GitalyServer)
+	if err != nil {
+		return nil, err
+	}
+
+	request := &pb.GetArchiveRequest{
+		Repository: &params.GitalyRepository,
+		CommitId:   params.CommitId,
+		Prefix:     params.ArchivePrefix,
+		Format:     format,
+	}
+
+	return c.ArchiveReader(r.Context(), request)
+}
+
+func setArchiveHeaders(w http.ResponseWriter, format pb.GetArchiveRequest_Format, archiveFilename string) {
 	w.Header().Del("Content-Length")
 	w.Header().Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, archiveFilename))
-	if format == ZipFormat {
+	if format == pb.GetArchiveRequest_ZIP {
 		w.Header().Set("Content-Type", "application/zip")
 	} else {
 		w.Header().Set("Content-Type", "application/octet-stream")
@@ -136,20 +165,20 @@ func finalizeCachedArchive(tempFile *os.File, archivePath string) error {
 	return nil
 }
 
-func parseBasename(basename string) (ArchiveFormat, bool) {
-	var format ArchiveFormat
+func parseBasename(basename string) (pb.GetArchiveRequest_Format, bool) {
+	var format pb.GetArchiveRequest_Format
 
 	switch basename {
 	case "archive.zip":
-		format = ZipFormat
+		format = pb.GetArchiveRequest_ZIP
 	case "archive.tar":
-		format = TarFormat
+		format = pb.GetArchiveRequest_TAR
 	case "archive", "archive.tar.gz", "archive.tgz", "archive.gz":
-		format = TarGzFormat
+		format = pb.GetArchiveRequest_TAR_GZ
 	case "archive.tar.bz2", "archive.tbz", "archive.tbz2", "archive.tb2", "archive.bz2":
-		format = TarBz2Format
+		format = pb.GetArchiveRequest_TAR_BZ2
 	default:
-		return InvalidFormat, false
+		return format, false
 	}
 
 	return format, true

internal/git/archive_test.go

@@ -5,23 +5,24 @@ import (
 	"net/http/httptest"
 	"testing"
 
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
 	"gitlab.com/gitlab-org/gitlab-workhorse/internal/testhelper"
 )
 
 func TestParseBasename(t *testing.T) {
 	for _, testCase := range []struct {
 		in  string
-		out ArchiveFormat
+		out pb.GetArchiveRequest_Format
 	}{
-		{"", TarGzFormat},
-		{".tar.gz", TarGzFormat},
-		{".tgz", TarGzFormat},
-		{".gz", TarGzFormat},
-		{".tar.bz2", TarBz2Format},
-		{".tbz", TarBz2Format},
-		{".tbz2", TarBz2Format},
-		{".tb2", TarBz2Format},
-		{".bz2", TarBz2Format},
+		{"", pb.GetArchiveRequest_TAR_GZ},
+		{".tar.gz", pb.GetArchiveRequest_TAR_GZ},
+		{".tgz", pb.GetArchiveRequest_TAR_GZ},
+		{".gz", pb.GetArchiveRequest_TAR_GZ},
+		{".tar.bz2", pb.GetArchiveRequest_TAR_BZ2},
+		{".tbz", pb.GetArchiveRequest_TAR_BZ2},
+		{".tbz2", pb.GetArchiveRequest_TAR_BZ2},
+		{".tb2", pb.GetArchiveRequest_TAR_BZ2},
+		{".bz2", pb.GetArchiveRequest_TAR_BZ2},
 	} {
 		basename := "archive" + testCase.in
 		out, ok := parseBasename(basename)
@@ -51,12 +52,13 @@ func TestFinalizeArchive(t *testing.T) {
 
 func TestSetArchiveHeaders(t *testing.T) {
 	for _, testCase := range []struct {
-		in  ArchiveFormat
+		in  pb.GetArchiveRequest_Format
 		out string
 	}{
-		{ZipFormat, "application/zip"},
-		{TarFormat, "application/octet-stream"},
-		{InvalidFormat, "application/octet-stream"},
+		{pb.GetArchiveRequest_ZIP, "application/zip"},
+		{pb.GetArchiveRequest_TAR, "application/octet-stream"},
+		{pb.GetArchiveRequest_TAR_GZ, "application/octet-stream"},
+		{pb.GetArchiveRequest_TAR_BZ2, "application/octet-stream"},
 	} {
 		w := httptest.NewRecorder()
 

internal/git/archivereader.go

@@ -7,28 +7,19 @@ import (
 	"os/exec"
 	"syscall"
 
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
 	"gitlab.com/gitlab-org/gitlab-workhorse/internal/helper"
 )
 
-type ArchiveFormat int
-
-const (
-	InvalidFormat ArchiveFormat = iota
-	ZipFormat
-	TarFormat
-	TarGzFormat
-	TarBz2Format
-)
-
-func parseArchiveFormat(format ArchiveFormat) (*exec.Cmd, string) {
+func parseArchiveFormat(format pb.GetArchiveRequest_Format) (*exec.Cmd, string) {
 	switch format {
-	case TarFormat:
+	case pb.GetArchiveRequest_TAR:
 		return nil, "tar"
-	case TarGzFormat:
+	case pb.GetArchiveRequest_TAR_GZ:
 		return exec.Command("gzip", "-c", "-n"), "tar"
-	case TarBz2Format:
+	case pb.GetArchiveRequest_TAR_BZ2:
 		return exec.Command("bzip2", "-c"), "tar"
-	case ZipFormat:
+	case pb.GetArchiveRequest_ZIP:
 		return nil, "zip"
 	default:
 		return nil, "invalid format"
@@ -70,7 +61,7 @@ func (a *archiveReader) wait() error {
 	return nil
 }
 
-func newArchiveReader(ctx context.Context, repoPath string, format ArchiveFormat, archivePrefix string, commitId string) (a *archiveReader, err error) {
+func newArchiveReader(ctx context.Context, repoPath string, format pb.GetArchiveRequest_Format, archivePrefix string, commitId string) (a *archiveReader, err error) {
 	a = &archiveReader{}
 
 	compressCmd, formatArg := parseArchiveFormat(format)

internal/gitaly/gitaly.go

@@ -41,6 +41,15 @@ func NewBlobClient(server Server) (*BlobClient, error) {
 	return &BlobClient{grpcClient}, nil
 }
 
+func NewRepositoryClient(server Server) (*RepositoryClient, error) {
+	conn, err := getOrCreateConnection(server)
+	if err != nil {
+		return nil, err
+	}
+	grpcClient := pb.NewRepositoryServiceClient(conn)
+	return &RepositoryClient{grpcClient}, nil
+}
+
 func getOrCreateConnection(server Server) (*grpc.ClientConn, error) {
 	cache.RLock()
 	conn := cache.connections[server]

internal/gitaly/repository.go

+package gitaly
+
+import (
+	"context"
+	"fmt"
+	"io"
+
+	pb "gitlab.com/gitlab-org/gitaly-proto/go"
+	"gitlab.com/gitlab-org/gitaly/streamio"
+)
+
+// RepositoryClient encapsulates RepositoryService calls
+type RepositoryClient struct {
+	pb.RepositoryServiceClient
+}
+
+// ArchiveReader performs a GetArchive Gitaly request and returns an io.Reader
+// for the response
+func (client *RepositoryClient) ArchiveReader(ctx context.Context, request *pb.GetArchiveRequest) (io.Reader, error) {
+	c, err := client.GetArchive(ctx, request)
+	if err != nil {
+		return nil, fmt.Errorf("RepositoryService::GetArchive: %v", err)
+	}
+
+	return streamio.NewReader(func() ([]byte, error) {
+		resp, err := c.Recv()
+
+		return resp.GetData(), err
+	}), nil
+}

internal/testhelper/gitaly.go

@@ -24,6 +24,7 @@ type GitalyTestServer struct {
 var (
 	GitalyInfoRefsResponseMock    = strings.Repeat("Mock Gitaly InfoRefsResponse data", 100000)
 	GitalyGetBlobResponseMock     = strings.Repeat("Mock Gitaly GetBlobResponse data", 100000)
+	GitalyGetArchiveResponseMock  = strings.Repeat("Mock Gitaly GetArchiveResponse data", 100000)
 	GitalyReceivePackResponseMock []byte
 	GitalyUploadPackResponseMock  []byte
 )
@@ -208,6 +209,63 @@ func (s *GitalyTestServer) GetBlob(in *pb.GetBlobRequest, stream pb.BlobService_
 	return s.finalError()
 }
 
+func (s *GitalyTestServer) GetArchive(in *pb.GetArchiveRequest, stream pb.RepositoryService_GetArchiveServer) error {
+	s.WaitGroup.Add(1)
+	defer s.WaitGroup.Done()
+
+	if err := validateRepository(in.GetRepository()); err != nil {
+		return err
+	}
+
+	nSends, err := sendBytes([]byte(GitalyGetArchiveResponseMock), 100, func(p []byte) error {
+		return stream.Send(&pb.GetArchiveResponse{Data: p})
+	})
+	if err != nil {
+		return err
+	}
+	if nSends <= 1 {
+		panic("should have sent more than one message")
+	}
+
+	return s.finalError()
+}
+
+func (s *GitalyTestServer) RepositoryExists(context.Context, *pb.RepositoryExistsRequest) (*pb.RepositoryExistsResponse, error) {
+	return nil, nil
+}
+
+func (s *GitalyTestServer) RepackIncremental(context.Context, *pb.RepackIncrementalRequest) (*pb.RepackIncrementalResponse, error) {
+	return nil, nil
+}
+
+func (s *GitalyTestServer) RepackFull(context.Context, *pb.RepackFullRequest) (*pb.RepackFullResponse, error) {
+	return nil, nil
+}
+
+func (s *GitalyTestServer) GarbageCollect(context.Context, *pb.GarbageCollectRequest) (*pb.GarbageCollectResponse, error) {
+	return nil, nil
+}
+
+func (s *GitalyTestServer) RepositorySize(context.Context, *pb.RepositorySizeRequest) (*pb.RepositorySizeResponse, error) {
+	return nil, nil
+}
+
+func (s *GitalyTestServer) ApplyGitattributes(context.Context, *pb.ApplyGitattributesRequest) (*pb.ApplyGitattributesResponse, error) {
+	return nil, nil
+}
+
+func (s *GitalyTestServer) FetchRemote(context.Context, *pb.FetchRemoteRequest) (*pb.FetchRemoteResponse, error) {
+	return nil, nil
+}
+
+func (s *GitalyTestServer) CreateRepository(context.Context, *pb.CreateRepositoryRequest) (*pb.CreateRepositoryResponse, error) {
+	return nil, nil
+}
+
+func (s *GitalyTestServer) Exists(context.Context, *pb.RepositoryExistsRequest) (*pb.RepositoryExistsResponse, error) {
+	return nil, nil
+}
+
 // sendBytes returns the number of times the 'sender' function was called and an error.
 func sendBytes(data []byte, chunkSize int, sender func([]byte) error) (int, error) {
 	i := 0

vendor/gitlab.com/gitlab-org/gitaly-proto/go/VERSION

-0.35.0
+0.38.0

vendor/gitlab.com/gitlab-org/gitaly-proto/go/blob.pb.go

@@ -69,8 +69,12 @@ It has these top-level messages:
 	PostReceiveResponse
 	UserCreateBranchRequest
 	UserCreateBranchResponse
+	UserDeleteBranchRequest
+	UserDeleteBranchResponse
 	UserDeleteTagRequest
 	UserDeleteTagResponse
+	UserCreateTagRequest
+	UserCreateTagResponse
 	FindDefaultBranchNameRequest
 	FindDefaultBranchNameResponse
 	FindAllBranchNamesRequest
@@ -111,11 +115,14 @@ It has these top-level messages:
 	FetchRemoteResponse
 	CreateRepositoryRequest
 	CreateRepositoryResponse
+	GetArchiveRequest
+	GetArchiveResponse
 	Repository
 	GitCommit
 	CommitAuthor
 	ExitStatus
 	Branch
+	Tag
 	User
 	InfoRefsRequest
 	InfoRefsResponse

vendor/gitlab.com/gitlab-org/gitaly-proto/go/operations.pb.go

@@ -59,6 +59,9 @@ func (m *UserCreateBranchRequest) GetStartPoint() []byte {
 
 type UserCreateBranchResponse struct {
 	Branch *Branch `protobuf:"bytes,1,opt,name=branch" json:"branch,omitempty"`
+	// Error returned by the pre-receive hook. If no error was thrown,
+	// it's the empty string ("")
+	PreReceiveError string `protobuf:"bytes,2,opt,name=pre_receive_error,json=preReceiveError" json:"pre_receive_error,omitempty"`
 }
 
 func (m *UserCreateBranchResponse) Reset()                    { *m = UserCreateBranchResponse{} }
@@ -73,6 +76,61 @@ func (m *UserCreateBranchResponse) GetBranch() *Branch {
 	return nil
 }
 
+func (m *UserCreateBranchResponse) GetPreReceiveError() string {
+	if m != nil {
+		return m.PreReceiveError
+	}
+	return ""
+}
+
+type UserDeleteBranchRequest struct {
+	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	BranchName []byte      `protobuf:"bytes,2,opt,name=branch_name,json=branchName,proto3" json:"branch_name,omitempty"`
+	User       *User       `protobuf:"bytes,3,opt,name=user" json:"user,omitempty"`
+}
+
+func (m *UserDeleteBranchRequest) Reset()                    { *m = UserDeleteBranchRequest{} }
+func (m *UserDeleteBranchRequest) String() string            { return proto.CompactTextString(m) }
+func (*UserDeleteBranchRequest) ProtoMessage()               {}
+func (*UserDeleteBranchRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{2} }
+
+func (m *UserDeleteBranchRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *UserDeleteBranchRequest) GetBranchName() []byte {
+	if m != nil {
+		return m.BranchName
+	}
+	return nil
+}
+
+func (m *UserDeleteBranchRequest) GetUser() *User {
+	if m != nil {
+		return m.User
+	}
+	return nil
+}
+
+type UserDeleteBranchResponse struct {
+	PreReceiveError string `protobuf:"bytes,1,opt,name=pre_receive_error,json=preReceiveError" json:"pre_receive_error,omitempty"`
+}
+
+func (m *UserDeleteBranchResponse) Reset()                    { *m = UserDeleteBranchResponse{} }
+func (m *UserDeleteBranchResponse) String() string            { return proto.CompactTextString(m) }
+func (*UserDeleteBranchResponse) ProtoMessage()               {}
+func (*UserDeleteBranchResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{3} }
+
+func (m *UserDeleteBranchResponse) GetPreReceiveError() string {
+	if m != nil {
+		return m.PreReceiveError
+	}
+	return ""
+}
+
 type UserDeleteTagRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
 	TagName    []byte      `protobuf:"bytes,2,opt,name=tag_name,json=tagName,proto3" json:"tag_name,omitempty"`
@@ -82,7 +140,7 @@ type UserDeleteTagRequest struct {
 func (m *UserDeleteTagRequest) Reset()                    { *m = UserDeleteTagRequest{} }
 func (m *UserDeleteTagRequest) String() string            { return proto.CompactTextString(m) }
 func (*UserDeleteTagRequest) ProtoMessage()               {}
-func (*UserDeleteTagRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{2} }
+func (*UserDeleteTagRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{4} }
 
 func (m *UserDeleteTagRequest) GetRepository() *Repository {
 	if m != nil {
@@ -106,18 +164,110 @@ func (m *UserDeleteTagRequest) GetUser() *User {
 }
 
 type UserDeleteTagResponse struct {
+	PreReceiveError string `protobuf:"bytes,1,opt,name=pre_receive_error,json=preReceiveError" json:"pre_receive_error,omitempty"`
 }
 
 func (m *UserDeleteTagResponse) Reset()                    { *m = UserDeleteTagResponse{} }
 func (m *UserDeleteTagResponse) String() string            { return proto.CompactTextString(m) }
 func (*UserDeleteTagResponse) ProtoMessage()               {}
-func (*UserDeleteTagResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{3} }
+func (*UserDeleteTagResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{5} }
+
+func (m *UserDeleteTagResponse) GetPreReceiveError() string {
+	if m != nil {
+		return m.PreReceiveError
+	}
+	return ""
+}
+
+type UserCreateTagRequest struct {
+	Repository     *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	TagName        []byte      `protobuf:"bytes,2,opt,name=tag_name,json=tagName,proto3" json:"tag_name,omitempty"`
+	User           *User       `protobuf:"bytes,3,opt,name=user" json:"user,omitempty"`
+	TargetRevision []byte      `protobuf:"bytes,4,opt,name=target_revision,json=targetRevision,proto3" json:"target_revision,omitempty"`
+	Message        []byte      `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"`
+}
+
+func (m *UserCreateTagRequest) Reset()                    { *m = UserCreateTagRequest{} }
+func (m *UserCreateTagRequest) String() string            { return proto.CompactTextString(m) }
+func (*UserCreateTagRequest) ProtoMessage()               {}
+func (*UserCreateTagRequest) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{6} }
+
+func (m *UserCreateTagRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *UserCreateTagRequest) GetTagName() []byte {
+	if m != nil {
+		return m.TagName
+	}
+	return nil
+}
+
+func (m *UserCreateTagRequest) GetUser() *User {
+	if m != nil {
+		return m.User
+	}
+	return nil
+}
+
+func (m *UserCreateTagRequest) GetTargetRevision() []byte {
+	if m != nil {
+		return m.TargetRevision
+	}
+	return nil
+}
+
+func (m *UserCreateTagRequest) GetMessage() []byte {
+	if m != nil {
+		return m.Message
+	}
+	return nil
+}
+
+type UserCreateTagResponse struct {
+	Tag             *Tag   `protobuf:"bytes,1,opt,name=tag" json:"tag,omitempty"`
+	Exists          bool   `protobuf:"varint,2,opt,name=exists" json:"exists,omitempty"`
+	PreReceiveError string `protobuf:"bytes,3,opt,name=pre_receive_error,json=preReceiveError" json:"pre_receive_error,omitempty"`
+}
+
+func (m *UserCreateTagResponse) Reset()                    { *m = UserCreateTagResponse{} }
+func (m *UserCreateTagResponse) String() string            { return proto.CompactTextString(m) }
+func (*UserCreateTagResponse) ProtoMessage()               {}
+func (*UserCreateTagResponse) Descriptor() ([]byte, []int) { return fileDescriptor6, []int{7} }
+
+func (m *UserCreateTagResponse) GetTag() *Tag {
+	if m != nil {
+		return m.Tag
+	}
+	return nil
+}
+
+func (m *UserCreateTagResponse) GetExists() bool {
+	if m != nil {
+		return m.Exists
+	}
+	return false
+}
+
+func (m *UserCreateTagResponse) GetPreReceiveError() string {
+	if m != nil {
+		return m.PreReceiveError
+	}
+	return ""
+}
 
 func init() {
 	proto.RegisterType((*UserCreateBranchRequest)(nil), "gitaly.UserCreateBranchRequest")
 	proto.RegisterType((*UserCreateBranchResponse)(nil), "gitaly.UserCreateBranchResponse")
+	proto.RegisterType((*UserDeleteBranchRequest)(nil), "gitaly.UserDeleteBranchRequest")
+	proto.RegisterType((*UserDeleteBranchResponse)(nil), "gitaly.UserDeleteBranchResponse")
 	proto.RegisterType((*UserDeleteTagRequest)(nil), "gitaly.UserDeleteTagRequest")
 	proto.RegisterType((*UserDeleteTagResponse)(nil), "gitaly.UserDeleteTagResponse")
+	proto.RegisterType((*UserCreateTagRequest)(nil), "gitaly.UserCreateTagRequest")
+	proto.RegisterType((*UserCreateTagResponse)(nil), "gitaly.UserCreateTagResponse")
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -132,6 +282,8 @@ const _ = grpc.SupportPackageIsVersion4
 
 type OperationServiceClient interface {
 	UserCreateBranch(ctx context.Context, in *UserCreateBranchRequest, opts ...grpc.CallOption) (*UserCreateBranchResponse, error)
+	UserDeleteBranch(ctx context.Context, in *UserDeleteBranchRequest, opts ...grpc.CallOption) (*UserDeleteBranchResponse, error)
+	UserCreateTag(ctx context.Context, in *UserCreateTagRequest, opts ...grpc.CallOption) (*UserCreateTagResponse, error)
 	UserDeleteTag(ctx context.Context, in *UserDeleteTagRequest, opts ...grpc.CallOption) (*UserDeleteTagResponse, error)
 }
 
@@ -152,6 +304,24 @@ func (c *operationServiceClient) UserCreateBranch(ctx context.Context, in *UserC
 	return out, nil
 }
 
+func (c *operationServiceClient) UserDeleteBranch(ctx context.Context, in *UserDeleteBranchRequest, opts ...grpc.CallOption) (*UserDeleteBranchResponse, error) {
+	out := new(UserDeleteBranchResponse)
+	err := grpc.Invoke(ctx, "/gitaly.OperationService/UserDeleteBranch", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *operationServiceClient) UserCreateTag(ctx context.Context, in *UserCreateTagRequest, opts ...grpc.CallOption) (*UserCreateTagResponse, error) {
+	out := new(UserCreateTagResponse)
+	err := grpc.Invoke(ctx, "/gitaly.OperationService/UserCreateTag", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *operationServiceClient) UserDeleteTag(ctx context.Context, in *UserDeleteTagRequest, opts ...grpc.CallOption) (*UserDeleteTagResponse, error) {
 	out := new(UserDeleteTagResponse)
 	err := grpc.Invoke(ctx, "/gitaly.OperationService/UserDeleteTag", in, out, c.cc, opts...)
@@ -165,6 +335,8 @@ func (c *operationServiceClient) UserDeleteTag(ctx context.Context, in *UserDele
 
 type OperationServiceServer interface {
 	UserCreateBranch(context.Context, *UserCreateBranchRequest) (*UserCreateBranchResponse, error)
+	UserDeleteBranch(context.Context, *UserDeleteBranchRequest) (*UserDeleteBranchResponse, error)
+	UserCreateTag(context.Context, *UserCreateTagRequest) (*UserCreateTagResponse, error)
 	UserDeleteTag(context.Context, *UserDeleteTagRequest) (*UserDeleteTagResponse, error)
 }
 
@@ -190,6 +362,42 @@ func _OperationService_UserCreateBranch_Handler(srv interface{}, ctx context.Con
 	return interceptor(ctx, in, info, handler)
 }
 
+func _OperationService_UserDeleteBranch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UserDeleteBranchRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(OperationServiceServer).UserDeleteBranch(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.OperationService/UserDeleteBranch",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(OperationServiceServer).UserDeleteBranch(ctx, req.(*UserDeleteBranchRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _OperationService_UserCreateTag_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UserCreateTagRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(OperationServiceServer).UserCreateTag(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/gitaly.OperationService/UserCreateTag",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(OperationServiceServer).UserCreateTag(ctx, req.(*UserCreateTagRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _OperationService_UserDeleteTag_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(UserDeleteTagRequest)
 	if err := dec(in); err != nil {
@@ -216,6 +424,14 @@ var _OperationService_serviceDesc = grpc.ServiceDesc{
 			MethodName: "UserCreateBranch",
 			Handler:    _OperationService_UserCreateBranch_Handler,
 		},
+		{
+			MethodName: "UserDeleteBranch",
+			Handler:    _OperationService_UserDeleteBranch_Handler,
+		},
+		{
+			MethodName: "UserCreateTag",
+			Handler:    _OperationService_UserCreateTag_Handler,
+		},
 		{
 			MethodName: "UserDeleteTag",
 			Handler:    _OperationService_UserDeleteTag_Handler,
@@ -228,25 +444,35 @@ var _OperationService_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("operations.proto", fileDescriptor6) }
 
 var fileDescriptor6 = []byte{
-	// 308 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x92, 0xc1, 0x4a, 0xfb, 0x40,
-	0x10, 0xc6, 0xff, 0xfb, 0xb7, 0x54, 0x99, 0x46, 0x09, 0x8b, 0xd2, 0x18, 0x94, 0x86, 0x1c, 0xa4,
-	0xa7, 0x1c, 0xe2, 0x1b, 0x54, 0xcf, 0x55, 0xa2, 0xe2, 0xb1, 0x6c, 0xeb, 0x90, 0x06, 0xda, 0x6c,
-	0x9c, 0x9d, 0x0a, 0x7d, 0x02, 0x9f, 0xc7, 0xb3, 0x2f, 0x27, 0xc9, 0x26, 0x12, 0xa3, 0x05, 0xc1,
-	0xeb, 0xf7, 0x4d, 0x7e, 0xf3, 0x7d, 0x99, 0x05, 0x57, 0x17, 0x48, 0x8a, 0x33, 0x9d, 0x9b, 0xa8,
-	0x20, 0xcd, 0x5a, 0xf6, 0xd3, 0x8c, 0xd5, 0x6a, 0xeb, 0x3b, 0x66, 0xa9, 0x08, 0x9f, 0xac, 0x1a,
-	0xbe, 0x09, 0x18, 0x3e, 0x18, 0xa4, 0x2b, 0x42, 0xc5, 0x38, 0x21, 0x95, 0x2f, 0x96, 0x09, 0x3e,
-	0x6f, 0xd0, 0xb0, 0x8c, 0x01, 0x08, 0x0b, 0x6d, 0x32, 0xd6, 0xb4, 0xf5, 0x44, 0x20, 0xc6, 0x83,
-	0x58, 0x46, 0x16, 0x13, 0x25, 0x9f, 0x4e, 0xd2, 0x9a, 0x92, 0x23, 0x18, 0xcc, 0x2b, 0xc8, 0x2c,
-	0x57, 0x6b, 0xf4, 0xfe, 0x07, 0x62, 0xec, 0x24, 0x60, 0xa5, 0xa9, 0x5a, 0xa3, 0x0c, 0xa0, 0xb7,
-	0x31, 0x48, 0xde, 0x5e, 0x85, 0x73, 0x1a, 0x5c, 0x99, 0x21, 0xa9, 0x9c, 0x12, 0x61, 0x58, 0x11,
-	0xcf, 0x0a, 0x9d, 0xe5, 0xec, 0xf5, 0x2c, 0xa2, 0x92, 0x6e, 0x4b, 0x25, 0x9c, 0x80, 0xf7, 0x3d,
-	0xb2, 0x29, 0x74, 0x6e, 0x50, 0x5e, 0x40, 0xdf, 0x2e, 0xab, 0xf3, 0x1e, 0x35, 0x0b, 0xea, 0xb9,
-	0xda, 0x0d, 0x5f, 0x05, 0x1c, 0x97, 0x90, 0x6b, 0x5c, 0x21, 0xe3, 0xbd, 0x4a, 0xff, 0x52, 0xfa,
-	0x14, 0x0e, 0x58, 0xa5, 0xed, 0xc6, 0xfb, 0xac, 0xd2, 0xdf, 0xd5, 0x0d, 0x87, 0x70, 0xd2, 0x09,
-	0x62, 0xab, 0xc4, 0xef, 0x02, 0xdc, 0x9b, 0xe6, 0x8a, 0x77, 0x48, 0x2f, 0xd9, 0x02, 0xe5, 0x23,
-	0xb8, 0xdd, 0xee, 0x72, 0xd4, 0xa6, 0xfe, 0x70, 0x48, 0x3f, 0xd8, 0x3d, 0x60, 0x77, 0x85, 0xff,
-	0xe4, 0x14, 0x0e, 0xbf, 0xc4, 0x90, 0x67, 0xed, 0x8f, 0xba, 0xbf, 0xc9, 0x3f, 0xdf, 0xe1, 0x36,
-	0xbc, 0x79, 0xbf, 0x7a, 0x5f, 0x97, 0x1f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xc3, 0x75, 0xe5, 0x7b,
-	0x89, 0x02, 0x00, 0x00,
+	// 472 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x54, 0xcd, 0x6e, 0xd3, 0x40,
+	0x10, 0x8e, 0x9b, 0xe2, 0x96, 0x49, 0x68, 0xc3, 0x8a, 0x1f, 0x13, 0x51, 0xd5, 0xda, 0x03, 0x54,
+	0x1c, 0x72, 0x08, 0x6f, 0x40, 0x81, 0x63, 0x41, 0x0b, 0x88, 0xa3, 0xb5, 0x0d, 0x23, 0x77, 0xa5,
+	0xc6, 0x6b, 0x66, 0x37, 0x11, 0xe1, 0x05, 0xb8, 0xf2, 0x2a, 0xbc, 0x06, 0xcf, 0xc1, 0x83, 0x20,
+	0x7b, 0xd7, 0x89, 0xed, 0x38, 0x12, 0x82, 0x03, 0x3d, 0xee, 0x37, 0xa3, 0x6f, 0xbe, 0xef, 0xd3,
+	0xcc, 0xc2, 0x48, 0xe7, 0x48, 0xd2, 0x2a, 0x9d, 0x99, 0x49, 0x4e, 0xda, 0x6a, 0x16, 0xa6, 0xca,
+	0xca, 0xeb, 0xd5, 0x78, 0x68, 0xae, 0x24, 0xe1, 0x27, 0x87, 0xf2, 0x1f, 0x01, 0x3c, 0xfc, 0x60,
+	0x90, 0xce, 0x09, 0xa5, 0xc5, 0x17, 0x24, 0xb3, 0xd9, 0x95, 0xc0, 0xcf, 0x0b, 0x34, 0x96, 0x4d,
+	0x01, 0x08, 0x73, 0x6d, 0x94, 0xd5, 0xb4, 0x8a, 0x82, 0x38, 0x38, 0x1b, 0x4c, 0xd9, 0xc4, 0xd1,
+	0x4c, 0xc4, 0xba, 0x22, 0x6a, 0x5d, 0xec, 0x14, 0x06, 0x97, 0x25, 0x49, 0x92, 0xc9, 0x39, 0x46,
+	0x7b, 0x71, 0x70, 0x36, 0x14, 0xe0, 0xa0, 0x0b, 0x39, 0x47, 0x16, 0xc3, 0xfe, 0xc2, 0x20, 0x45,
+	0xfd, 0x92, 0x6e, 0x58, 0xd1, 0x15, 0x1a, 0x44, 0x59, 0x29, 0x28, 0x8c, 0x95, 0x64, 0x93, 0x5c,
+	0xab, 0xcc, 0x46, 0xfb, 0x8e, 0xa2, 0x84, 0xde, 0x16, 0x08, 0xcf, 0x20, 0xda, 0x96, 0x6c, 0x72,
+	0x9d, 0x19, 0x64, 0x4f, 0x20, 0x74, 0xc3, 0xbc, 0xde, 0xa3, 0x6a, 0x80, 0xef, 0xf3, 0x55, 0xf6,
+	0x0c, 0xee, 0xe6, 0x84, 0x09, 0xe1, 0x0c, 0xd5, 0x12, 0x13, 0x24, 0xd2, 0x54, 0xaa, 0xbd, 0x2d,
+	0x8e, 0x73, 0x42, 0xe1, 0xf0, 0x57, 0x05, 0xcc, 0xbf, 0xfb, 0x8c, 0x5e, 0xe2, 0x35, 0xde, 0x8c,
+	0x8c, 0xf8, 0x6b, 0x17, 0x41, 0x53, 0x91, 0x8f, 0xa0, 0xd3, 0x5a, 0xd0, 0x6d, 0xed, 0x5b, 0x00,
+	0xf7, 0x36, 0x44, 0xef, 0x65, 0xfa, 0x2f, 0xbe, 0x1e, 0xc1, 0xa1, 0x95, 0x69, 0xdd, 0xd4, 0x81,
+	0x95, 0xe9, 0x1f, 0x3a, 0x3a, 0x87, 0xfb, 0x2d, 0x21, 0x7f, 0x61, 0xe7, 0xa7, 0xb7, 0xe3, 0x56,
+	0xe3, 0x3f, 0xda, 0x61, 0x4f, 0xe1, 0xd8, 0x4a, 0x4a, 0xd1, 0x26, 0x84, 0x4b, 0x65, 0x94, 0xce,
+	0xfc, 0x22, 0x1f, 0x39, 0x58, 0x78, 0x94, 0x45, 0x70, 0x30, 0x47, 0x63, 0x64, 0x8a, 0xd1, 0x2d,
+	0x37, 0xc4, 0x3f, 0xf9, 0x57, 0x97, 0x48, 0xcd, 0x8b, 0x4f, 0xe4, 0x04, 0xfa, 0x56, 0xa6, 0xde,
+	0xc5, 0xa0, 0x1a, 0x5e, 0x74, 0x14, 0x38, 0x7b, 0x00, 0x21, 0x7e, 0x51, 0xc6, 0x9a, 0x52, 0xf5,
+	0xa1, 0xf0, 0xaf, 0xee, 0x20, 0xfb, 0x9d, 0x41, 0x4e, 0x7f, 0xed, 0xc1, 0xe8, 0x4d, 0xf5, 0x83,
+	0xbc, 0x43, 0x5a, 0xaa, 0x19, 0xb2, 0x8f, 0x30, 0x6a, 0xdf, 0x1d, 0x3b, 0xad, 0x7b, 0xef, 0xf8,
+	0x44, 0xc6, 0xf1, 0xee, 0x06, 0x67, 0x87, 0xf7, 0x2a, 0xe2, 0xfa, 0x36, 0x37, 0x89, 0x3b, 0x2e,
+	0xaf, 0x49, 0xdc, 0x75, 0x08, 0xbc, 0xc7, 0x2e, 0xe0, 0x4e, 0x23, 0x42, 0xf6, 0x78, 0x5b, 0xcd,
+	0x66, 0x4b, 0xc6, 0x27, 0x3b, 0xaa, 0x6d, 0xbe, 0xf5, 0x92, 0x36, 0xf9, 0xda, 0x47, 0xd4, 0xe4,
+	0xdb, 0xda, 0x6c, 0xde, 0xbb, 0x0c, 0xcb, 0x4f, 0xf8, 0xf9, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff,
+	0x4d, 0x0d, 0x02, 0xa3, 0xae, 0x05, 0x00, 0x00,
 }

vendor/gitlab.com/gitlab-org/gitaly-proto/go/ref.pb.go

@@ -415,7 +415,7 @@ func (m *FindAllTagsRequest) GetRepository() *Repository {
 }
 
 type FindAllTagsResponse struct {
-	Tags []*FindAllTagsResponse_Tag `protobuf:"bytes,1,rep,name=tags" json:"tags,omitempty"`
+	Tags []*Tag `protobuf:"bytes,1,rep,name=tags" json:"tags,omitempty"`
 }
 
 func (m *FindAllTagsResponse) Reset()                    { *m = FindAllTagsResponse{} }
@@ -423,53 +423,13 @@ func (m *FindAllTagsResponse) String() string            { return proto.CompactT
 func (*FindAllTagsResponse) ProtoMessage()               {}
 func (*FindAllTagsResponse) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{15} }
 
-func (m *FindAllTagsResponse) GetTags() []*FindAllTagsResponse_Tag {
+func (m *FindAllTagsResponse) GetTags() []*Tag {
 	if m != nil {
 		return m.Tags
 	}
 	return nil
 }
 
-type FindAllTagsResponse_Tag struct {
-	Name         []byte     `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
-	Id           string     `protobuf:"bytes,2,opt,name=id" json:"id,omitempty"`
-	TargetCommit *GitCommit `protobuf:"bytes,3,opt,name=target_commit,json=targetCommit" json:"target_commit,omitempty"`
-	Message      []byte     `protobuf:"bytes,4,opt,name=message,proto3" json:"message,omitempty"`
-}
-
-func (m *FindAllTagsResponse_Tag) Reset()                    { *m = FindAllTagsResponse_Tag{} }
-func (m *FindAllTagsResponse_Tag) String() string            { return proto.CompactTextString(m) }
-func (*FindAllTagsResponse_Tag) ProtoMessage()               {}
-func (*FindAllTagsResponse_Tag) Descriptor() ([]byte, []int) { return fileDescriptor7, []int{15, 0} }
-
-func (m *FindAllTagsResponse_Tag) GetName() []byte {
-	if m != nil {
-		return m.Name
-	}
-	return nil
-}
-
-func (m *FindAllTagsResponse_Tag) GetId() string {
-	if m != nil {
-		return m.Id
-	}
-	return ""
-}
-
-func (m *FindAllTagsResponse_Tag) GetTargetCommit() *GitCommit {
-	if m != nil {
-		return m.TargetCommit
-	}
-	return nil
-}
-
-func (m *FindAllTagsResponse_Tag) GetMessage() []byte {
-	if m != nil {
-		return m.Message
-	}
-	return nil
-}
-
 type RefExistsRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
 	// Any ref, e.g. 'refs/heads/master' or 'refs/tags/v1.0.1'. Must start with 'refs/'.
@@ -659,7 +619,6 @@ func init() {
 	proto.RegisterType((*FindAllBranchesResponse_Branch)(nil), "gitaly.FindAllBranchesResponse.Branch")
 	proto.RegisterType((*FindAllTagsRequest)(nil), "gitaly.FindAllTagsRequest")
 	proto.RegisterType((*FindAllTagsResponse)(nil), "gitaly.FindAllTagsResponse")
-	proto.RegisterType((*FindAllTagsResponse_Tag)(nil), "gitaly.FindAllTagsResponse.Tag")
 	proto.RegisterType((*RefExistsRequest)(nil), "gitaly.RefExistsRequest")
 	proto.RegisterType((*RefExistsResponse)(nil), "gitaly.RefExistsResponse")
 	proto.RegisterType((*CreateBranchRequest)(nil), "gitaly.CreateBranchRequest")
@@ -1217,71 +1176,68 @@ var _RefService_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("ref.proto", fileDescriptor7) }
 
 var fileDescriptor7 = []byte{
-	// 1053 bytes of a gzipped FileDescriptorProto
+	// 1007 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x51, 0x73, 0x22, 0x45,
-	0x10, 0xce, 0x12, 0x6e, 0x93, 0x34, 0x1c, 0xd9, 0x4c, 0x62, 0x8e, 0x2c, 0xe7, 0x25, 0x37, 0x7a,
-	0x67, 0xf2, 0xb2, 0xb1, 0x48, 0xe9, 0x8b, 0x3e, 0x48, 0x00, 0x2f, 0x78, 0x91, 0xa4, 0x06, 0xbc,
-	0x4a, 0x95, 0x5a, 0xd4, 0x00, 0x03, 0x59, 0x0b, 0x58, 0xdc, 0x1d, 0xce, 0x4b, 0x59, 0xfa, 0x07,
-	0xfc, 0x0f, 0x3e, 0xfa, 0x57, 0xee, 0xc1, 0x3f, 0x65, 0x31, 0x33, 0xbb, 0xec, 0x92, 0x81, 0xb3,
-	0xc4, 0x7b, 0x82, 0xe9, 0xe9, 0xfe, 0x66, 0xfa, 0x9b, 0xee, 0x6f, 0x1b, 0xb6, 0x7c, 0xd6, 0x73,
-	0xc6, 0xbe, 0xc7, 0x3d, 0x64, 0xf6, 0x5d, 0x4e, 0x07, 0x77, 0x76, 0x36, 0xb8, 0xa5, 0x3e, 0xeb,
-	0x4a, 0xab, 0x7d, 0xd8, 0xf7, 0xbc, 0xfe, 0x80, 0x9d, 0x8a, 0x55, 0x7b, 0xd2, 0x3b, 0xe5, 0xee,
-	0x90, 0x05, 0x9c, 0x0e, 0xc7, 0xd2, 0x01, 0x13, 0x78, 0xfc, 0xb5, 0x3b, 0xea, 0x56, 0x58, 0x8f,
-	0x4e, 0x06, 0xfc, 0xdc, 0xa7, 0xa3, 0xce, 0x6d, 0x9d, 0x0e, 0x19, 0x61, 0x3f, 0x4f, 0x58, 0xc0,
-	0x51, 0x11, 0xc0, 0x67, 0x63, 0x2f, 0x70, 0xb9, 0xe7, 0xdf, 0xe5, 0x8d, 0x23, 0xe3, 0x38, 0x53,
-	0x44, 0x8e, 0x3c, 0xcb, 0x21, 0xd1, 0x0e, 0x89, 0x79, 0xe1, 0x33, 0xf8, 0x70, 0x01, 0x66, 0x30,
-	0xf6, 0x46, 0x01, 0x43, 0x08, 0xd2, 0x23, 0x3a, 0x64, 0x02, 0x2e, 0x4b, 0xc4, 0x7f, 0x7c, 0x05,
-	0x07, 0xd3, 0xa0, 0xd2, 0x60, 0x30, 0x0b, 0x08, 0x56, 0xb9, 0x45, 0x11, 0x6c, 0x1d, 0xa0, 0xba,
-	0xc2, 0x1e, 0x3c, 0x98, 0x1e, 0x1b, 0xe4, 0x8d, 0xa3, 0xf5, 0xe3, 0x2c, 0x91, 0x0b, 0x7c, 0x09,
-	0xfb, 0x2a, 0xa6, 0x49, 0xfb, 0x2b, 0xdf, 0xe0, 0x14, 0x1e, 0xdd, 0x43, 0x5b, 0x7a, 0xfc, 0x6f,
-	0x80, 0xa6, 0x01, 0x84, 0xf5, 0x56, 0x7c, 0x02, 0x54, 0x80, 0xad, 0x8e, 0x37, 0x1c, 0xba, 0xbc,
-	0xe5, 0x76, 0xf3, 0xa9, 0x23, 0xe3, 0x78, 0x8b, 0x6c, 0x4a, 0x43, 0xad, 0x8b, 0xf6, 0xc1, 0x1c,
-	0xfb, 0xac, 0xe7, 0xbe, 0xc9, 0xaf, 0x8b, 0x07, 0x50, 0x2b, 0x7c, 0x02, 0xbb, 0x89, 0xe3, 0x97,
-	0xbc, 0xd6, 0x5b, 0x03, 0xf2, 0x53, 0xdf, 0x4b, 0xaf, 0x43, 0x15, 0xbf, 0x2b, 0x71, 0x85, 0xbe,
-	0x82, 0x8d, 0xc0, 0xf3, 0x79, 0xab, 0x7d, 0x27, 0xae, 0x9b, 0x2b, 0x7e, 0x12, 0x06, 0x2c, 0x3a,
-	0xc6, 0x69, 0x78, 0x3e, 0x3f, 0xbf, 0x23, 0x66, 0x20, 0x7e, 0xf1, 0x67, 0x60, 0x4a, 0x0b, 0xda,
-	0x84, 0x74, 0xbd, 0xf4, 0x6d, 0xd5, 0x5a, 0x43, 0xdb, 0x90, 0xf9, 0xee, 0xba, 0x52, 0x6a, 0x56,
-	0x2b, 0xad, 0x52, 0xa3, 0x6c, 0x19, 0xc8, 0x82, 0x6c, 0x68, 0xa8, 0x54, 0x1b, 0x65, 0x2b, 0x85,
-	0x6f, 0x64, 0xdd, 0xcd, 0x9d, 0xa0, 0x52, 0xff, 0x02, 0x36, 0xdb, 0xca, 0x26, 0x5e, 0x2a, 0x53,
-	0x3c, 0x5c, 0x70, 0xad, 0x30, 0x84, 0x44, 0x01, 0xf8, 0x8f, 0x94, 0x7c, 0x7f, 0x8d, 0x97, 0x8e,
-	0xd3, 0xe5, 0x6f, 0xf6, 0x0c, 0x72, 0x6a, 0x33, 0x98, 0xb4, 0x7f, 0x62, 0x1d, 0xae, 0xde, 0xee,
-	0xa1, 0xb4, 0x36, 0xa4, 0x11, 0x5d, 0x80, 0x32, 0xb4, 0xe8, 0x84, 0xdf, 0x7a, 0x7e, 0x3e, 0x2d,
-	0xd8, 0xff, 0x68, 0xc1, 0xad, 0xcb, 0xc2, 0xb7, 0x24, 0x5c, 0x49, 0xb6, 0x13, 0x5b, 0xa1, 0x3a,
-	0x58, 0x0a, 0x49, 0xfe, 0x70, 0xe6, 0xe7, 0x1f, 0xfc, 0x7b, 0xb0, 0x6d, 0x19, 0x55, 0x0e, 0x63,
-	0xf1, 0x2f, 0x50, 0x58, 0xe2, 0xaf, 0x25, 0x64, 0x0f, 0x1e, 0xb0, 0x21, 0x75, 0x07, 0x82, 0x8c,
-	0x2c, 0x91, 0x0b, 0xe4, 0x40, 0xba, 0x4b, 0x39, 0x13, 0xf9, 0x67, 0x8a, 0xb6, 0x23, 0x15, 0xce,
-	0x09, 0x15, 0xce, 0x69, 0x86, 0x0a, 0x47, 0x84, 0x5f, 0xac, 0xa7, 0xff, 0x87, 0x3a, 0xc5, 0x7f,
-	0x19, 0x51, 0x53, 0xdf, 0xab, 0x96, 0xf3, 0x7b, 0xd5, 0xf2, 0x3c, 0x4e, 0x95, 0x26, 0xc4, 0x51,
-	0x65, 0x11, 0xc5, 0xd9, 0x2f, 0xc0, 0x94, 0x36, 0x2d, 0x23, 0x27, 0x60, 0x72, 0xea, 0xf7, 0x19,
-	0x17, 0x94, 0x64, 0x8a, 0x3b, 0x21, 0xfe, 0x8b, 0x90, 0x6a, 0xa2, 0x1c, 0xf0, 0x85, 0xd4, 0x12,
-	0x29, 0x3e, 0x2b, 0xa5, 0xfc, 0xd6, 0x90, 0xba, 0x10, 0x41, 0xa9, 0x74, 0xcf, 0x20, 0xcd, 0x69,
-	0x5f, 0xdb, 0x18, 0x73, 0xae, 0x4e, 0x93, 0xf6, 0x89, 0x70, 0xb6, 0x7f, 0x85, 0xf5, 0x26, 0xed,
-	0x6b, 0x93, 0xcb, 0x41, 0x2a, 0x2a, 0xfc, 0x94, 0xdb, 0x45, 0x9f, 0xc3, 0x43, 0x99, 0x8b, 0xaa,
-	0x40, 0xf5, 0xe2, 0x9a, 0x9c, 0xb3, 0xd2, 0x4f, 0xae, 0x50, 0x1e, 0x36, 0x86, 0x2c, 0x08, 0x68,
-	0x9f, 0x89, 0xea, 0xcf, 0x92, 0x70, 0x89, 0x6f, 0xc0, 0x22, 0xac, 0x57, 0x7d, 0xe3, 0x06, 0x7c,
-	0x25, 0xb1, 0xb2, 0x60, 0xdd, 0x67, 0x3d, 0x55, 0x96, 0xd3, 0xbf, 0xf8, 0x04, 0x76, 0x62, 0xc8,
-	0x33, 0x91, 0x7f, 0x4d, 0x07, 0x13, 0x99, 0xe5, 0x26, 0x91, 0x0b, 0xfc, 0x3b, 0xec, 0x96, 0x7d,
-	0x46, 0x39, 0x0b, 0x25, 0xe1, 0xbf, 0xdf, 0x23, 0x64, 0x31, 0x15, 0x63, 0xf1, 0x10, 0x32, 0x01,
-	0xa7, 0x3e, 0x6f, 0x8d, 0x3d, 0x77, 0x14, 0xaa, 0x04, 0x08, 0xd3, 0xf5, 0xd4, 0x82, 0xff, 0x36,
-	0x60, 0x2f, 0x79, 0x81, 0x48, 0xec, 0xcc, 0x80, 0x53, 0x3e, 0x09, 0xc4, 0xe9, 0xb9, 0x59, 0x9f,
-	0xeb, 0xbc, 0x9d, 0x86, 0x70, 0x25, 0x2a, 0x04, 0x3d, 0x07, 0x53, 0xd6, 0xb0, 0xaa, 0xcc, 0x5c,
-	0x18, 0xac, 0xc2, 0xd4, 0x2e, 0xae, 0x83, 0x29, 0x23, 0x91, 0x09, 0xa9, 0xab, 0x97, 0xd6, 0x1a,
-	0xca, 0x01, 0x54, 0x09, 0x69, 0x55, 0x6f, 0x6a, 0x8d, 0x66, 0xc3, 0x32, 0xa6, 0x9a, 0x3d, 0x5d,
-	0xd7, 0xea, 0xaf, 0x4a, 0x97, 0xb5, 0x8a, 0x95, 0x42, 0x05, 0x78, 0x14, 0x33, 0xb4, 0x1a, 0xcd,
-	0x12, 0x69, 0xb6, 0xae, 0xaf, 0x6a, 0xf5, 0xa6, 0xb5, 0x8e, 0x7f, 0x84, 0xdd, 0x0a, 0x1b, 0xb0,
-	0xf7, 0xc4, 0x26, 0xde, 0x87, 0xbd, 0x24, 0xbc, 0xcc, 0x1e, 0x7f, 0x0f, 0x3b, 0xd3, 0x3a, 0x7f,
-	0x3f, 0x87, 0x7e, 0x29, 0x5b, 0x77, 0xee, 0x79, 0x66, 0x0c, 0x1b, 0xcb, 0x18, 0x2e, 0xfe, 0xb9,
-	0x01, 0x40, 0x58, 0xaf, 0xc1, 0xfc, 0xd7, 0x6e, 0x87, 0xa1, 0x1e, 0x7c, 0xa0, 0x1d, 0xc6, 0xd0,
-	0xc7, 0xf1, 0x86, 0x5d, 0x34, 0xff, 0xd9, 0xcf, 0xde, 0xe1, 0xa5, 0xf8, 0x58, 0x43, 0xad, 0x48,
-	0x6f, 0x62, 0xe3, 0x16, 0x7a, 0xaa, 0x15, 0xc0, 0xf8, 0x64, 0x65, 0xe3, 0x65, 0x2e, 0x21, 0xfc,
-	0xa7, 0x06, 0x7a, 0x05, 0xdb, 0x73, 0xd3, 0x14, 0x7a, 0x72, 0x5f, 0x73, 0x12, 0xd0, 0x87, 0x0b,
-	0xf7, 0x63, 0xb8, 0x17, 0x90, 0x89, 0x4d, 0x3d, 0xc8, 0x8e, 0xc7, 0x24, 0x27, 0x31, 0xbb, 0xa0,
-	0xdd, 0x8b, 0x28, 0xf8, 0x41, 0x16, 0x45, 0x62, 0x94, 0x40, 0x47, 0xef, 0x9a, 0x63, 0xec, 0xa7,
-	0x4b, 0x3c, 0xb4, 0xf9, 0x47, 0xd8, 0x4f, 0x16, 0x7e, 0x5e, 0xf4, 0xf9, 0x6b, 0x71, 0xbf, 0x91,
-	0xf9, 0x2b, 0xc9, 0x4e, 0xe6, 0x9f, 0xfc, 0x7a, 0x24, 0xf3, 0x9f, 0xd3, 0x78, 0x81, 0x75, 0x0e,
-	0x5b, 0x91, 0x0c, 0xa2, 0xfc, 0xac, 0xf4, 0x93, 0x9a, 0x6b, 0x1f, 0x68, 0x76, 0x22, 0x16, 0x5f,
-	0x42, 0x36, 0x2e, 0x38, 0xa8, 0xa0, 0x97, 0x21, 0x89, 0xf4, 0x78, 0x99, 0x46, 0x49, 0xb0, 0x78,
-	0xff, 0xce, 0xc0, 0x34, 0xa2, 0x31, 0x03, 0xd3, 0xb6, 0xfc, 0x1a, 0xaa, 0x02, 0xcc, 0xfa, 0x12,
-	0x1d, 0xc4, 0xc9, 0x48, 0x02, 0xd9, 0xba, 0xad, 0x10, 0xa6, 0x6d, 0x8a, 0x51, 0xe5, 0xec, 0x9f,
-	0x00, 0x00, 0x00, 0xff, 0xff, 0xf3, 0x6c, 0xba, 0xd7, 0xbd, 0x0d, 0x00, 0x00,
+	0x10, 0xce, 0x12, 0xb2, 0x97, 0x34, 0x48, 0x36, 0x93, 0x98, 0x23, 0xcb, 0x79, 0xe4, 0x46, 0xef,
+	0x4c, 0x5e, 0x36, 0x16, 0x57, 0xfa, 0xa2, 0x0f, 0x12, 0xc0, 0x0b, 0x5e, 0x24, 0xa9, 0x01, 0xaf,
+	0x52, 0xa5, 0x16, 0x35, 0xc0, 0x40, 0xd6, 0x02, 0x16, 0x77, 0x87, 0xf3, 0xf2, 0xa0, 0x7f, 0xc0,
+	0xff, 0xe0, 0xa3, 0x7f, 0xc5, 0x07, 0xff, 0x94, 0xc5, 0xcc, 0xec, 0xb2, 0x4b, 0x06, 0xce, 0x92,
+	0xbb, 0x27, 0x76, 0x7a, 0xba, 0xbf, 0x99, 0xfe, 0xa6, 0xfb, 0xa3, 0x61, 0xc7, 0x67, 0x7d, 0x67,
+	0xe2, 0x7b, 0xdc, 0x43, 0xe6, 0xc0, 0xe5, 0x74, 0x78, 0x67, 0x67, 0x83, 0x5b, 0xea, 0xb3, 0x9e,
+	0xb4, 0xda, 0xc5, 0x81, 0xe7, 0x0d, 0x86, 0xec, 0x4c, 0xac, 0x3a, 0xd3, 0xfe, 0x19, 0x77, 0x47,
+	0x2c, 0xe0, 0x74, 0x34, 0x91, 0x0e, 0x98, 0xc0, 0xa3, 0x6f, 0xdc, 0x71, 0xaf, 0xca, 0xfa, 0x74,
+	0x3a, 0xe4, 0xe7, 0x3e, 0x1d, 0x77, 0x6f, 0x1b, 0x74, 0xc4, 0x08, 0xfb, 0x65, 0xca, 0x02, 0x8e,
+	0x4a, 0x00, 0x3e, 0x9b, 0x78, 0x81, 0xcb, 0x3d, 0xff, 0x2e, 0x6f, 0x1c, 0x1b, 0x27, 0x99, 0x12,
+	0x72, 0xe4, 0x59, 0x0e, 0x89, 0x76, 0x48, 0xcc, 0x0b, 0x3f, 0x87, 0x8f, 0x96, 0x60, 0x06, 0x13,
+	0x6f, 0x1c, 0x30, 0x84, 0x20, 0x3d, 0xa6, 0x23, 0x26, 0xe0, 0xb2, 0x44, 0x7c, 0xe3, 0x2b, 0x38,
+	0x9a, 0x05, 0x95, 0x87, 0xc3, 0x79, 0x40, 0xb0, 0xce, 0x2d, 0x4a, 0x60, 0xeb, 0x00, 0xd5, 0x15,
+	0x0e, 0x60, 0x6b, 0x76, 0x6c, 0x90, 0x37, 0x8e, 0x37, 0x4f, 0xb2, 0x44, 0x2e, 0xf0, 0x25, 0x1c,
+	0xaa, 0x98, 0x16, 0x1d, 0xac, 0x7d, 0x83, 0x33, 0x78, 0x78, 0x0f, 0x6d, 0xe5, 0xf1, 0xbf, 0x01,
+	0x9a, 0x05, 0x10, 0xd6, 0x5f, 0xf3, 0x09, 0x50, 0x01, 0x76, 0xba, 0xde, 0x68, 0xe4, 0xf2, 0xb6,
+	0xdb, 0xcb, 0xa7, 0x8e, 0x8d, 0x93, 0x1d, 0xb2, 0x2d, 0x0d, 0xf5, 0x1e, 0x3a, 0x04, 0x73, 0xe2,
+	0xb3, 0xbe, 0xfb, 0x26, 0xbf, 0x29, 0x1e, 0x40, 0xad, 0xf0, 0x29, 0xec, 0x27, 0x8e, 0x5f, 0xf1,
+	0x5a, 0x7f, 0x1b, 0x90, 0x9f, 0xf9, 0x5e, 0x7a, 0x5d, 0xaa, 0xf8, 0x5d, 0x8b, 0x2b, 0xf4, 0x35,
+	0x3c, 0x08, 0x3c, 0x9f, 0xb7, 0x3b, 0x77, 0xe2, 0xba, 0xb9, 0xd2, 0xa7, 0x61, 0xc0, 0xb2, 0x63,
+	0x9c, 0xa6, 0xe7, 0xf3, 0xf3, 0x3b, 0x62, 0x06, 0xe2, 0x17, 0x7f, 0x0e, 0xa6, 0xb4, 0xa0, 0x6d,
+	0x48, 0x37, 0xca, 0xdf, 0xd5, 0xac, 0x0d, 0xb4, 0x0b, 0x99, 0xef, 0xaf, 0xab, 0xe5, 0x56, 0xad,
+	0xda, 0x2e, 0x37, 0x2b, 0x96, 0x81, 0x2c, 0xc8, 0x86, 0x86, 0x6a, 0xad, 0x59, 0xb1, 0x52, 0xf8,
+	0x46, 0xd6, 0xdd, 0xc2, 0x09, 0x2a, 0xf5, 0x2f, 0x61, 0xbb, 0xa3, 0x6c, 0xe2, 0xa5, 0x32, 0xa5,
+	0xe2, 0x92, 0x6b, 0x85, 0x21, 0x24, 0x0a, 0xc0, 0x7f, 0xa4, 0xe4, 0xfb, 0x6b, 0xbc, 0x74, 0x9c,
+	0xae, 0x7e, 0xb3, 0xa7, 0x90, 0x53, 0x9b, 0xc1, 0xb4, 0xf3, 0x33, 0xeb, 0x72, 0xf5, 0x76, 0x1f,
+	0x48, 0x6b, 0x53, 0x1a, 0xd1, 0x05, 0x28, 0x43, 0x9b, 0x4e, 0xf9, 0xad, 0xe7, 0xe7, 0xd3, 0x82,
+	0xfd, 0x8f, 0x97, 0xdc, 0xba, 0x22, 0x7c, 0xcb, 0xc2, 0x95, 0x64, 0xbb, 0xb1, 0x15, 0x6a, 0x80,
+	0xa5, 0x90, 0xe4, 0x0f, 0x67, 0x7e, 0x7e, 0xeb, 0xbf, 0x83, 0xed, 0xca, 0xa8, 0x4a, 0x18, 0x8b,
+	0x7f, 0x85, 0xc2, 0x0a, 0x7f, 0x2d, 0x21, 0x07, 0xb0, 0xc5, 0x46, 0xd4, 0x1d, 0x0a, 0x32, 0xb2,
+	0x44, 0x2e, 0x90, 0x03, 0xe9, 0x1e, 0xe5, 0x4c, 0xe4, 0x9f, 0x29, 0xd9, 0x8e, 0x54, 0x38, 0x27,
+	0x54, 0x38, 0xa7, 0x15, 0x2a, 0x1c, 0x11, 0x7e, 0xb1, 0x9e, 0x7e, 0x07, 0x75, 0x8a, 0xff, 0x32,
+	0xa2, 0xa6, 0xbe, 0x57, 0x2d, 0xe7, 0xf7, 0xaa, 0xe5, 0x59, 0x9c, 0x2a, 0x4d, 0x88, 0xa3, 0xca,
+	0x22, 0x8a, 0xb3, 0x5f, 0x80, 0x29, 0x6d, 0x5a, 0x46, 0x4e, 0xc1, 0xe4, 0xd4, 0x1f, 0x30, 0x2e,
+	0x28, 0xc9, 0x94, 0xf6, 0x42, 0xfc, 0x17, 0x21, 0xd5, 0x44, 0x39, 0xe0, 0x0b, 0xa9, 0x25, 0x52,
+	0x7c, 0xd6, 0x4a, 0xf9, 0x0b, 0x29, 0x0b, 0x11, 0x92, 0xca, 0xb6, 0x08, 0x69, 0x4e, 0x07, 0x61,
+	0xa6, 0x99, 0x10, 0xa4, 0x45, 0x07, 0x44, 0x6c, 0xe0, 0x1b, 0xb0, 0x08, 0xeb, 0xd7, 0xde, 0xb8,
+	0x01, 0x5f, 0x4b, 0x1a, 0x2c, 0xd8, 0xf4, 0x59, 0x5f, 0x15, 0xc1, 0xec, 0x13, 0x9f, 0xc2, 0x5e,
+	0x0c, 0x79, 0x2e, 0xa9, 0xaf, 0xe9, 0x70, 0x2a, 0x09, 0xdb, 0x26, 0x72, 0x81, 0x7f, 0x87, 0xfd,
+	0x8a, 0xcf, 0x28, 0x67, 0x61, 0x03, 0xfe, 0xff, 0x7b, 0x84, 0x0f, 0x92, 0x8a, 0x3d, 0x48, 0x11,
+	0x32, 0x01, 0xa7, 0x3e, 0x6f, 0x4f, 0x3c, 0x77, 0x1c, 0xf6, 0x24, 0x08, 0xd3, 0xf5, 0xcc, 0x82,
+	0xff, 0x31, 0xe0, 0x20, 0x79, 0x81, 0x48, 0x5a, 0xcc, 0x80, 0x53, 0x3e, 0x0d, 0xc4, 0xe9, 0xb9,
+	0x79, 0x57, 0xe9, 0xbc, 0x9d, 0xa6, 0x70, 0x25, 0x2a, 0x04, 0x3d, 0x03, 0x53, 0x56, 0x8c, 0xaa,
+	0x83, 0x5c, 0x18, 0xac, 0xc2, 0xd4, 0x2e, 0x6e, 0x80, 0x29, 0x23, 0x91, 0x09, 0xa9, 0xab, 0x97,
+	0xd6, 0x06, 0xca, 0x01, 0xd4, 0x08, 0x69, 0xd7, 0x6e, 0xea, 0xcd, 0x56, 0xd3, 0x32, 0x66, 0x0a,
+	0x39, 0x5b, 0xd7, 0x1b, 0xaf, 0xca, 0x97, 0xf5, 0xaa, 0x95, 0x42, 0x05, 0x78, 0x18, 0x33, 0xb4,
+	0x9b, 0xad, 0x32, 0x69, 0xb5, 0xaf, 0xaf, 0xea, 0x8d, 0x96, 0xb5, 0x89, 0x7f, 0x82, 0xfd, 0x2a,
+	0x1b, 0xb2, 0xf7, 0xc4, 0x26, 0x3e, 0x84, 0x83, 0x24, 0xbc, 0xcc, 0x1e, 0xff, 0x00, 0x7b, 0xb3,
+	0x0a, 0x7c, 0x3f, 0x87, 0x7e, 0x25, 0x1b, 0x65, 0xe1, 0x79, 0xe6, 0x0c, 0x1b, 0xab, 0x18, 0x2e,
+	0xfd, 0xf9, 0x00, 0x80, 0xb0, 0x7e, 0x93, 0xf9, 0xaf, 0xdd, 0x2e, 0x43, 0x7d, 0xf8, 0x50, 0x3b,
+	0xfa, 0xa0, 0x4f, 0xe2, 0x4a, 0xb0, 0x6c, 0xda, 0xb2, 0x9f, 0xbe, 0xc5, 0x4b, 0xf1, 0xb1, 0x81,
+	0xda, 0x51, 0x77, 0xc7, 0x86, 0x1b, 0xf4, 0x44, 0x2b, 0x37, 0xf1, 0x39, 0xc6, 0xc6, 0xab, 0x5c,
+	0x42, 0xf8, 0xcf, 0x0c, 0xf4, 0x0a, 0x76, 0x17, 0x66, 0x17, 0xf4, 0x78, 0x21, 0x74, 0x61, 0x44,
+	0xb2, 0x8b, 0x4b, 0xf7, 0x63, 0xb8, 0x17, 0x90, 0x89, 0xcd, 0x18, 0xc8, 0x8e, 0xc7, 0x24, 0xe7,
+	0x1e, 0xbb, 0xa0, 0xdd, 0x8b, 0x28, 0xf8, 0x51, 0x16, 0x45, 0xe2, 0x8f, 0x1b, 0x1d, 0xbf, 0x6d,
+	0x6a, 0xb0, 0x9f, 0xac, 0xf0, 0xd0, 0xe6, 0x1f, 0x61, 0x3f, 0x5e, 0x2a, 0xe6, 0xfa, 0xfc, 0xb5,
+	0xb8, 0xdf, 0xca, 0xfc, 0x95, 0x98, 0x26, 0xf3, 0x4f, 0x6a, 0x75, 0x32, 0xff, 0x05, 0xf5, 0x15,
+	0x58, 0xe7, 0xb0, 0x13, 0xc9, 0x20, 0xca, 0xcf, 0x4b, 0x3f, 0xa9, 0xb9, 0xf6, 0x91, 0x66, 0x27,
+	0x62, 0xf1, 0x25, 0x64, 0xe3, 0x82, 0x83, 0x0a, 0x7a, 0x19, 0x92, 0x48, 0x8f, 0x56, 0x69, 0x94,
+	0x04, 0x8b, 0xf7, 0xef, 0x1c, 0x4c, 0x23, 0x1a, 0x73, 0x30, 0x6d, 0xcb, 0x6f, 0xa0, 0x1a, 0xc0,
+	0xbc, 0x2f, 0xd1, 0x51, 0x9c, 0x8c, 0x24, 0x90, 0xad, 0xdb, 0x0a, 0x61, 0x3a, 0xa6, 0x18, 0x0c,
+	0x9e, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x63, 0x76, 0x69, 0xeb, 0x2b, 0x0d, 0x00, 0x00,
 }

vendor/gitlab.com/gitlab-org/gitaly-proto/go/repository-service.pb.go

@@ -17,6 +17,33 @@ var _ = proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 
+type GetArchiveRequest_Format int32
+
+const (
+	GetArchiveRequest_ZIP     GetArchiveRequest_Format = 0
+	GetArchiveRequest_TAR     GetArchiveRequest_Format = 1
+	GetArchiveRequest_TAR_GZ  GetArchiveRequest_Format = 2
+	GetArchiveRequest_TAR_BZ2 GetArchiveRequest_Format = 3
+)
+
+var GetArchiveRequest_Format_name = map[int32]string{
+	0: "ZIP",
+	1: "TAR",
+	2: "TAR_GZ",
+	3: "TAR_BZ2",
+}
+var GetArchiveRequest_Format_value = map[string]int32{
+	"ZIP":     0,
+	"TAR":     1,
+	"TAR_GZ":  2,
+	"TAR_BZ2": 3,
+}
+
+func (x GetArchiveRequest_Format) String() string {
+	return proto.EnumName(GetArchiveRequest_Format_name, int32(x))
+}
+func (GetArchiveRequest_Format) EnumDescriptor() ([]byte, []int) { return fileDescriptor8, []int{16, 0} }
+
 type RepositoryExistsRequest struct {
 	Repository *Repository `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
 }
@@ -298,6 +325,62 @@ func (m *CreateRepositoryResponse) String() string            { return proto.Com
 func (*CreateRepositoryResponse) ProtoMessage()               {}
 func (*CreateRepositoryResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{15} }
 
+type GetArchiveRequest struct {
+	Repository *Repository              `protobuf:"bytes,1,opt,name=repository" json:"repository,omitempty"`
+	CommitId   string                   `protobuf:"bytes,2,opt,name=commit_id,json=commitId" json:"commit_id,omitempty"`
+	Prefix     string                   `protobuf:"bytes,3,opt,name=prefix" json:"prefix,omitempty"`
+	Format     GetArchiveRequest_Format `protobuf:"varint,4,opt,name=format,enum=gitaly.GetArchiveRequest_Format" json:"format,omitempty"`
+}
+
+func (m *GetArchiveRequest) Reset()                    { *m = GetArchiveRequest{} }
+func (m *GetArchiveRequest) String() string            { return proto.CompactTextString(m) }
+func (*GetArchiveRequest) ProtoMessage()               {}
+func (*GetArchiveRequest) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{16} }
+
+func (m *GetArchiveRequest) GetRepository() *Repository {
+	if m != nil {
+		return m.Repository
+	}
+	return nil
+}
+
+func (m *GetArchiveRequest) GetCommitId() string {
+	if m != nil {
+		return m.CommitId
+	}
+	return ""
+}
+
+func (m *GetArchiveRequest) GetPrefix() string {
+	if m != nil {
+		return m.Prefix
+	}
+	return ""
+}
+
+func (m *GetArchiveRequest) GetFormat() GetArchiveRequest_Format {
+	if m != nil {
+		return m.Format
+	}
+	return GetArchiveRequest_ZIP
+}
+
+type GetArchiveResponse struct {
+	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (m *GetArchiveResponse) Reset()                    { *m = GetArchiveResponse{} }
+func (m *GetArchiveResponse) String() string            { return proto.CompactTextString(m) }
+func (*GetArchiveResponse) ProtoMessage()               {}
+func (*GetArchiveResponse) Descriptor() ([]byte, []int) { return fileDescriptor8, []int{17} }
+
+func (m *GetArchiveResponse) GetData() []byte {
+	if m != nil {
+		return m.Data
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*RepositoryExistsRequest)(nil), "gitaly.RepositoryExistsRequest")
 	proto.RegisterType((*RepositoryExistsResponse)(nil), "gitaly.RepositoryExistsResponse")
@@ -315,6 +398,9 @@ func init() {
 	proto.RegisterType((*FetchRemoteResponse)(nil), "gitaly.FetchRemoteResponse")
 	proto.RegisterType((*CreateRepositoryRequest)(nil), "gitaly.CreateRepositoryRequest")
 	proto.RegisterType((*CreateRepositoryResponse)(nil), "gitaly.CreateRepositoryResponse")
+	proto.RegisterType((*GetArchiveRequest)(nil), "gitaly.GetArchiveRequest")
+	proto.RegisterType((*GetArchiveResponse)(nil), "gitaly.GetArchiveResponse")
+	proto.RegisterEnum("gitaly.GetArchiveRequest_Format", GetArchiveRequest_Format_name, GetArchiveRequest_Format_value)
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -336,6 +422,7 @@ type RepositoryServiceClient interface {
 	ApplyGitattributes(ctx context.Context, in *ApplyGitattributesRequest, opts ...grpc.CallOption) (*ApplyGitattributesResponse, error)
 	FetchRemote(ctx context.Context, in *FetchRemoteRequest, opts ...grpc.CallOption) (*FetchRemoteResponse, error)
 	CreateRepository(ctx context.Context, in *CreateRepositoryRequest, opts ...grpc.CallOption) (*CreateRepositoryResponse, error)
+	GetArchive(ctx context.Context, in *GetArchiveRequest, opts ...grpc.CallOption) (RepositoryService_GetArchiveClient, error)
 	// Deprecated, use the RepositoryExists RPC instead.
 	Exists(ctx context.Context, in *RepositoryExistsRequest, opts ...grpc.CallOption) (*RepositoryExistsResponse, error)
 }
@@ -420,6 +507,38 @@ func (c *repositoryServiceClient) CreateRepository(ctx context.Context, in *Crea
 	return out, nil
 }
 
+func (c *repositoryServiceClient) GetArchive(ctx context.Context, in *GetArchiveRequest, opts ...grpc.CallOption) (RepositoryService_GetArchiveClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_RepositoryService_serviceDesc.Streams[0], c.cc, "/gitaly.RepositoryService/GetArchive", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &repositoryServiceGetArchiveClient{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 RepositoryService_GetArchiveClient interface {
+	Recv() (*GetArchiveResponse, error)
+	grpc.ClientStream
+}
+
+type repositoryServiceGetArchiveClient struct {
+	grpc.ClientStream
+}
+
+func (x *repositoryServiceGetArchiveClient) Recv() (*GetArchiveResponse, error) {
+	m := new(GetArchiveResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 func (c *repositoryServiceClient) Exists(ctx context.Context, in *RepositoryExistsRequest, opts ...grpc.CallOption) (*RepositoryExistsResponse, error) {
 	out := new(RepositoryExistsResponse)
 	err := grpc.Invoke(ctx, "/gitaly.RepositoryService/Exists", in, out, c.cc, opts...)
@@ -440,6 +559,7 @@ type RepositoryServiceServer interface {
 	ApplyGitattributes(context.Context, *ApplyGitattributesRequest) (*ApplyGitattributesResponse, error)
 	FetchRemote(context.Context, *FetchRemoteRequest) (*FetchRemoteResponse, error)
 	CreateRepository(context.Context, *CreateRepositoryRequest) (*CreateRepositoryResponse, error)
+	GetArchive(*GetArchiveRequest, RepositoryService_GetArchiveServer) error
 	// Deprecated, use the RepositoryExists RPC instead.
 	Exists(context.Context, *RepositoryExistsRequest) (*RepositoryExistsResponse, error)
 }
@@ -592,6 +712,27 @@ func _RepositoryService_CreateRepository_Handler(srv interface{}, ctx context.Co
 	return interceptor(ctx, in, info, handler)
 }
 
+func _RepositoryService_GetArchive_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(GetArchiveRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(RepositoryServiceServer).GetArchive(m, &repositoryServiceGetArchiveServer{stream})
+}
+
+type RepositoryService_GetArchiveServer interface {
+	Send(*GetArchiveResponse) error
+	grpc.ServerStream
+}
+
+type repositoryServiceGetArchiveServer struct {
+	grpc.ServerStream
+}
+
+func (x *repositoryServiceGetArchiveServer) Send(m *GetArchiveResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
 func _RepositoryService_Exists_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(RepositoryExistsRequest)
 	if err := dec(in); err != nil {
@@ -651,50 +792,64 @@ var _RepositoryService_serviceDesc = grpc.ServiceDesc{
 			Handler:    _RepositoryService_Exists_Handler,
 		},
 	},
-	Streams:  []grpc.StreamDesc{},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "GetArchive",
+			Handler:       _RepositoryService_GetArchive_Handler,
+			ServerStreams: true,
+		},
+	},
 	Metadata: "repository-service.proto",
 }
 
 func init() { proto.RegisterFile("repository-service.proto", fileDescriptor8) }
 
 var fileDescriptor8 = []byte{
-	// 593 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x55, 0xdb, 0x6e, 0xd3, 0x4c,
-	0x10, 0x6e, 0xfe, 0xb6, 0x4e, 0xff, 0x49, 0x40, 0x65, 0x68, 0x12, 0xc7, 0x05, 0x1a, 0xcc, 0x4d,
-	0x2f, 0x20, 0x17, 0xe1, 0x09, 0xa0, 0xea, 0x01, 0x55, 0x41, 0xc2, 0x20, 0x55, 0x42, 0x42, 0xd1,
-	0xc6, 0x0c, 0xc9, 0x2a, 0x8e, 0xd7, 0xec, 0x6e, 0x0a, 0xe9, 0x03, 0xf0, 0xa2, 0xbc, 0x08, 0xca,
-	0xda, 0xb1, 0x9d, 0xc4, 0xe9, 0x8d, 0xe1, 0x2e, 0x3b, 0x87, 0x6f, 0x0e, 0xfe, 0xbe, 0x09, 0xd8,
-	0x92, 0x22, 0xa1, 0xb8, 0x16, 0x72, 0xfe, 0x4a, 0x91, 0xbc, 0xe5, 0x3e, 0x75, 0x23, 0x29, 0xb4,
-	0x40, 0x6b, 0xc4, 0x35, 0x0b, 0xe6, 0x4e, 0x5d, 0x8d, 0x99, 0xa4, 0xaf, 0xb1, 0xd5, 0xed, 0x43,
-	0xcb, 0x4b, 0x33, 0xce, 0x7f, 0x72, 0xa5, 0x95, 0x47, 0xdf, 0x67, 0xa4, 0x34, 0xf6, 0x00, 0x32,
-	0x30, 0xbb, 0xd2, 0xa9, 0x9c, 0xd6, 0x7a, 0xd8, 0x8d, 0x51, 0xba, 0x59, 0x92, 0x97, 0x8b, 0x72,
-	0x7b, 0x60, 0x6f, 0xc2, 0xa9, 0x48, 0x84, 0x8a, 0xb0, 0x09, 0x16, 0x19, 0x8b, 0xc1, 0x3a, 0xf0,
-	0x92, 0x97, 0xfb, 0xde, 0xe4, 0x30, 0x7f, 0xf2, 0x2e, 0xf4, 0x25, 0x4d, 0x29, 0xd4, 0x2c, 0x28,
-	0xd3, 0xc3, 0x31, 0xb4, 0x0b, 0xf0, 0xe2, 0x26, 0xdc, 0x00, 0x1e, 0xc5, 0xce, 0x8b, 0x59, 0x50,
-	0xa6, 0x0a, 0xbe, 0x80, 0x07, 0xbe, 0x24, 0xa6, 0x69, 0x30, 0xe4, 0x7a, 0xca, 0x22, 0xfb, 0x3f,
-	0x33, 0x54, 0x3d, 0x36, 0xbe, 0x35, 0x36, 0xf7, 0x08, 0x30, 0x5f, 0x2d, 0xe9, 0x21, 0x82, 0xc6,
-	0x25, 0x93, 0x43, 0x36, 0xa2, 0x33, 0x11, 0x04, 0xe4, 0xeb, 0x7f, 0xde, 0x87, 0x0d, 0xcd, 0xf5,
-	0x8a, 0x49, 0x2f, 0xd7, 0xd0, 0xc8, 0x80, 0x3f, 0xf2, 0x3b, 0x2a, 0xb3, 0xf9, 0x97, 0xd0, 0x5c,
-	0x07, 0x4b, 0xbe, 0x3d, 0xc2, 0x9e, 0xe2, 0x77, 0x64, 0x70, 0x76, 0x3d, 0xf3, 0xdb, 0x9d, 0x40,
-	0xfb, 0x4d, 0x14, 0x05, 0xf3, 0x4b, 0xae, 0x99, 0xd6, 0x92, 0x0f, 0x67, 0x9a, 0xca, 0x90, 0x0f,
-	0x1d, 0x38, 0x90, 0x74, 0xcb, 0x15, 0x17, 0xa1, 0xd9, 0x42, 0xdd, 0x4b, 0xdf, 0xee, 0x13, 0x70,
-	0x8a, 0x8a, 0x25, 0x5b, 0xf8, 0x5d, 0x01, 0xbc, 0x20, 0xed, 0x8f, 0x3d, 0x9a, 0x0a, 0x5d, 0x66,
-	0x07, 0x0b, 0x96, 0x4b, 0x03, 0x62, 0x5a, 0xf8, 0xdf, 0x4b, 0x5e, 0x78, 0x04, 0xfb, 0xdf, 0x84,
-	0xf4, 0xc9, 0xde, 0x35, 0xdf, 0x27, 0x7e, 0x60, 0x0b, 0xaa, 0xa1, 0x18, 0x68, 0x36, 0x52, 0xf6,
-	0x5e, 0x2c, 0x8a, 0x50, 0x7c, 0x62, 0x23, 0x85, 0x36, 0x54, 0x35, 0x9f, 0x92, 0x98, 0x69, 0x7b,
-	0xbf, 0x53, 0x39, 0xdd, 0xf7, 0x96, 0xcf, 0x45, 0x8a, 0x52, 0xe3, 0xc1, 0x84, 0xe6, 0xb6, 0x15,
-	0x57, 0x50, 0x6a, 0x7c, 0x4d, 0x73, 0x3c, 0x81, 0xda, 0x24, 0x14, 0x3f, 0xc2, 0xc1, 0x58, 0x2c,
-	0x44, 0x56, 0x35, 0x4e, 0x30, 0xa6, 0xab, 0x85, 0xc5, 0x6d, 0xc0, 0xe3, 0x95, 0x21, 0x93, 0xe1,
-	0xfb, 0xd0, 0x3a, 0x33, 0x64, 0xc9, 0x4d, 0x54, 0x82, 0x04, 0x0e, 0xd8, 0x9b, 0x70, 0x71, 0xa9,
-	0xde, 0x2f, 0xcb, 0xc8, 0x6f, 0xc9, 0x90, 0xf8, 0x3e, 0xe1, 0x0d, 0x1c, 0xae, 0x1f, 0x0d, 0x3c,
-	0xd9, 0xac, 0xb2, 0x72, 0x9d, 0x9c, 0xce, 0xf6, 0x80, 0x64, 0xae, 0x1d, 0xfc, 0xbc, 0x14, 0x7b,
-	0xee, 0x12, 0x60, 0x3e, 0xb1, 0xf0, 0xe8, 0x38, 0xcf, 0xef, 0x89, 0x48, 0xb1, 0xcf, 0x01, 0x32,
-	0x69, 0x63, 0x7b, 0x35, 0x25, 0x77, 0x5c, 0x1c, 0xa7, 0xc8, 0x95, 0xc2, 0x7c, 0x80, 0x87, 0xab,
-	0xca, 0xc4, 0xa7, 0xcb, 0xf8, 0xc2, 0x1b, 0xe1, 0x3c, 0xdb, 0xe6, 0xce, 0x43, 0xae, 0xaa, 0x30,
-	0x83, 0x2c, 0x94, 0x7a, 0x06, 0x59, 0x2c, 0x5e, 0x77, 0x07, 0xbf, 0x00, 0x6e, 0xaa, 0x07, 0xd3,
-	0x3d, 0x6d, 0x95, 0xb1, 0xe3, 0xde, 0x17, 0x92, 0xc2, 0x5f, 0x41, 0x2d, 0x47, 0x4c, 0x4c, 0x37,
-	0xb6, 0x29, 0x49, 0xe7, 0xb8, 0xd0, 0x97, 0x22, 0xdd, 0xc0, 0xe1, 0x3a, 0xf9, 0x32, 0x2a, 0x6d,
-	0x61, 0x79, 0x46, 0xa5, 0x6d, 0xbc, 0x75, 0x77, 0xb0, 0x0f, 0xd6, 0x5f, 0x64, 0xe6, 0xd0, 0x32,
-	0xff, 0xbe, 0xaf, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0xd3, 0xae, 0xf2, 0xe4, 0xaf, 0x07, 0x00,
-	0x00,
+	// 734 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x4f, 0x6f, 0xda, 0x4a,
+	0x10, 0x87, 0x90, 0x98, 0x64, 0xe0, 0x45, 0x64, 0x5e, 0xfe, 0x38, 0xce, 0x7b, 0x0d, 0x75, 0x2f,
+	0x39, 0xb4, 0xa8, 0x22, 0x97, 0x5e, 0x49, 0x94, 0x90, 0x28, 0x4a, 0xd5, 0xba, 0x91, 0x22, 0x21,
+	0x55, 0x68, 0x31, 0x1b, 0x58, 0x01, 0x5e, 0x77, 0x77, 0x49, 0x43, 0xbe, 0x64, 0x3f, 0x44, 0x8f,
+	0xfd, 0x12, 0x15, 0x6b, 0x63, 0x1b, 0x6c, 0x72, 0xa1, 0xbd, 0x79, 0x67, 0x67, 0x7e, 0x33, 0xfb,
+	0x9b, 0x99, 0x9f, 0x0c, 0xa6, 0xa0, 0x3e, 0x97, 0x4c, 0x71, 0x31, 0x79, 0x27, 0xa9, 0x78, 0x64,
+	0x2e, 0xad, 0xf9, 0x82, 0x2b, 0x8e, 0x46, 0x8f, 0x29, 0x32, 0x9c, 0x58, 0x65, 0xd9, 0x27, 0x82,
+	0x76, 0x03, 0xab, 0x7d, 0x0b, 0x07, 0x4e, 0x14, 0x71, 0xf1, 0xc4, 0xa4, 0x92, 0x0e, 0xfd, 0x36,
+	0xa6, 0x52, 0x61, 0x1d, 0x20, 0x06, 0x33, 0xf3, 0xd5, 0xfc, 0x49, 0xa9, 0x8e, 0xb5, 0x00, 0xa5,
+	0x16, 0x07, 0x39, 0x09, 0x2f, 0xbb, 0x0e, 0x66, 0x1a, 0x4e, 0xfa, 0xdc, 0x93, 0x14, 0xf7, 0xc1,
+	0xa0, 0xda, 0xa2, 0xb1, 0x36, 0x9d, 0xf0, 0x64, 0x7f, 0xd4, 0x31, 0xc4, 0x1d, 0x5c, 0x7b, 0xae,
+	0xa0, 0x23, 0xea, 0x29, 0x32, 0x5c, 0xa5, 0x86, 0x23, 0x38, 0xcc, 0xc0, 0x0b, 0x8a, 0xb0, 0x87,
+	0xb0, 0x13, 0x5c, 0x5e, 0x8e, 0x87, 0xab, 0x64, 0xc1, 0x37, 0xf0, 0x8f, 0x2b, 0x28, 0x51, 0xb4,
+	0xdd, 0x61, 0x6a, 0x44, 0x7c, 0x73, 0x4d, 0x3f, 0xaa, 0x1c, 0x18, 0xcf, 0xb4, 0xcd, 0xde, 0x05,
+	0x4c, 0x66, 0x0b, 0x6b, 0xf0, 0x61, 0xaf, 0x49, 0x44, 0x87, 0xf4, 0xe8, 0x39, 0x1f, 0x0e, 0xa9,
+	0xab, 0xfe, 0x7a, 0x1d, 0x26, 0xec, 0x2f, 0x66, 0x0c, 0x6b, 0xb9, 0x81, 0xbd, 0x18, 0xf8, 0x0b,
+	0x7b, 0xa6, 0xab, 0x30, 0xff, 0x16, 0xf6, 0x17, 0xc1, 0xc2, 0xde, 0x23, 0xac, 0x4b, 0xf6, 0x4c,
+	0x35, 0x4e, 0xc1, 0xd1, 0xdf, 0xf6, 0x00, 0x0e, 0x1b, 0xbe, 0x3f, 0x9c, 0x34, 0x99, 0x22, 0x4a,
+	0x09, 0xd6, 0x19, 0x2b, 0xba, 0xca, 0xf0, 0xa1, 0x05, 0x9b, 0x82, 0x3e, 0x32, 0xc9, 0xb8, 0xa7,
+	0x59, 0x28, 0x3b, 0xd1, 0xd9, 0xfe, 0x0f, 0xac, 0xac, 0x64, 0x21, 0x0b, 0x3f, 0xf3, 0x80, 0x97,
+	0x54, 0xb9, 0x7d, 0x87, 0x8e, 0xb8, 0x5a, 0x85, 0x83, 0xe9, 0x94, 0x0b, 0x0d, 0xa2, 0x4b, 0xd8,
+	0x72, 0xc2, 0x13, 0xee, 0xc2, 0xc6, 0x03, 0x17, 0x2e, 0x35, 0x0b, 0xba, 0x3f, 0xc1, 0x01, 0x0f,
+	0xa0, 0xe8, 0xf1, 0xb6, 0x22, 0x3d, 0x69, 0xae, 0x07, 0x4b, 0xe1, 0xf1, 0x3b, 0xd2, 0x93, 0x68,
+	0x42, 0x51, 0xb1, 0x11, 0xe5, 0x63, 0x65, 0x6e, 0x54, 0xf3, 0x27, 0x1b, 0xce, 0xec, 0x38, 0x0d,
+	0x91, 0xb2, 0xdf, 0x1e, 0xd0, 0x89, 0x69, 0x04, 0x19, 0xa4, 0xec, 0xdf, 0xd0, 0x09, 0x1e, 0x43,
+	0x69, 0xe0, 0xf1, 0xef, 0x5e, 0xbb, 0xcf, 0xa7, 0x4b, 0x56, 0xd4, 0x97, 0xa0, 0x4d, 0x57, 0x53,
+	0x8b, 0xbd, 0x07, 0xff, 0xce, 0x3d, 0x32, 0x7c, 0xfc, 0x2d, 0x1c, 0x9c, 0xeb, 0x61, 0x49, 0xbc,
+	0x68, 0x85, 0x21, 0xb0, 0xc0, 0x4c, 0xc3, 0x85, 0xa9, 0x7e, 0xe5, 0x61, 0xa7, 0x49, 0x55, 0x43,
+	0xb8, 0x7d, 0xf6, 0xb8, 0x12, 0xcd, 0x47, 0xb0, 0xe5, 0xf2, 0xd1, 0x88, 0xa9, 0x36, 0xeb, 0x86,
+	0x4c, 0x6f, 0x06, 0x86, 0xeb, 0xee, 0xb4, 0x07, 0xbe, 0xa0, 0x0f, 0xec, 0x49, 0x93, 0xbd, 0xe5,
+	0x84, 0x27, 0xfc, 0x00, 0xc6, 0x03, 0x17, 0x23, 0xa2, 0x34, 0xd9, 0xdb, 0xf5, 0xea, 0x2c, 0x49,
+	0xaa, 0xa6, 0xda, 0xa5, 0xf6, 0x73, 0x42, 0x7f, 0xfb, 0x14, 0x8c, 0xc0, 0x82, 0x45, 0x28, 0xb4,
+	0xae, 0x3f, 0x55, 0x72, 0xd3, 0x8f, 0xbb, 0x86, 0x53, 0xc9, 0x23, 0x80, 0x71, 0xd7, 0x70, 0xda,
+	0xcd, 0x56, 0x65, 0x0d, 0x4b, 0x50, 0x9c, 0x7e, 0x9f, 0xb5, 0xea, 0x95, 0x82, 0x7d, 0x02, 0x98,
+	0x04, 0x8e, 0x57, 0xa1, 0x4b, 0x14, 0xd1, 0xef, 0x2c, 0x3b, 0xfa, 0xbb, 0xfe, 0xc3, 0xd0, 0xb2,
+	0x34, 0xdb, 0x9c, 0x40, 0xb7, 0xf1, 0x1e, 0x2a, 0x8b, 0x62, 0x8a, 0xc7, 0x69, 0x5e, 0xe6, 0x54,
+	0xdb, 0xaa, 0x2e, 0x77, 0x08, 0x9b, 0x90, 0xc3, 0xd6, 0x4c, 0x04, 0x13, 0x0a, 0x89, 0xc9, 0xc0,
+	0x4c, 0x31, 0xb6, 0x5e, 0xbf, 0xe0, 0x11, 0x61, 0x5f, 0x00, 0xc4, 0x92, 0x87, 0x87, 0xf3, 0x21,
+	0x09, 0xd1, 0xb5, 0xac, 0xac, 0xab, 0x08, 0xe6, 0x33, 0x6c, 0xcf, 0x2b, 0x16, 0xfe, 0x1f, 0x35,
+	0x2b, 0x4b, 0x3b, 0xad, 0x57, 0xcb, 0xae, 0x93, 0x90, 0xf3, 0xea, 0x14, 0x43, 0x66, 0x4a, 0x60,
+	0x0c, 0x99, 0x2d, 0x6a, 0x76, 0x0e, 0xbf, 0x02, 0xa6, 0x55, 0x05, 0x23, 0x9e, 0x96, 0xca, 0x9b,
+	0x65, 0xbf, 0xe4, 0x12, 0xc1, 0x5f, 0x41, 0x29, 0xb1, 0xb0, 0x18, 0x31, 0x96, 0x96, 0x2a, 0xeb,
+	0x28, 0xf3, 0x2e, 0x42, 0xba, 0x87, 0xca, 0xe2, 0x52, 0xc6, 0xa3, 0xb4, 0x64, 0xfb, 0xe3, 0x51,
+	0x5a, 0xba, 0xcf, 0x39, 0x6c, 0x02, 0xc4, 0x33, 0x1e, 0xb7, 0x3b, 0xb5, 0x50, 0x71, 0xbb, 0xd3,
+	0x2b, 0x61, 0xe7, 0xde, 0xe7, 0xf1, 0x16, 0x8c, 0x3f, 0x38, 0xe2, 0x1d, 0x43, 0xff, 0xde, 0x9c,
+	0xfe, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x20, 0x17, 0xa1, 0x43, 0x10, 0x09, 0x00, 0x00,
 }

vendor/gitlab.com/gitlab-org/gitaly-proto/go/shared.pb.go

@@ -197,6 +197,46 @@ func (m *Branch) GetTargetCommit() *GitCommit {
 	return nil
 }
 
+type Tag struct {
+	Name         []byte     `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	Id           string     `protobuf:"bytes,2,opt,name=id" json:"id,omitempty"`
+	TargetCommit *GitCommit `protobuf:"bytes,3,opt,name=target_commit,json=targetCommit" json:"target_commit,omitempty"`
+	Message      []byte     `protobuf:"bytes,4,opt,name=message,proto3" json:"message,omitempty"`
+}
+
+func (m *Tag) Reset()                    { *m = Tag{} }
+func (m *Tag) String() string            { return proto.CompactTextString(m) }
+func (*Tag) ProtoMessage()               {}
+func (*Tag) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{5} }
+
+func (m *Tag) GetName() []byte {
+	if m != nil {
+		return m.Name
+	}
+	return nil
+}
+
+func (m *Tag) GetId() string {
+	if m != nil {
+		return m.Id
+	}
+	return ""
+}
+
+func (m *Tag) GetTargetCommit() *GitCommit {
+	if m != nil {
+		return m.TargetCommit
+	}
+	return nil
+}
+
+func (m *Tag) GetMessage() []byte {
+	if m != nil {
+		return m.Message
+	}
+	return nil
+}
+
 type User struct {
 	GlId  string `protobuf:"bytes,1,opt,name=gl_id,json=glId" json:"gl_id,omitempty"`
 	Name  []byte `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
@@ -206,7 +246,7 @@ type User struct {
 func (m *User) Reset()                    { *m = User{} }
 func (m *User) String() string            { return proto.CompactTextString(m) }
 func (*User) ProtoMessage()               {}
-func (*User) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{5} }
+func (*User) Descriptor() ([]byte, []int) { return fileDescriptor9, []int{6} }
 
 func (m *User) GetGlId() string {
 	if m != nil {
@@ -235,41 +275,44 @@ func init() {
 	proto.RegisterType((*CommitAuthor)(nil), "gitaly.CommitAuthor")
 	proto.RegisterType((*ExitStatus)(nil), "gitaly.ExitStatus")
 	proto.RegisterType((*Branch)(nil), "gitaly.Branch")
+	proto.RegisterType((*Tag)(nil), "gitaly.Tag")
 	proto.RegisterType((*User)(nil), "gitaly.User")
 }
 
 func init() { proto.RegisterFile("shared.proto", fileDescriptor9) }
 
 var fileDescriptor9 = []byte{
-	// 468 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x52, 0xc1, 0x6e, 0xd3, 0x40,
-	0x10, 0x55, 0x1c, 0xc7, 0xe0, 0x89, 0x8b, 0x60, 0xc9, 0xc1, 0xaa, 0x54, 0x11, 0xcc, 0xa5, 0x07,
-	0xe4, 0xa2, 0x20, 0x71, 0x2f, 0x50, 0x55, 0xe5, 0x00, 0x68, 0x29, 0x67, 0x6b, 0x13, 0x0f, 0xeb,
-	0x45, 0xeb, 0xac, 0xb5, 0x3b, 0xae, 0xc8, 0x8d, 0xef, 0xe3, 0xab, 0x90, 0x77, 0xe3, 0xb4, 0xa0,
-	0xaa, 0xb7, 0x9d, 0xd9, 0xf7, 0x66, 0xde, 0x9b, 0x19, 0xc8, 0x5c, 0x23, 0x2c, 0xd6, 0x65, 0x67,
-	0x0d, 0x19, 0x96, 0x48, 0x45, 0x42, 0xef, 0x8e, 0x5f, 0x48, 0x63, 0xa4, 0xc6, 0x33, 0x9f, 0x5d,
-	0xf7, 0x3f, 0xce, 0x48, 0xb5, 0xe8, 0x48, 0xb4, 0x5d, 0x00, 0x16, 0xbf, 0x23, 0x00, 0x8e, 0x9d,
-	0x71, 0x8a, 0x8c, 0xdd, 0xb1, 0x97, 0x90, 0x39, 0x32, 0x56, 0x48, 0xac, 0xb6, 0xa2, 0xc5, 0x3c,
-	0x5a, 0x4e, 0x4e, 0x53, 0x3e, 0xdf, 0xe7, 0x3e, 0x8b, 0x16, 0xd9, 0x2b, 0x38, 0xb2, 0xa8, 0x05,
-	0xa9, 0x1b, 0xac, 0x3a, 0x41, 0x4d, 0x3e, 0xf5, 0x98, 0x6c, 0x4c, 0x7e, 0x15, 0xd4, 0xb0, 0x37,
-	0xb0, 0x90, 0x8a, 0x2a, 0xb3, 0xfe, 0x89, 0x1b, 0xaa, 0x6a, 0x65, 0x71, 0x33, 0xd4, 0xcf, 0x63,
-	0x8f, 0x65, 0x52, 0xd1, 0x17, 0xff, 0xf5, 0x71, 0xfc, 0x61, 0x97, 0xb0, 0x1c, 0x18, 0x42, 0x13,
-	0xda, 0xad, 0x20, 0xfc, 0x9f, 0xab, 0xd0, 0xe5, 0xb3, 0xe5, 0xf4, 0x34, 0xe5, 0x27, 0x52, 0xd1,
-	0xf9, 0x08, 0xfb, 0xb7, 0x8c, 0x42, 0x37, 0xe8, 0x93, 0xba, 0xb2, 0x07, 0x4f, 0x79, 0x12, 0xf4,
-	0x49, 0x7d, 0xeb, 0xf3, 0x53, 0xfc, 0x78, 0xf2, 0x34, 0xe2, 0xf1, 0xa0, 0xbf, 0xf8, 0x33, 0x81,
-	0xf4, 0x52, 0xd1, 0x07, 0xd3, 0xb6, 0x8a, 0xd8, 0x13, 0x88, 0x54, 0x9d, 0x4f, 0x3c, 0x27, 0x52,
-	0x35, 0xcb, 0xe1, 0x91, 0xeb, 0x7d, 0x13, 0x3f, 0x8c, 0x8c, 0x8f, 0x21, 0x63, 0x10, 0xaf, 0x4d,
-	0xbd, 0xf3, 0xfe, 0x33, 0xee, 0xdf, 0xec, 0x35, 0x24, 0xa2, 0xa7, 0xc6, 0x58, 0xef, 0x74, 0xbe,
-	0x5a, 0x94, 0x61, 0x11, 0x65, 0xa8, 0x7e, 0xee, 0xff, 0xf8, 0x1e, 0xc3, 0x56, 0x90, 0x6e, 0x7c,
-	0x9e, 0xd0, 0xe6, 0xb3, 0x07, 0x08, 0xb7, 0x30, 0x76, 0x02, 0xd0, 0x09, 0x8b, 0x5b, 0xaa, 0x54,
-	0xed, 0xf2, 0xc4, 0x4f, 0x24, 0x0d, 0x99, 0xab, 0xda, 0x15, 0x0d, 0x64, 0x77, 0x99, 0x83, 0x48,
-	0xbf, 0xc8, 0x49, 0x10, 0x39, 0xbc, 0xd9, 0x02, 0x66, 0xd8, 0x0a, 0xa5, 0xf7, 0x86, 0x42, 0xc0,
-	0x4a, 0x88, 0x6b, 0x41, 0xe8, 0xed, 0xcc, 0x57, 0xc7, 0x65, 0xb8, 0x9c, 0x72, 0xbc, 0x9c, 0xf2,
-	0x7a, 0xbc, 0x1c, 0xee, 0x71, 0x45, 0x01, 0x70, 0xf1, 0x4b, 0xd1, 0x37, 0x12, 0xd4, 0xbb, 0xa1,
-	0xe6, 0x8d, 0xd0, 0x7d, 0x68, 0x34, 0xe3, 0x21, 0x28, 0xae, 0x21, 0x79, 0x6f, 0xc5, 0x76, 0xd3,
-	0xdc, 0xab, 0xe3, 0x1d, 0x1c, 0x91, 0xb0, 0x12, 0xa9, 0x0a, 0xf6, 0xbc, 0x9e, 0xf9, 0xea, 0xd9,
-	0x38, 0x82, 0xc3, 0x52, 0x78, 0x16, 0x70, 0x21, 0x2a, 0x2e, 0x20, 0xfe, 0xee, 0xd0, 0xb2, 0xe7,
-	0x30, 0x93, 0xba, 0x3a, 0x6c, 0x2b, 0x96, 0xfa, 0xaa, 0x3e, 0x34, 0x8a, 0xee, 0x33, 0x3c, 0xbd,
-	0x63, 0x78, 0x9d, 0x78, 0x6b, 0x6f, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x86, 0x24, 0x75, 0x89,
-	0x3a, 0x03, 0x00, 0x00,
+	// 500 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x52, 0xc1, 0x6e, 0xd3, 0x40,
+	0x10, 0x55, 0x1c, 0xc7, 0x90, 0x89, 0x8b, 0x60, 0xe9, 0xc1, 0xaa, 0x54, 0x11, 0xcc, 0xa5, 0x07,
+	0xe4, 0xa2, 0x20, 0x71, 0x2f, 0x50, 0x55, 0xe5, 0x00, 0x68, 0x09, 0x67, 0x6b, 0x12, 0x0f, 0xeb,
+	0x45, 0x76, 0x36, 0xda, 0x9d, 0x54, 0x44, 0x5c, 0xf8, 0x3e, 0xbe, 0x0a, 0x79, 0x37, 0x4e, 0x0b,
+	0x44, 0x88, 0xdb, 0xce, 0xec, 0x9b, 0x99, 0xf7, 0xe6, 0x0d, 0xa4, 0xae, 0x46, 0x4b, 0x55, 0xb1,
+	0xb6, 0x86, 0x8d, 0x48, 0x94, 0x66, 0x6c, 0xb6, 0x27, 0x4f, 0x94, 0x31, 0xaa, 0xa1, 0x73, 0x9f,
+	0x5d, 0x6c, 0xbe, 0x9c, 0xb3, 0x6e, 0xc9, 0x31, 0xb6, 0xeb, 0x00, 0xcc, 0x7f, 0x44, 0x00, 0x92,
+	0xd6, 0xc6, 0x69, 0x36, 0x76, 0x2b, 0x9e, 0x42, 0xea, 0xd8, 0x58, 0x54, 0x54, 0xae, 0xb0, 0xa5,
+	0x2c, 0x9a, 0x0e, 0xce, 0xc6, 0x72, 0xb2, 0xcb, 0xbd, 0xc7, 0x96, 0xc4, 0x33, 0x38, 0xb2, 0xd4,
+	0x20, 0xeb, 0x1b, 0x2a, 0xd7, 0xc8, 0x75, 0x36, 0xf4, 0x98, 0xb4, 0x4f, 0x7e, 0x44, 0xae, 0xc5,
+	0x0b, 0x38, 0x56, 0x9a, 0x4b, 0xb3, 0xf8, 0x4a, 0x4b, 0x2e, 0x2b, 0x6d, 0x69, 0xd9, 0xf5, 0xcf,
+	0x62, 0x8f, 0x15, 0x4a, 0xf3, 0x07, 0xff, 0xf5, 0xb6, 0xff, 0x11, 0x57, 0x30, 0xed, 0x2a, 0xb0,
+	0x61, 0xb2, 0x2b, 0x64, 0xfa, 0xb3, 0x56, 0x93, 0xcb, 0x46, 0xd3, 0xe1, 0xd9, 0x58, 0x9e, 0x2a,
+	0xcd, 0x17, 0x3d, 0xec, 0xf7, 0x36, 0x9a, 0x5c, 0xc7, 0x4f, 0x35, 0xa5, 0xdd, 0x6b, 0xca, 0x92,
+	0xc0, 0x4f, 0x35, 0xb7, 0x3a, 0xdf, 0xc5, 0xf7, 0x07, 0x0f, 0x23, 0x19, 0x77, 0xfc, 0xf3, 0x9f,
+	0x03, 0x18, 0x5f, 0x69, 0x7e, 0x63, 0xda, 0x56, 0xb3, 0x78, 0x00, 0x91, 0xae, 0xb2, 0x81, 0xaf,
+	0x89, 0x74, 0x25, 0x32, 0xb8, 0xe7, 0x36, 0x7e, 0x88, 0x5f, 0x46, 0x2a, 0xfb, 0x50, 0x08, 0x88,
+	0x17, 0xa6, 0xda, 0x7a, 0xfd, 0xa9, 0xf4, 0x6f, 0xf1, 0x1c, 0x12, 0xdc, 0x70, 0x6d, 0xac, 0x57,
+	0x3a, 0x99, 0x1d, 0x17, 0xc1, 0x88, 0x22, 0x74, 0xbf, 0xf0, 0x7f, 0x72, 0x87, 0x11, 0x33, 0x18,
+	0x2f, 0x7d, 0x9e, 0xc9, 0x66, 0xa3, 0x7f, 0x14, 0xdc, 0xc2, 0xc4, 0x29, 0xc0, 0x1a, 0x2d, 0xad,
+	0xb8, 0xd4, 0x95, 0xcb, 0x12, 0xbf, 0x91, 0x71, 0xc8, 0x5c, 0x57, 0x2e, 0xaf, 0x21, 0xbd, 0x5b,
+	0xd9, 0x91, 0xf4, 0x46, 0x0e, 0x02, 0xc9, 0xee, 0x2d, 0x8e, 0x61, 0x44, 0x2d, 0xea, 0x66, 0x27,
+	0x28, 0x04, 0xa2, 0x80, 0xb8, 0x42, 0x26, 0x2f, 0x67, 0x32, 0x3b, 0x29, 0xc2, 0xe5, 0x14, 0xfd,
+	0xe5, 0x14, 0xf3, 0xfe, 0x72, 0xa4, 0xc7, 0xe5, 0x39, 0xc0, 0xe5, 0x37, 0xcd, 0x9f, 0x18, 0x79,
+	0xe3, 0xba, 0x9e, 0x37, 0xd8, 0x6c, 0xc2, 0xa0, 0x91, 0x0c, 0x41, 0x3e, 0x87, 0xe4, 0xb5, 0xc5,
+	0xd5, 0xb2, 0x3e, 0xc8, 0xe3, 0x15, 0x1c, 0x31, 0x5a, 0x45, 0x5c, 0x06, 0x79, 0x9e, 0xcf, 0x64,
+	0xf6, 0xa8, 0x5f, 0xc1, 0xde, 0x14, 0x99, 0x06, 0x5c, 0x88, 0xf2, 0xef, 0x30, 0x9c, 0xa3, 0x3a,
+	0xd8, 0x32, 0xb8, 0x17, 0xed, 0xdd, 0xfb, 0x6b, 0xc4, 0xf0, 0xbf, 0x46, 0x74, 0xae, 0xb7, 0xe4,
+	0x1c, 0x2a, 0xf2, 0x46, 0xa6, 0xb2, 0x0f, 0xf3, 0x4b, 0x88, 0x3f, 0x3b, 0xb2, 0xe2, 0x31, 0x8c,
+	0x54, 0x53, 0xee, 0x4f, 0x25, 0x56, 0xcd, 0x75, 0xb5, 0xa7, 0x14, 0x1d, 0xda, 0xf6, 0xf0, 0xce,
+	0xb6, 0x17, 0x89, 0xdf, 0xeb, 0xcb, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xaa, 0x7f, 0xf5, 0xea,
+	0xb7, 0x03, 0x00, 0x00,
 }

vendor/vendor.json

@@ -152,12 +152,12 @@
 			"revisionTime": "2016-11-17T07:43:51Z"
 		},
 		{
-			"checksumSHA1": "A2jWY7L3EazZt0xdKFKMDOGXCdk=",
+			"checksumSHA1": "tisAil16tojFqhqWYbs2kXwBYyk=",
 			"path": "gitlab.com/gitlab-org/gitaly-proto/go",
-			"revision": "b61fee8cd76e282d15a3c719f7f71a4f71ef0d6c",
-			"revisionTime": "2017-09-20T19:16:33Z",
-			"version": "v0.35.0",
-			"versionExact": "v0.35.0"
+			"revision": "12872bd8dad9dc72328b2c590386e67a17c65612",
+			"revisionTime": "2017-09-27T21:53:01Z",
+			"version": "v0.38.0",
+			"versionExact": "v0.38.0"
 		},
 		{
 			"checksumSHA1": "dUHJbKas746n5fLzlwxHb6FOCxs=",