From 5f818566d316cc0235bfff67b74669677aecdc89 Mon Sep 17 00:00:00 2001 From: Geoffrey Gilmore Date: Tue, 7 May 2024 10:43:40 -0700 Subject: [PATCH] gitserver: grpc: create changed files RPC implementation for gRPC server (#62262) Part of https://github.com/sourcegraph/sourcegraph/issues/60654 This PR implements a new gitserver gRPC method, ChangedFiles that lists the files that changed between two commits alonside their added/modified/deleted status. This PR builds on the functionality exposed in https://github.com/sourcegraph/sourcegraph/pull/62252. ## Test plan Unit tests --- cmd/gitserver/internal/git/gitcli/diff.go | 20 +- .../internal/git/gitcli/diff_test.go | 26 + cmd/gitserver/internal/git/iface.go | 2 + cmd/gitserver/internal/server_grpc.go | 81 + cmd/gitserver/internal/server_grpc_logger.go | 35 +- cmd/gitserver/internal/server_grpc_test.go | 116 + internal/gitserver/errwrap.go | 18 + internal/gitserver/gitdomain/BUILD.bazel | 5 +- internal/gitserver/gitdomain/log.go | 65 +- internal/gitserver/gitdomain/log_test.go | 76 + internal/gitserver/mock.go | 1892 +++++++++++++++++ internal/gitserver/retry.go | 5 + internal/gitserver/v1/gitserver.pb.go | 1207 +++++++---- internal/gitserver/v1/gitserver.proto | 43 + internal/gitserver/v1/gitserver_grpc.pb.go | 84 + mockgen.temp.yaml | 2 + 16 files changed, 3216 insertions(+), 461 deletions(-) create mode 100644 internal/gitserver/gitdomain/log_test.go diff --git a/cmd/gitserver/internal/git/gitcli/diff.go b/cmd/gitserver/internal/git/gitcli/diff.go index 41904d839eb..0ad8a144b6e 100644 --- a/cmd/gitserver/internal/git/gitcli/diff.go +++ b/cmd/gitserver/internal/git/gitcli/diff.go @@ -87,13 +87,18 @@ func newGitDiffIterator(rc io.ReadCloser) git.ChangedFilesIterator { scanner := bufio.NewScanner(rc) scanner.Split(byteutils.ScanNullLines) + closeChan := make(chan struct{}) closer := sync.OnceValue(func() error { - return rc.Close() + err := rc.Close() + close(closeChan) + + return err }) return &gitDiffIterator{ rc: rc, scanner: scanner, + closeChan: closeChan, onceFuncCloser: closer, } } @@ -102,11 +107,24 @@ type gitDiffIterator struct { rc io.ReadCloser scanner *bufio.Scanner + closeChan chan struct{} onceFuncCloser func() error } func (i *gitDiffIterator) Next() (gitdomain.PathStatus, error) { + select { + case <-i.closeChan: + return gitdomain.PathStatus{}, io.EOF + default: + } + for i.scanner.Scan() { + select { + case <-i.closeChan: + return gitdomain.PathStatus{}, io.EOF + default: + } + status := i.scanner.Text() if len(status) == 0 { continue diff --git a/cmd/gitserver/internal/git/gitcli/diff_test.go b/cmd/gitserver/internal/git/gitcli/diff_test.go index f52ea672390..f594c846a41 100644 --- a/cmd/gitserver/internal/git/gitcli/diff_test.go +++ b/cmd/gitserver/internal/git/gitcli/diff_test.go @@ -660,6 +660,32 @@ func TestGitDiffIterator(t *testing.T) { err := iter.Close() require.NoError(t, err) + + // Verify that Next returns io.EOF after the iterator is closed + _, err = iter.Next() + require.Equal(t, io.EOF, err) + }) + + t.Run("close iterator during iteration", func(t *testing.T) { + input := combineBytes( + []byte("A"), []byte{NUL}, []byte("file1.txt"), []byte{NUL}, + []byte("M"), []byte{NUL}, []byte("file2.txt"), []byte{NUL}, + []byte("D"), []byte{NUL}, []byte("file3.txt"), []byte{NUL}, + ) + rc := io.NopCloser(bytes.NewReader(input)) + iter := newGitDiffIterator(rc) + + // Iterate over the first change + _, err := iter.Next() + require.NoError(t, err) + + // Close the iterator during iteration + err = iter.Close() + require.NoError(t, err) + + // Verify that Next returns io.EOF after the iterator is closed + _, err = iter.Next() + require.Equal(t, io.EOF, err) }) } diff --git a/cmd/gitserver/internal/git/iface.go b/cmd/gitserver/internal/git/iface.go index 03408b922e6..17eed8feea0 100644 --- a/cmd/gitserver/internal/git/iface.go +++ b/cmd/gitserver/internal/git/iface.go @@ -217,6 +217,8 @@ type ChangedFilesIterator interface { // If there are no more files, io.EOF is returned. Next() (gitdomain.PathStatus, error) // Close releases resources associated with the iterator. + // + // After Close() is called, Next() will always return io.EOF. Close() error } diff --git a/cmd/gitserver/internal/server_grpc.go b/cmd/gitserver/internal/server_grpc.go index b7c46020af4..015652113f6 100644 --- a/cmd/gitserver/internal/server_grpc.go +++ b/cmd/gitserver/internal/server_grpc.go @@ -1439,6 +1439,87 @@ func (gs *grpcServer) BehindAhead(ctx context.Context, req *proto.BehindAheadReq return behindAhead.ToProto(), nil } +func (gs *grpcServer) ChangedFiles(req *proto.ChangedFilesRequest, ss proto.GitserverService_ChangedFilesServer) error { + ctx := ss.Context() + + accesslog.Record( + ctx, + req.GetRepoName(), + log.String("base", string(req.GetBase())), + log.String("head", string(req.GetHead())), + ) + + if req.GetRepoName() == "" { + return status.New(codes.InvalidArgument, "repo must be specified").Err() + } + + if len(req.GetHead()) == 0 { + return status.New(codes.InvalidArgument, "head () must be specified").Err() + } + + repoName := api.RepoName(req.GetRepoName()) + repoDir := gs.fs.RepoDir(repoName) + + if err := gs.checkRepoExists(ctx, repoName); err != nil { + return err + } + + backend := gs.getBackendFunc(repoDir, repoName) + + iterator, err := backend.ChangedFiles(ctx, string(req.GetBase()), string(req.GetHead())) + if err != nil { + if gitdomain.IsRevisionNotFoundError(err) { + s, err := status.New(codes.NotFound, "revision not found").WithDetails(&proto.RevisionNotFoundPayload{ + Repo: req.GetRepoName(), + Spec: err.Error(), + }) + if err != nil { + return err + } + return s.Err() + } + + gs.svc.LogIfCorrupt(ctx, repoName, err) + return err + } + defer iterator.Close() + + chunker := chunk.New(func(paths []*proto.ChangedFile) error { + out := &proto.ChangedFilesResponse{ + Files: paths, + } + + return ss.Send(out) + }) + + for { + select { + case <-ctx.Done(): + return ctx.Err() + default: + } + + file, err := iterator.Next() + if err == io.EOF { + break + } + + if err != nil { + return errors.Wrap(err, "failed to get changed file") + } + + if err := chunker.Send(file.ToProto()); err != nil { + return errors.Wrapf(err, "failed to send changed file %s", file) + } + } + + if err := chunker.Flush(); err != nil { + return errors.Wrap(err, "failed to flush file chunks") + } + + return nil +} + // checkRepoExists checks if a given repository is cloned on disk, and returns an // error otherwise. // On Sourcegraph.com, not all repos are managed by the scheduler. We thus diff --git a/cmd/gitserver/internal/server_grpc_logger.go b/cmd/gitserver/internal/server_grpc_logger.go index 70b132da363..f8ff81e4111 100644 --- a/cmd/gitserver/internal/server_grpc_logger.go +++ b/cmd/gitserver/internal/server_grpc_logger.go @@ -6,15 +6,17 @@ import ( "sync/atomic" "time" + "google.golang.org/grpc/codes" + "github.com/sourcegraph/sourcegraph/cmd/gitserver/internal/urlredactor" "github.com/sourcegraph/sourcegraph/internal/grpc/grpcutil" "github.com/sourcegraph/sourcegraph/internal/vcs" - "google.golang.org/grpc/codes" "github.com/sourcegraph/log" + "google.golang.org/grpc/status" + proto "github.com/sourcegraph/sourcegraph/internal/gitserver/v1" "github.com/sourcegraph/sourcegraph/internal/trace" - "google.golang.org/grpc/status" ) // loggingGRPCServer is a wrapper around the provided GitserverServiceServer @@ -1004,6 +1006,35 @@ func BehindAheadRequestToLogFields(req *proto.BehindAheadRequest) []log.Field { } } +func (l *loggingGRPCServer) ChangedFiles(req *proto.ChangedFilesRequest, ss proto.GitserverService_ChangedFilesServer) (err error) { + start := time.Now() + + defer func() { + elapsed := time.Since(start) + + doLog( + l.logger, + proto.GitserverService_ChangedFiles_FullMethodName, + status.Code(err), + trace.Context(ss.Context()).TraceID, + elapsed, + + changedFilesRequestToLogFields(req)..., + ) + + }() + + return l.base.ChangedFiles(req, ss) +} + +func changedFilesRequestToLogFields(req *proto.ChangedFilesRequest) []log.Field { + return []log.Field{ + log.String("repoName", req.GetRepoName()), + log.String("base", string(req.GetBase())), + log.String("head", string(req.GetHead())), + } +} + type loggingRepositoryServiceServer struct { base proto.GitserverRepositoryServiceServer logger log.Logger diff --git a/cmd/gitserver/internal/server_grpc_test.go b/cmd/gitserver/internal/server_grpc_test.go index 6969c0bc142..15f002e123f 100644 --- a/cmd/gitserver/internal/server_grpc_test.go +++ b/cmd/gitserver/internal/server_grpc_test.go @@ -906,6 +906,105 @@ func TestGRPCServer_ContributorCounts(t *testing.T) { }) } +func TestGRPCServer_ChangedFiles(t *testing.T) { + mockSS := gitserver.NewMockGitserverService_ChangedFilesServer() + mockSS.ContextFunc.SetDefaultReturn(context.Background()) + t.Run("argument validation", func(t *testing.T) { + t.Run("repo must be specified", func(t *testing.T) { + gs := &grpcServer{} + err := gs.ChangedFiles(&v1.ChangedFilesRequest{RepoName: "", Head: []byte("HEAD")}, mockSS) + require.ErrorContains(t, err, "repo must be specified") + assertGRPCStatusCode(t, err, codes.InvalidArgument) + }) + + t.Run("head () must be specified", func(t *testing.T) { + gs := &grpcServer{} + err := gs.ChangedFiles(&v1.ChangedFilesRequest{RepoName: "therepo"}, mockSS) + require.ErrorContains(t, err, "head () must be specified") + assertGRPCStatusCode(t, err, codes.InvalidArgument) + }) + }) + t.Run("checks for uncloned repo", func(t *testing.T) { + fs := gitserverfs.NewMockFS() + fs.RepoClonedFunc.SetDefaultReturn(false, nil) + locker := NewMockRepositoryLocker() + locker.StatusFunc.SetDefaultReturn("cloning", true) + gs := &grpcServer{svc: NewMockService(), fs: fs, locker: locker} + err := gs.ChangedFiles(&v1.ChangedFilesRequest{RepoName: "therepo", Base: []byte("base"), Head: []byte("head")}, mockSS) + require.Error(t, err) + assertGRPCStatusCode(t, err, codes.NotFound) + assertHasGRPCErrorDetailOfType(t, err, &proto.RepoNotFoundPayload{}) + require.Contains(t, err.Error(), "repo not found") + mockassert.Called(t, fs.RepoClonedFunc) + mockassert.Called(t, locker.StatusFunc) + }) + t.Run("revision not found", func(t *testing.T) { + fs := gitserverfs.NewMockFS() + // Repo is cloned, proceed! + fs.RepoClonedFunc.SetDefaultReturn(true, nil) + gs := &grpcServer{ + svc: NewMockService(), + fs: fs, + getBackendFunc: func(common.GitDir, api.RepoName) git.GitBackend { + b := git.NewMockGitBackend() + b.ChangedFilesFunc.SetDefaultReturn(nil, &gitdomain.RevisionNotFoundError{Repo: "therepo", Spec: "base...head"}) + return b + }, + } + err := gs.ChangedFiles(&v1.ChangedFilesRequest{RepoName: "therepo", Base: []byte("base"), Head: []byte("head")}, mockSS) + require.Error(t, err) + assertGRPCStatusCode(t, err, codes.NotFound) + assertHasGRPCErrorDetailOfType(t, err, &proto.RevisionNotFoundPayload{}) + require.Contains(t, err.Error(), "revision not found") + }) + t.Run("e2e", func(t *testing.T) { + fs := gitserverfs.NewMockFS() + // Repo is cloned, proceed! + fs.RepoClonedFunc.SetDefaultReturn(true, nil) + b := git.NewMockGitBackend() + b.ChangedFilesFunc.SetDefaultReturn(&testChangedFilesIterator{ + paths: []gitdomain.PathStatus{ + {Path: "file1.txt", Status: gitdomain.AddedAMD}, + {Path: "file2.txt", Status: gitdomain.ModifiedAMD}, + {Path: "file3.txt", Status: gitdomain.DeletedAMD}, + }, + }, nil) + gs := &grpcServer{ + svc: NewMockService(), + fs: fs, + getBackendFunc: func(common.GitDir, api.RepoName) git.GitBackend { + return b + }, + } + + cli := spawnServer(t, gs) + r, err := cli.ChangedFiles(context.Background(), &v1.ChangedFilesRequest{ + RepoName: "therepo", + Base: []byte("base"), + Head: []byte("head"), + }) + require.NoError(t, err) + var paths []*proto.ChangedFile + for { + msg, err := r.Recv() + if err != nil { + if err == io.EOF { + break + } + require.NoError(t, err) + } + paths = append(paths, msg.GetFiles()...) + } + if diff := cmp.Diff([]*proto.ChangedFile{ + {Path: []byte("file1.txt"), Status: proto.ChangedFile_STATUS_ADDED}, + {Path: []byte("file2.txt"), Status: proto.ChangedFile_STATUS_MODIFIED}, + {Path: []byte("file3.txt"), Status: proto.ChangedFile_STATUS_DELETED}, + }, paths, protocmp.Transform()); diff != "" { + t.Fatalf("unexpected response (-want +got):\n%s", diff) + } + }) +} + func TestGRPCServer_FirstCommitEver(t *testing.T) { ctx := context.Background() @@ -1106,3 +1205,20 @@ func spawnServer(t *testing.T, server *grpcServer) proto.GitserverServiceClient return proto.NewGitserverServiceClient(cc) } + +type testChangedFilesIterator struct { + paths []gitdomain.PathStatus +} + +func (t *testChangedFilesIterator) Next() (gitdomain.PathStatus, error) { + if len(t.paths) == 0 { + return gitdomain.PathStatus{}, io.EOF + } + path := t.paths[0] + t.paths = t.paths[1:] + return path, nil +} + +func (t *testChangedFilesIterator) Close() error { + return nil +} diff --git a/internal/gitserver/errwrap.go b/internal/gitserver/errwrap.go index 2e7b450e5af..ad017000446 100644 --- a/internal/gitserver/errwrap.go +++ b/internal/gitserver/errwrap.go @@ -329,4 +329,22 @@ func (r *errorTranslatingClient) BehindAhead(ctx context.Context, in *proto.Behi return res, convertGRPCErrorToGitDomainError(err) } +type errorTranslatingChangedFilesClient struct { + proto.GitserverService_ChangedFilesClient +} + +func (r *errorTranslatingChangedFilesClient) Recv() (*proto.ChangedFilesResponse, error) { + res, err := r.GitserverService_ChangedFilesClient.Recv() + return res, convertGRPCErrorToGitDomainError(err) +} + +// ChangedFiles implements v1.GitserverServiceClient. +func (r *errorTranslatingClient) ChangedFiles(ctx context.Context, in *proto.ChangedFilesRequest, opts ...grpc.CallOption) (proto.GitserverService_ChangedFilesClient, error) { + cc, err := r.base.ChangedFiles(ctx, in, opts...) + if err != nil { + return nil, convertGRPCErrorToGitDomainError(err) + } + return &errorTranslatingChangedFilesClient{cc}, nil +} + var _ proto.GitserverServiceClient = &errorTranslatingClient{} diff --git a/internal/gitserver/gitdomain/BUILD.bazel b/internal/gitserver/gitdomain/BUILD.bazel index 4538cc84883..c7f01eb20d5 100644 --- a/internal/gitserver/gitdomain/BUILD.bazel +++ b/internal/gitserver/gitdomain/BUILD.bazel @@ -23,7 +23,10 @@ go_library( go_test( name = "gitdomain_test", timeout = "short", - srcs = ["common_test.go"], + srcs = [ + "common_test.go", + "log_test.go", + ], embed = [":gitdomain"], deps = [ "//internal/api", diff --git a/internal/gitserver/gitdomain/log.go b/internal/gitserver/gitdomain/log.go index 86be498415a..48152ae5082 100644 --- a/internal/gitserver/gitdomain/log.go +++ b/internal/gitserver/gitdomain/log.go @@ -5,6 +5,7 @@ import ( "fmt" "io" + proto "github.com/sourcegraph/sourcegraph/internal/gitserver/v1" "github.com/sourcegraph/sourcegraph/lib/errors" ) @@ -18,14 +19,72 @@ type PathStatus struct { Status StatusAMD } +func (s *PathStatus) String() string { + return fmt.Sprintf("%s %q", s.Status, s.Path) +} + +func PathStatusFromProto(p *proto.ChangedFile) PathStatus { + return PathStatus{ + Path: string(p.Path), + Status: StatusAMDFromProto(p.Status), + } +} + +func (p *PathStatus) ToProto() *proto.ChangedFile { + return &proto.ChangedFile{ + Path: []byte(p.Path), + Status: p.Status.ToProto(), + } +} + type StatusAMD int const ( - AddedAMD StatusAMD = 0 - ModifiedAMD StatusAMD = 1 - DeletedAMD StatusAMD = 2 + StatusUnspecifiedAMD StatusAMD = 0 + AddedAMD StatusAMD = 1 + ModifiedAMD StatusAMD = 2 + DeletedAMD StatusAMD = 3 ) +func (s StatusAMD) String() string { + switch s { + case AddedAMD: + return "Added" + case ModifiedAMD: + return "Modified" + case DeletedAMD: + return "Deleted" + default: + return "Unspecified" + } +} + +func StatusAMDFromProto(s proto.ChangedFile_Status) StatusAMD { + switch s { + case proto.ChangedFile_STATUS_ADDED: + return AddedAMD + case proto.ChangedFile_STATUS_MODIFIED: + return ModifiedAMD + case proto.ChangedFile_STATUS_DELETED: + return DeletedAMD + default: + return StatusUnspecifiedAMD + } +} + +func (s StatusAMD) ToProto() proto.ChangedFile_Status { + switch s { + case AddedAMD: + return proto.ChangedFile_STATUS_ADDED + case ModifiedAMD: + return proto.ChangedFile_STATUS_MODIFIED + case DeletedAMD: + return proto.ChangedFile_STATUS_DELETED + default: + return proto.ChangedFile_STATUS_UNSPECIFIED + } +} + func LogReverseArgs(n int, givenCommit string) []string { return []string{ "log", diff --git a/internal/gitserver/gitdomain/log_test.go b/internal/gitserver/gitdomain/log_test.go new file mode 100644 index 00000000000..d451f0db612 --- /dev/null +++ b/internal/gitserver/gitdomain/log_test.go @@ -0,0 +1,76 @@ +package gitdomain + +import ( + "math/rand" + "reflect" + "testing" + "testing/quick" + + "github.com/google/go-cmp/cmp" +) + +func TestPathStatus_RoundTrip(t *testing.T) { + var diff string + + if err := quick.Check(func(path string, status fuzzStatus) bool { + original := &PathStatus{ + Path: path, + Status: StatusAMD(status), + } + + converted := PathStatusFromProto(original.ToProto()) + if diff = cmp.Diff(original, &converted); diff != "" { + return false + + } + + return true + }, nil); err != nil { + t.Errorf("PathStatus roundtrip mismatch (-want +got):\n%s", diff) + } +} + +func TestStatusAMD_RoundTrip(t *testing.T) { + // Can't use testing/quick here because the enum has only 4 values. The underlying type of the enum is int, + // so we can't fuzz since it would use the full range of int. + tests := []struct { + name string + amd StatusAMD + }{ + { + name: "AddedAMD", + amd: AddedAMD, + }, + { + name: "ModifiedAMD", + amd: ModifiedAMD, + }, + { + name: "DeletedAMD", + amd: DeletedAMD, + }, + { + name: "StatusUnspecifiedAMD", + amd: StatusUnspecifiedAMD, + }, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + converted := StatusAMDFromProto(test.amd.ToProto()) + + if diff := cmp.Diff(test.amd, converted); diff != "" { + t.Errorf("StatusAMD roundtrip mismatch (-want +got):\n%s", diff) + } + }) + } +} + +type fuzzStatus StatusAMD + +func (fuzzStatus) Generate(rand *rand.Rand, _ int) reflect.Value { + validValues := []StatusAMD{AddedAMD, ModifiedAMD, DeletedAMD, StatusUnspecifiedAMD} + return reflect.ValueOf(fuzzStatus(validValues[rand.Intn(len(validValues))])) +} + +var _ quick.Generator = fuzzStatus(AddedAMD) diff --git a/internal/gitserver/mock.go b/internal/gitserver/mock.go index 008f785465e..e93dc716e92 100644 --- a/internal/gitserver/mock.go +++ b/internal/gitserver/mock.go @@ -29,6 +29,9 @@ type MockGitserverServiceClient struct { // BlameFunc is an instance of a mock function object controlling the // behavior of the method Blame. BlameFunc *GitserverServiceClientBlameFunc + // ChangedFilesFunc is an instance of a mock function object controlling + // the behavior of the method ChangedFiles. + ChangedFilesFunc *GitserverServiceClientChangedFilesFunc // CheckPerforceCredentialsFunc is an instance of a mock function object // controlling the behavior of the method CheckPerforceCredentials. CheckPerforceCredentialsFunc *GitserverServiceClientCheckPerforceCredentialsFunc @@ -130,6 +133,11 @@ func NewMockGitserverServiceClient() *MockGitserverServiceClient { return }, }, + ChangedFilesFunc: &GitserverServiceClientChangedFilesFunc{ + defaultHook: func(context.Context, *v1.ChangedFilesRequest, ...grpc.CallOption) (r0 v1.GitserverService_ChangedFilesClient, r1 error) { + return + }, + }, CheckPerforceCredentialsFunc: &GitserverServiceClientCheckPerforceCredentialsFunc{ defaultHook: func(context.Context, *v1.CheckPerforceCredentialsRequest, ...grpc.CallOption) (r0 *v1.CheckPerforceCredentialsResponse, r1 error) { return @@ -283,6 +291,11 @@ func NewStrictMockGitserverServiceClient() *MockGitserverServiceClient { panic("unexpected invocation of MockGitserverServiceClient.Blame") }, }, + ChangedFilesFunc: &GitserverServiceClientChangedFilesFunc{ + defaultHook: func(context.Context, *v1.ChangedFilesRequest, ...grpc.CallOption) (v1.GitserverService_ChangedFilesClient, error) { + panic("unexpected invocation of MockGitserverServiceClient.ChangedFiles") + }, + }, CheckPerforceCredentialsFunc: &GitserverServiceClientCheckPerforceCredentialsFunc{ defaultHook: func(context.Context, *v1.CheckPerforceCredentialsRequest, ...grpc.CallOption) (*v1.CheckPerforceCredentialsResponse, error) { panic("unexpected invocation of MockGitserverServiceClient.CheckPerforceCredentials") @@ -430,6 +443,9 @@ func NewMockGitserverServiceClientFrom(i v1.GitserverServiceClient) *MockGitserv BlameFunc: &GitserverServiceClientBlameFunc{ defaultHook: i.Blame, }, + ChangedFilesFunc: &GitserverServiceClientChangedFilesFunc{ + defaultHook: i.ChangedFiles, + }, CheckPerforceCredentialsFunc: &GitserverServiceClientCheckPerforceCredentialsFunc{ defaultHook: i.CheckPerforceCredentials, }, @@ -869,6 +885,127 @@ func (c GitserverServiceClientBlameFuncCall) Results() []interface{} { return []interface{}{c.Result0, c.Result1} } +// GitserverServiceClientChangedFilesFunc describes the behavior when the +// ChangedFiles method of the parent MockGitserverServiceClient instance is +// invoked. +type GitserverServiceClientChangedFilesFunc struct { + defaultHook func(context.Context, *v1.ChangedFilesRequest, ...grpc.CallOption) (v1.GitserverService_ChangedFilesClient, error) + hooks []func(context.Context, *v1.ChangedFilesRequest, ...grpc.CallOption) (v1.GitserverService_ChangedFilesClient, error) + history []GitserverServiceClientChangedFilesFuncCall + mutex sync.Mutex +} + +// ChangedFiles delegates to the next hook function in the queue and stores +// the parameter and result values of this invocation. +func (m *MockGitserverServiceClient) ChangedFiles(v0 context.Context, v1 *v1.ChangedFilesRequest, v2 ...grpc.CallOption) (v1.GitserverService_ChangedFilesClient, error) { + r0, r1 := m.ChangedFilesFunc.nextHook()(v0, v1, v2...) + m.ChangedFilesFunc.appendCall(GitserverServiceClientChangedFilesFuncCall{v0, v1, v2, r0, r1}) + return r0, r1 +} + +// SetDefaultHook sets function that is called when the ChangedFiles method +// of the parent MockGitserverServiceClient instance is invoked and the hook +// queue is empty. +func (f *GitserverServiceClientChangedFilesFunc) SetDefaultHook(hook func(context.Context, *v1.ChangedFilesRequest, ...grpc.CallOption) (v1.GitserverService_ChangedFilesClient, error)) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// ChangedFiles method of the parent MockGitserverServiceClient instance +// invokes the hook at the front of the queue and discards it. After the +// queue is empty, the default hook function is invoked for any future +// action. +func (f *GitserverServiceClientChangedFilesFunc) PushHook(hook func(context.Context, *v1.ChangedFilesRequest, ...grpc.CallOption) (v1.GitserverService_ChangedFilesClient, error)) { + f.mutex.Lock() + f.hooks = append(f.hooks, hook) + f.mutex.Unlock() +} + +// SetDefaultReturn calls SetDefaultHook with a function that returns the +// given values. +func (f *GitserverServiceClientChangedFilesFunc) SetDefaultReturn(r0 v1.GitserverService_ChangedFilesClient, r1 error) { + f.SetDefaultHook(func(context.Context, *v1.ChangedFilesRequest, ...grpc.CallOption) (v1.GitserverService_ChangedFilesClient, error) { + return r0, r1 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *GitserverServiceClientChangedFilesFunc) PushReturn(r0 v1.GitserverService_ChangedFilesClient, r1 error) { + f.PushHook(func(context.Context, *v1.ChangedFilesRequest, ...grpc.CallOption) (v1.GitserverService_ChangedFilesClient, error) { + return r0, r1 + }) +} + +func (f *GitserverServiceClientChangedFilesFunc) nextHook() func(context.Context, *v1.ChangedFilesRequest, ...grpc.CallOption) (v1.GitserverService_ChangedFilesClient, error) { + f.mutex.Lock() + defer f.mutex.Unlock() + + if len(f.hooks) == 0 { + return f.defaultHook + } + + hook := f.hooks[0] + f.hooks = f.hooks[1:] + return hook +} + +func (f *GitserverServiceClientChangedFilesFunc) appendCall(r0 GitserverServiceClientChangedFilesFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of GitserverServiceClientChangedFilesFuncCall +// objects describing the invocations of this function. +func (f *GitserverServiceClientChangedFilesFunc) History() []GitserverServiceClientChangedFilesFuncCall { + f.mutex.Lock() + history := make([]GitserverServiceClientChangedFilesFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// GitserverServiceClientChangedFilesFuncCall is an object that describes an +// invocation of method ChangedFiles on an instance of +// MockGitserverServiceClient. +type GitserverServiceClientChangedFilesFuncCall struct { + // Arg0 is the value of the 1st argument passed to this method + // invocation. + Arg0 context.Context + // Arg1 is the value of the 2nd argument passed to this method + // invocation. + Arg1 *v1.ChangedFilesRequest + // Arg2 is a slice containing the values of the variadic arguments + // passed to this method invocation. + Arg2 []grpc.CallOption + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 v1.GitserverService_ChangedFilesClient + // Result1 is the value of the 2nd result returned from this method + // invocation. + Result1 error +} + +// Args returns an interface slice containing the arguments of this +// invocation. The variadic slice argument is flattened in this array such +// that one positional argument and three variadic arguments would result in +// a slice of four, not two. +func (c GitserverServiceClientChangedFilesFuncCall) Args() []interface{} { + trailing := []interface{}{} + for _, val := range c.Arg2 { + trailing = append(trailing, val) + } + + return append([]interface{}{c.Arg0, c.Arg1}, trailing...) +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c GitserverServiceClientChangedFilesFuncCall) Results() []interface{} { + return []interface{}{c.Result0, c.Result1} +} + // GitserverServiceClientCheckPerforceCredentialsFunc describes the behavior // when the CheckPerforceCredentials method of the parent // MockGitserverServiceClient instance is invoked. @@ -7513,6 +7650,1761 @@ func (c GitserverService_BlameServerSetTrailerFuncCall) Results() []interface{} return []interface{}{} } +// MockGitserverService_ChangedFilesClient is a mock implementation of the +// GitserverService_ChangedFilesClient interface (from the package +// github.com/sourcegraph/sourcegraph/internal/gitserver/v1) used for unit +// testing. +type MockGitserverService_ChangedFilesClient struct { + // CloseSendFunc is an instance of a mock function object controlling + // the behavior of the method CloseSend. + CloseSendFunc *GitserverService_ChangedFilesClientCloseSendFunc + // ContextFunc is an instance of a mock function object controlling the + // behavior of the method Context. + ContextFunc *GitserverService_ChangedFilesClientContextFunc + // HeaderFunc is an instance of a mock function object controlling the + // behavior of the method Header. + HeaderFunc *GitserverService_ChangedFilesClientHeaderFunc + // RecvFunc is an instance of a mock function object controlling the + // behavior of the method Recv. + RecvFunc *GitserverService_ChangedFilesClientRecvFunc + // RecvMsgFunc is an instance of a mock function object controlling the + // behavior of the method RecvMsg. + RecvMsgFunc *GitserverService_ChangedFilesClientRecvMsgFunc + // SendMsgFunc is an instance of a mock function object controlling the + // behavior of the method SendMsg. + SendMsgFunc *GitserverService_ChangedFilesClientSendMsgFunc + // TrailerFunc is an instance of a mock function object controlling the + // behavior of the method Trailer. + TrailerFunc *GitserverService_ChangedFilesClientTrailerFunc +} + +// NewMockGitserverService_ChangedFilesClient creates a new mock of the +// GitserverService_ChangedFilesClient interface. All methods return zero +// values for all results, unless overwritten. +func NewMockGitserverService_ChangedFilesClient() *MockGitserverService_ChangedFilesClient { + return &MockGitserverService_ChangedFilesClient{ + CloseSendFunc: &GitserverService_ChangedFilesClientCloseSendFunc{ + defaultHook: func() (r0 error) { + return + }, + }, + ContextFunc: &GitserverService_ChangedFilesClientContextFunc{ + defaultHook: func() (r0 context.Context) { + return + }, + }, + HeaderFunc: &GitserverService_ChangedFilesClientHeaderFunc{ + defaultHook: func() (r0 metadata.MD, r1 error) { + return + }, + }, + RecvFunc: &GitserverService_ChangedFilesClientRecvFunc{ + defaultHook: func() (r0 *v1.ChangedFilesResponse, r1 error) { + return + }, + }, + RecvMsgFunc: &GitserverService_ChangedFilesClientRecvMsgFunc{ + defaultHook: func(interface{}) (r0 error) { + return + }, + }, + SendMsgFunc: &GitserverService_ChangedFilesClientSendMsgFunc{ + defaultHook: func(interface{}) (r0 error) { + return + }, + }, + TrailerFunc: &GitserverService_ChangedFilesClientTrailerFunc{ + defaultHook: func() (r0 metadata.MD) { + return + }, + }, + } +} + +// NewStrictMockGitserverService_ChangedFilesClient creates a new mock of +// the GitserverService_ChangedFilesClient interface. All methods panic on +// invocation, unless overwritten. +func NewStrictMockGitserverService_ChangedFilesClient() *MockGitserverService_ChangedFilesClient { + return &MockGitserverService_ChangedFilesClient{ + CloseSendFunc: &GitserverService_ChangedFilesClientCloseSendFunc{ + defaultHook: func() error { + panic("unexpected invocation of MockGitserverService_ChangedFilesClient.CloseSend") + }, + }, + ContextFunc: &GitserverService_ChangedFilesClientContextFunc{ + defaultHook: func() context.Context { + panic("unexpected invocation of MockGitserverService_ChangedFilesClient.Context") + }, + }, + HeaderFunc: &GitserverService_ChangedFilesClientHeaderFunc{ + defaultHook: func() (metadata.MD, error) { + panic("unexpected invocation of MockGitserverService_ChangedFilesClient.Header") + }, + }, + RecvFunc: &GitserverService_ChangedFilesClientRecvFunc{ + defaultHook: func() (*v1.ChangedFilesResponse, error) { + panic("unexpected invocation of MockGitserverService_ChangedFilesClient.Recv") + }, + }, + RecvMsgFunc: &GitserverService_ChangedFilesClientRecvMsgFunc{ + defaultHook: func(interface{}) error { + panic("unexpected invocation of MockGitserverService_ChangedFilesClient.RecvMsg") + }, + }, + SendMsgFunc: &GitserverService_ChangedFilesClientSendMsgFunc{ + defaultHook: func(interface{}) error { + panic("unexpected invocation of MockGitserverService_ChangedFilesClient.SendMsg") + }, + }, + TrailerFunc: &GitserverService_ChangedFilesClientTrailerFunc{ + defaultHook: func() metadata.MD { + panic("unexpected invocation of MockGitserverService_ChangedFilesClient.Trailer") + }, + }, + } +} + +// NewMockGitserverService_ChangedFilesClientFrom creates a new mock of the +// MockGitserverService_ChangedFilesClient interface. All methods delegate +// to the given implementation, unless overwritten. +func NewMockGitserverService_ChangedFilesClientFrom(i v1.GitserverService_ChangedFilesClient) *MockGitserverService_ChangedFilesClient { + return &MockGitserverService_ChangedFilesClient{ + CloseSendFunc: &GitserverService_ChangedFilesClientCloseSendFunc{ + defaultHook: i.CloseSend, + }, + ContextFunc: &GitserverService_ChangedFilesClientContextFunc{ + defaultHook: i.Context, + }, + HeaderFunc: &GitserverService_ChangedFilesClientHeaderFunc{ + defaultHook: i.Header, + }, + RecvFunc: &GitserverService_ChangedFilesClientRecvFunc{ + defaultHook: i.Recv, + }, + RecvMsgFunc: &GitserverService_ChangedFilesClientRecvMsgFunc{ + defaultHook: i.RecvMsg, + }, + SendMsgFunc: &GitserverService_ChangedFilesClientSendMsgFunc{ + defaultHook: i.SendMsg, + }, + TrailerFunc: &GitserverService_ChangedFilesClientTrailerFunc{ + defaultHook: i.Trailer, + }, + } +} + +// GitserverService_ChangedFilesClientCloseSendFunc describes the behavior +// when the CloseSend method of the parent +// MockGitserverService_ChangedFilesClient instance is invoked. +type GitserverService_ChangedFilesClientCloseSendFunc struct { + defaultHook func() error + hooks []func() error + history []GitserverService_ChangedFilesClientCloseSendFuncCall + mutex sync.Mutex +} + +// CloseSend delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockGitserverService_ChangedFilesClient) CloseSend() error { + r0 := m.CloseSendFunc.nextHook()() + m.CloseSendFunc.appendCall(GitserverService_ChangedFilesClientCloseSendFuncCall{r0}) + return r0 +} + +// SetDefaultHook sets function that is called when the CloseSend method of +// the parent MockGitserverService_ChangedFilesClient instance is invoked +// and the hook queue is empty. +func (f *GitserverService_ChangedFilesClientCloseSendFunc) SetDefaultHook(hook func() error) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// CloseSend method of the parent MockGitserverService_ChangedFilesClient +// instance invokes the hook at the front of the queue and discards it. +// After the queue is empty, the default hook function is invoked for any +// future action. +func (f *GitserverService_ChangedFilesClientCloseSendFunc) PushHook(hook func() error) { + f.mutex.Lock() + f.hooks = append(f.hooks, hook) + f.mutex.Unlock() +} + +// SetDefaultReturn calls SetDefaultHook with a function that returns the +// given values. +func (f *GitserverService_ChangedFilesClientCloseSendFunc) SetDefaultReturn(r0 error) { + f.SetDefaultHook(func() error { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *GitserverService_ChangedFilesClientCloseSendFunc) PushReturn(r0 error) { + f.PushHook(func() error { + return r0 + }) +} + +func (f *GitserverService_ChangedFilesClientCloseSendFunc) nextHook() func() error { + f.mutex.Lock() + defer f.mutex.Unlock() + + if len(f.hooks) == 0 { + return f.defaultHook + } + + hook := f.hooks[0] + f.hooks = f.hooks[1:] + return hook +} + +func (f *GitserverService_ChangedFilesClientCloseSendFunc) appendCall(r0 GitserverService_ChangedFilesClientCloseSendFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of +// GitserverService_ChangedFilesClientCloseSendFuncCall objects describing +// the invocations of this function. +func (f *GitserverService_ChangedFilesClientCloseSendFunc) History() []GitserverService_ChangedFilesClientCloseSendFuncCall { + f.mutex.Lock() + history := make([]GitserverService_ChangedFilesClientCloseSendFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// GitserverService_ChangedFilesClientCloseSendFuncCall is an object that +// describes an invocation of method CloseSend on an instance of +// MockGitserverService_ChangedFilesClient. +type GitserverService_ChangedFilesClientCloseSendFuncCall struct { + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 error +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c GitserverService_ChangedFilesClientCloseSendFuncCall) Args() []interface{} { + return []interface{}{} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c GitserverService_ChangedFilesClientCloseSendFuncCall) Results() []interface{} { + return []interface{}{c.Result0} +} + +// GitserverService_ChangedFilesClientContextFunc describes the behavior +// when the Context method of the parent +// MockGitserverService_ChangedFilesClient instance is invoked. +type GitserverService_ChangedFilesClientContextFunc struct { + defaultHook func() context.Context + hooks []func() context.Context + history []GitserverService_ChangedFilesClientContextFuncCall + mutex sync.Mutex +} + +// Context delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockGitserverService_ChangedFilesClient) Context() context.Context { + r0 := m.ContextFunc.nextHook()() + m.ContextFunc.appendCall(GitserverService_ChangedFilesClientContextFuncCall{r0}) + return r0 +} + +// SetDefaultHook sets function that is called when the Context method of +// the parent MockGitserverService_ChangedFilesClient instance is invoked +// and the hook queue is empty. +func (f *GitserverService_ChangedFilesClientContextFunc) SetDefaultHook(hook func() context.Context) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// Context method of the parent MockGitserverService_ChangedFilesClient +// instance invokes the hook at the front of the queue and discards it. +// After the queue is empty, the default hook function is invoked for any +// future action. +func (f *GitserverService_ChangedFilesClientContextFunc) PushHook(hook func() context.Context) { + f.mutex.Lock() + f.hooks = append(f.hooks, hook) + f.mutex.Unlock() +} + +// SetDefaultReturn calls SetDefaultHook with a function that returns the +// given values. +func (f *GitserverService_ChangedFilesClientContextFunc) SetDefaultReturn(r0 context.Context) { + f.SetDefaultHook(func() context.Context { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *GitserverService_ChangedFilesClientContextFunc) PushReturn(r0 context.Context) { + f.PushHook(func() context.Context { + return r0 + }) +} + +func (f *GitserverService_ChangedFilesClientContextFunc) nextHook() func() context.Context { + f.mutex.Lock() + defer f.mutex.Unlock() + + if len(f.hooks) == 0 { + return f.defaultHook + } + + hook := f.hooks[0] + f.hooks = f.hooks[1:] + return hook +} + +func (f *GitserverService_ChangedFilesClientContextFunc) appendCall(r0 GitserverService_ChangedFilesClientContextFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of +// GitserverService_ChangedFilesClientContextFuncCall objects describing the +// invocations of this function. +func (f *GitserverService_ChangedFilesClientContextFunc) History() []GitserverService_ChangedFilesClientContextFuncCall { + f.mutex.Lock() + history := make([]GitserverService_ChangedFilesClientContextFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// GitserverService_ChangedFilesClientContextFuncCall is an object that +// describes an invocation of method Context on an instance of +// MockGitserverService_ChangedFilesClient. +type GitserverService_ChangedFilesClientContextFuncCall struct { + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 context.Context +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c GitserverService_ChangedFilesClientContextFuncCall) Args() []interface{} { + return []interface{}{} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c GitserverService_ChangedFilesClientContextFuncCall) Results() []interface{} { + return []interface{}{c.Result0} +} + +// GitserverService_ChangedFilesClientHeaderFunc describes the behavior when +// the Header method of the parent MockGitserverService_ChangedFilesClient +// instance is invoked. +type GitserverService_ChangedFilesClientHeaderFunc struct { + defaultHook func() (metadata.MD, error) + hooks []func() (metadata.MD, error) + history []GitserverService_ChangedFilesClientHeaderFuncCall + mutex sync.Mutex +} + +// Header delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockGitserverService_ChangedFilesClient) Header() (metadata.MD, error) { + r0, r1 := m.HeaderFunc.nextHook()() + m.HeaderFunc.appendCall(GitserverService_ChangedFilesClientHeaderFuncCall{r0, r1}) + return r0, r1 +} + +// SetDefaultHook sets function that is called when the Header method of the +// parent MockGitserverService_ChangedFilesClient instance is invoked and +// the hook queue is empty. +func (f *GitserverService_ChangedFilesClientHeaderFunc) SetDefaultHook(hook func() (metadata.MD, error)) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// Header method of the parent MockGitserverService_ChangedFilesClient +// instance invokes the hook at the front of the queue and discards it. +// After the queue is empty, the default hook function is invoked for any +// future action. +func (f *GitserverService_ChangedFilesClientHeaderFunc) PushHook(hook func() (metadata.MD, error)) { + f.mutex.Lock() + f.hooks = append(f.hooks, hook) + f.mutex.Unlock() +} + +// SetDefaultReturn calls SetDefaultHook with a function that returns the +// given values. +func (f *GitserverService_ChangedFilesClientHeaderFunc) SetDefaultReturn(r0 metadata.MD, r1 error) { + f.SetDefaultHook(func() (metadata.MD, error) { + return r0, r1 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *GitserverService_ChangedFilesClientHeaderFunc) PushReturn(r0 metadata.MD, r1 error) { + f.PushHook(func() (metadata.MD, error) { + return r0, r1 + }) +} + +func (f *GitserverService_ChangedFilesClientHeaderFunc) nextHook() func() (metadata.MD, error) { + f.mutex.Lock() + defer f.mutex.Unlock() + + if len(f.hooks) == 0 { + return f.defaultHook + } + + hook := f.hooks[0] + f.hooks = f.hooks[1:] + return hook +} + +func (f *GitserverService_ChangedFilesClientHeaderFunc) appendCall(r0 GitserverService_ChangedFilesClientHeaderFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of +// GitserverService_ChangedFilesClientHeaderFuncCall objects describing the +// invocations of this function. +func (f *GitserverService_ChangedFilesClientHeaderFunc) History() []GitserverService_ChangedFilesClientHeaderFuncCall { + f.mutex.Lock() + history := make([]GitserverService_ChangedFilesClientHeaderFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// GitserverService_ChangedFilesClientHeaderFuncCall is an object that +// describes an invocation of method Header on an instance of +// MockGitserverService_ChangedFilesClient. +type GitserverService_ChangedFilesClientHeaderFuncCall struct { + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 metadata.MD + // Result1 is the value of the 2nd result returned from this method + // invocation. + Result1 error +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c GitserverService_ChangedFilesClientHeaderFuncCall) Args() []interface{} { + return []interface{}{} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c GitserverService_ChangedFilesClientHeaderFuncCall) Results() []interface{} { + return []interface{}{c.Result0, c.Result1} +} + +// GitserverService_ChangedFilesClientRecvFunc describes the behavior when +// the Recv method of the parent MockGitserverService_ChangedFilesClient +// instance is invoked. +type GitserverService_ChangedFilesClientRecvFunc struct { + defaultHook func() (*v1.ChangedFilesResponse, error) + hooks []func() (*v1.ChangedFilesResponse, error) + history []GitserverService_ChangedFilesClientRecvFuncCall + mutex sync.Mutex +} + +// Recv delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockGitserverService_ChangedFilesClient) Recv() (*v1.ChangedFilesResponse, error) { + r0, r1 := m.RecvFunc.nextHook()() + m.RecvFunc.appendCall(GitserverService_ChangedFilesClientRecvFuncCall{r0, r1}) + return r0, r1 +} + +// SetDefaultHook sets function that is called when the Recv method of the +// parent MockGitserverService_ChangedFilesClient instance is invoked and +// the hook queue is empty. +func (f *GitserverService_ChangedFilesClientRecvFunc) SetDefaultHook(hook func() (*v1.ChangedFilesResponse, error)) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// Recv method of the parent MockGitserverService_ChangedFilesClient +// instance invokes the hook at the front of the queue and discards it. +// After the queue is empty, the default hook function is invoked for any +// future action. +func (f *GitserverService_ChangedFilesClientRecvFunc) PushHook(hook func() (*v1.ChangedFilesResponse, error)) { + f.mutex.Lock() + f.hooks = append(f.hooks, hook) + f.mutex.Unlock() +} + +// SetDefaultReturn calls SetDefaultHook with a function that returns the +// given values. +func (f *GitserverService_ChangedFilesClientRecvFunc) SetDefaultReturn(r0 *v1.ChangedFilesResponse, r1 error) { + f.SetDefaultHook(func() (*v1.ChangedFilesResponse, error) { + return r0, r1 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *GitserverService_ChangedFilesClientRecvFunc) PushReturn(r0 *v1.ChangedFilesResponse, r1 error) { + f.PushHook(func() (*v1.ChangedFilesResponse, error) { + return r0, r1 + }) +} + +func (f *GitserverService_ChangedFilesClientRecvFunc) nextHook() func() (*v1.ChangedFilesResponse, error) { + f.mutex.Lock() + defer f.mutex.Unlock() + + if len(f.hooks) == 0 { + return f.defaultHook + } + + hook := f.hooks[0] + f.hooks = f.hooks[1:] + return hook +} + +func (f *GitserverService_ChangedFilesClientRecvFunc) appendCall(r0 GitserverService_ChangedFilesClientRecvFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of +// GitserverService_ChangedFilesClientRecvFuncCall objects describing the +// invocations of this function. +func (f *GitserverService_ChangedFilesClientRecvFunc) History() []GitserverService_ChangedFilesClientRecvFuncCall { + f.mutex.Lock() + history := make([]GitserverService_ChangedFilesClientRecvFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// GitserverService_ChangedFilesClientRecvFuncCall is an object that +// describes an invocation of method Recv on an instance of +// MockGitserverService_ChangedFilesClient. +type GitserverService_ChangedFilesClientRecvFuncCall struct { + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 *v1.ChangedFilesResponse + // Result1 is the value of the 2nd result returned from this method + // invocation. + Result1 error +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c GitserverService_ChangedFilesClientRecvFuncCall) Args() []interface{} { + return []interface{}{} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c GitserverService_ChangedFilesClientRecvFuncCall) Results() []interface{} { + return []interface{}{c.Result0, c.Result1} +} + +// GitserverService_ChangedFilesClientRecvMsgFunc describes the behavior +// when the RecvMsg method of the parent +// MockGitserverService_ChangedFilesClient instance is invoked. +type GitserverService_ChangedFilesClientRecvMsgFunc struct { + defaultHook func(interface{}) error + hooks []func(interface{}) error + history []GitserverService_ChangedFilesClientRecvMsgFuncCall + mutex sync.Mutex +} + +// RecvMsg delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockGitserverService_ChangedFilesClient) RecvMsg(v0 interface{}) error { + r0 := m.RecvMsgFunc.nextHook()(v0) + m.RecvMsgFunc.appendCall(GitserverService_ChangedFilesClientRecvMsgFuncCall{v0, r0}) + return r0 +} + +// SetDefaultHook sets function that is called when the RecvMsg method of +// the parent MockGitserverService_ChangedFilesClient instance is invoked +// and the hook queue is empty. +func (f *GitserverService_ChangedFilesClientRecvMsgFunc) SetDefaultHook(hook func(interface{}) error) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// RecvMsg method of the parent MockGitserverService_ChangedFilesClient +// instance invokes the hook at the front of the queue and discards it. +// After the queue is empty, the default hook function is invoked for any +// future action. +func (f *GitserverService_ChangedFilesClientRecvMsgFunc) PushHook(hook func(interface{}) error) { + f.mutex.Lock() + f.hooks = append(f.hooks, hook) + f.mutex.Unlock() +} + +// SetDefaultReturn calls SetDefaultHook with a function that returns the +// given values. +func (f *GitserverService_ChangedFilesClientRecvMsgFunc) SetDefaultReturn(r0 error) { + f.SetDefaultHook(func(interface{}) error { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *GitserverService_ChangedFilesClientRecvMsgFunc) PushReturn(r0 error) { + f.PushHook(func(interface{}) error { + return r0 + }) +} + +func (f *GitserverService_ChangedFilesClientRecvMsgFunc) nextHook() func(interface{}) error { + f.mutex.Lock() + defer f.mutex.Unlock() + + if len(f.hooks) == 0 { + return f.defaultHook + } + + hook := f.hooks[0] + f.hooks = f.hooks[1:] + return hook +} + +func (f *GitserverService_ChangedFilesClientRecvMsgFunc) appendCall(r0 GitserverService_ChangedFilesClientRecvMsgFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of +// GitserverService_ChangedFilesClientRecvMsgFuncCall objects describing the +// invocations of this function. +func (f *GitserverService_ChangedFilesClientRecvMsgFunc) History() []GitserverService_ChangedFilesClientRecvMsgFuncCall { + f.mutex.Lock() + history := make([]GitserverService_ChangedFilesClientRecvMsgFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// GitserverService_ChangedFilesClientRecvMsgFuncCall is an object that +// describes an invocation of method RecvMsg on an instance of +// MockGitserverService_ChangedFilesClient. +type GitserverService_ChangedFilesClientRecvMsgFuncCall struct { + // Arg0 is the value of the 1st argument passed to this method + // invocation. + Arg0 interface{} + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 error +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c GitserverService_ChangedFilesClientRecvMsgFuncCall) Args() []interface{} { + return []interface{}{c.Arg0} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c GitserverService_ChangedFilesClientRecvMsgFuncCall) Results() []interface{} { + return []interface{}{c.Result0} +} + +// GitserverService_ChangedFilesClientSendMsgFunc describes the behavior +// when the SendMsg method of the parent +// MockGitserverService_ChangedFilesClient instance is invoked. +type GitserverService_ChangedFilesClientSendMsgFunc struct { + defaultHook func(interface{}) error + hooks []func(interface{}) error + history []GitserverService_ChangedFilesClientSendMsgFuncCall + mutex sync.Mutex +} + +// SendMsg delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockGitserverService_ChangedFilesClient) SendMsg(v0 interface{}) error { + r0 := m.SendMsgFunc.nextHook()(v0) + m.SendMsgFunc.appendCall(GitserverService_ChangedFilesClientSendMsgFuncCall{v0, r0}) + return r0 +} + +// SetDefaultHook sets function that is called when the SendMsg method of +// the parent MockGitserverService_ChangedFilesClient instance is invoked +// and the hook queue is empty. +func (f *GitserverService_ChangedFilesClientSendMsgFunc) SetDefaultHook(hook func(interface{}) error) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// SendMsg method of the parent MockGitserverService_ChangedFilesClient +// instance invokes the hook at the front of the queue and discards it. +// After the queue is empty, the default hook function is invoked for any +// future action. +func (f *GitserverService_ChangedFilesClientSendMsgFunc) PushHook(hook func(interface{}) error) { + f.mutex.Lock() + f.hooks = append(f.hooks, hook) + f.mutex.Unlock() +} + +// SetDefaultReturn calls SetDefaultHook with a function that returns the +// given values. +func (f *GitserverService_ChangedFilesClientSendMsgFunc) SetDefaultReturn(r0 error) { + f.SetDefaultHook(func(interface{}) error { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *GitserverService_ChangedFilesClientSendMsgFunc) PushReturn(r0 error) { + f.PushHook(func(interface{}) error { + return r0 + }) +} + +func (f *GitserverService_ChangedFilesClientSendMsgFunc) nextHook() func(interface{}) error { + f.mutex.Lock() + defer f.mutex.Unlock() + + if len(f.hooks) == 0 { + return f.defaultHook + } + + hook := f.hooks[0] + f.hooks = f.hooks[1:] + return hook +} + +func (f *GitserverService_ChangedFilesClientSendMsgFunc) appendCall(r0 GitserverService_ChangedFilesClientSendMsgFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of +// GitserverService_ChangedFilesClientSendMsgFuncCall objects describing the +// invocations of this function. +func (f *GitserverService_ChangedFilesClientSendMsgFunc) History() []GitserverService_ChangedFilesClientSendMsgFuncCall { + f.mutex.Lock() + history := make([]GitserverService_ChangedFilesClientSendMsgFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// GitserverService_ChangedFilesClientSendMsgFuncCall is an object that +// describes an invocation of method SendMsg on an instance of +// MockGitserverService_ChangedFilesClient. +type GitserverService_ChangedFilesClientSendMsgFuncCall struct { + // Arg0 is the value of the 1st argument passed to this method + // invocation. + Arg0 interface{} + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 error +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c GitserverService_ChangedFilesClientSendMsgFuncCall) Args() []interface{} { + return []interface{}{c.Arg0} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c GitserverService_ChangedFilesClientSendMsgFuncCall) Results() []interface{} { + return []interface{}{c.Result0} +} + +// GitserverService_ChangedFilesClientTrailerFunc describes the behavior +// when the Trailer method of the parent +// MockGitserverService_ChangedFilesClient instance is invoked. +type GitserverService_ChangedFilesClientTrailerFunc struct { + defaultHook func() metadata.MD + hooks []func() metadata.MD + history []GitserverService_ChangedFilesClientTrailerFuncCall + mutex sync.Mutex +} + +// Trailer delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockGitserverService_ChangedFilesClient) Trailer() metadata.MD { + r0 := m.TrailerFunc.nextHook()() + m.TrailerFunc.appendCall(GitserverService_ChangedFilesClientTrailerFuncCall{r0}) + return r0 +} + +// SetDefaultHook sets function that is called when the Trailer method of +// the parent MockGitserverService_ChangedFilesClient instance is invoked +// and the hook queue is empty. +func (f *GitserverService_ChangedFilesClientTrailerFunc) SetDefaultHook(hook func() metadata.MD) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// Trailer method of the parent MockGitserverService_ChangedFilesClient +// instance invokes the hook at the front of the queue and discards it. +// After the queue is empty, the default hook function is invoked for any +// future action. +func (f *GitserverService_ChangedFilesClientTrailerFunc) PushHook(hook func() metadata.MD) { + f.mutex.Lock() + f.hooks = append(f.hooks, hook) + f.mutex.Unlock() +} + +// SetDefaultReturn calls SetDefaultHook with a function that returns the +// given values. +func (f *GitserverService_ChangedFilesClientTrailerFunc) SetDefaultReturn(r0 metadata.MD) { + f.SetDefaultHook(func() metadata.MD { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *GitserverService_ChangedFilesClientTrailerFunc) PushReturn(r0 metadata.MD) { + f.PushHook(func() metadata.MD { + return r0 + }) +} + +func (f *GitserverService_ChangedFilesClientTrailerFunc) nextHook() func() metadata.MD { + f.mutex.Lock() + defer f.mutex.Unlock() + + if len(f.hooks) == 0 { + return f.defaultHook + } + + hook := f.hooks[0] + f.hooks = f.hooks[1:] + return hook +} + +func (f *GitserverService_ChangedFilesClientTrailerFunc) appendCall(r0 GitserverService_ChangedFilesClientTrailerFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of +// GitserverService_ChangedFilesClientTrailerFuncCall objects describing the +// invocations of this function. +func (f *GitserverService_ChangedFilesClientTrailerFunc) History() []GitserverService_ChangedFilesClientTrailerFuncCall { + f.mutex.Lock() + history := make([]GitserverService_ChangedFilesClientTrailerFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// GitserverService_ChangedFilesClientTrailerFuncCall is an object that +// describes an invocation of method Trailer on an instance of +// MockGitserverService_ChangedFilesClient. +type GitserverService_ChangedFilesClientTrailerFuncCall struct { + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 metadata.MD +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c GitserverService_ChangedFilesClientTrailerFuncCall) Args() []interface{} { + return []interface{}{} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c GitserverService_ChangedFilesClientTrailerFuncCall) Results() []interface{} { + return []interface{}{c.Result0} +} + +// MockGitserverService_ChangedFilesServer is a mock implementation of the +// GitserverService_ChangedFilesServer interface (from the package +// github.com/sourcegraph/sourcegraph/internal/gitserver/v1) used for unit +// testing. +type MockGitserverService_ChangedFilesServer struct { + // ContextFunc is an instance of a mock function object controlling the + // behavior of the method Context. + ContextFunc *GitserverService_ChangedFilesServerContextFunc + // RecvMsgFunc is an instance of a mock function object controlling the + // behavior of the method RecvMsg. + RecvMsgFunc *GitserverService_ChangedFilesServerRecvMsgFunc + // SendFunc is an instance of a mock function object controlling the + // behavior of the method Send. + SendFunc *GitserverService_ChangedFilesServerSendFunc + // SendHeaderFunc is an instance of a mock function object controlling + // the behavior of the method SendHeader. + SendHeaderFunc *GitserverService_ChangedFilesServerSendHeaderFunc + // SendMsgFunc is an instance of a mock function object controlling the + // behavior of the method SendMsg. + SendMsgFunc *GitserverService_ChangedFilesServerSendMsgFunc + // SetHeaderFunc is an instance of a mock function object controlling + // the behavior of the method SetHeader. + SetHeaderFunc *GitserverService_ChangedFilesServerSetHeaderFunc + // SetTrailerFunc is an instance of a mock function object controlling + // the behavior of the method SetTrailer. + SetTrailerFunc *GitserverService_ChangedFilesServerSetTrailerFunc +} + +// NewMockGitserverService_ChangedFilesServer creates a new mock of the +// GitserverService_ChangedFilesServer interface. All methods return zero +// values for all results, unless overwritten. +func NewMockGitserverService_ChangedFilesServer() *MockGitserverService_ChangedFilesServer { + return &MockGitserverService_ChangedFilesServer{ + ContextFunc: &GitserverService_ChangedFilesServerContextFunc{ + defaultHook: func() (r0 context.Context) { + return + }, + }, + RecvMsgFunc: &GitserverService_ChangedFilesServerRecvMsgFunc{ + defaultHook: func(interface{}) (r0 error) { + return + }, + }, + SendFunc: &GitserverService_ChangedFilesServerSendFunc{ + defaultHook: func(*v1.ChangedFilesResponse) (r0 error) { + return + }, + }, + SendHeaderFunc: &GitserverService_ChangedFilesServerSendHeaderFunc{ + defaultHook: func(metadata.MD) (r0 error) { + return + }, + }, + SendMsgFunc: &GitserverService_ChangedFilesServerSendMsgFunc{ + defaultHook: func(interface{}) (r0 error) { + return + }, + }, + SetHeaderFunc: &GitserverService_ChangedFilesServerSetHeaderFunc{ + defaultHook: func(metadata.MD) (r0 error) { + return + }, + }, + SetTrailerFunc: &GitserverService_ChangedFilesServerSetTrailerFunc{ + defaultHook: func(metadata.MD) { + return + }, + }, + } +} + +// NewStrictMockGitserverService_ChangedFilesServer creates a new mock of +// the GitserverService_ChangedFilesServer interface. All methods panic on +// invocation, unless overwritten. +func NewStrictMockGitserverService_ChangedFilesServer() *MockGitserverService_ChangedFilesServer { + return &MockGitserverService_ChangedFilesServer{ + ContextFunc: &GitserverService_ChangedFilesServerContextFunc{ + defaultHook: func() context.Context { + panic("unexpected invocation of MockGitserverService_ChangedFilesServer.Context") + }, + }, + RecvMsgFunc: &GitserverService_ChangedFilesServerRecvMsgFunc{ + defaultHook: func(interface{}) error { + panic("unexpected invocation of MockGitserverService_ChangedFilesServer.RecvMsg") + }, + }, + SendFunc: &GitserverService_ChangedFilesServerSendFunc{ + defaultHook: func(*v1.ChangedFilesResponse) error { + panic("unexpected invocation of MockGitserverService_ChangedFilesServer.Send") + }, + }, + SendHeaderFunc: &GitserverService_ChangedFilesServerSendHeaderFunc{ + defaultHook: func(metadata.MD) error { + panic("unexpected invocation of MockGitserverService_ChangedFilesServer.SendHeader") + }, + }, + SendMsgFunc: &GitserverService_ChangedFilesServerSendMsgFunc{ + defaultHook: func(interface{}) error { + panic("unexpected invocation of MockGitserverService_ChangedFilesServer.SendMsg") + }, + }, + SetHeaderFunc: &GitserverService_ChangedFilesServerSetHeaderFunc{ + defaultHook: func(metadata.MD) error { + panic("unexpected invocation of MockGitserverService_ChangedFilesServer.SetHeader") + }, + }, + SetTrailerFunc: &GitserverService_ChangedFilesServerSetTrailerFunc{ + defaultHook: func(metadata.MD) { + panic("unexpected invocation of MockGitserverService_ChangedFilesServer.SetTrailer") + }, + }, + } +} + +// NewMockGitserverService_ChangedFilesServerFrom creates a new mock of the +// MockGitserverService_ChangedFilesServer interface. All methods delegate +// to the given implementation, unless overwritten. +func NewMockGitserverService_ChangedFilesServerFrom(i v1.GitserverService_ChangedFilesServer) *MockGitserverService_ChangedFilesServer { + return &MockGitserverService_ChangedFilesServer{ + ContextFunc: &GitserverService_ChangedFilesServerContextFunc{ + defaultHook: i.Context, + }, + RecvMsgFunc: &GitserverService_ChangedFilesServerRecvMsgFunc{ + defaultHook: i.RecvMsg, + }, + SendFunc: &GitserverService_ChangedFilesServerSendFunc{ + defaultHook: i.Send, + }, + SendHeaderFunc: &GitserverService_ChangedFilesServerSendHeaderFunc{ + defaultHook: i.SendHeader, + }, + SendMsgFunc: &GitserverService_ChangedFilesServerSendMsgFunc{ + defaultHook: i.SendMsg, + }, + SetHeaderFunc: &GitserverService_ChangedFilesServerSetHeaderFunc{ + defaultHook: i.SetHeader, + }, + SetTrailerFunc: &GitserverService_ChangedFilesServerSetTrailerFunc{ + defaultHook: i.SetTrailer, + }, + } +} + +// GitserverService_ChangedFilesServerContextFunc describes the behavior +// when the Context method of the parent +// MockGitserverService_ChangedFilesServer instance is invoked. +type GitserverService_ChangedFilesServerContextFunc struct { + defaultHook func() context.Context + hooks []func() context.Context + history []GitserverService_ChangedFilesServerContextFuncCall + mutex sync.Mutex +} + +// Context delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockGitserverService_ChangedFilesServer) Context() context.Context { + r0 := m.ContextFunc.nextHook()() + m.ContextFunc.appendCall(GitserverService_ChangedFilesServerContextFuncCall{r0}) + return r0 +} + +// SetDefaultHook sets function that is called when the Context method of +// the parent MockGitserverService_ChangedFilesServer instance is invoked +// and the hook queue is empty. +func (f *GitserverService_ChangedFilesServerContextFunc) SetDefaultHook(hook func() context.Context) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// Context method of the parent MockGitserverService_ChangedFilesServer +// instance invokes the hook at the front of the queue and discards it. +// After the queue is empty, the default hook function is invoked for any +// future action. +func (f *GitserverService_ChangedFilesServerContextFunc) PushHook(hook func() context.Context) { + f.mutex.Lock() + f.hooks = append(f.hooks, hook) + f.mutex.Unlock() +} + +// SetDefaultReturn calls SetDefaultHook with a function that returns the +// given values. +func (f *GitserverService_ChangedFilesServerContextFunc) SetDefaultReturn(r0 context.Context) { + f.SetDefaultHook(func() context.Context { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *GitserverService_ChangedFilesServerContextFunc) PushReturn(r0 context.Context) { + f.PushHook(func() context.Context { + return r0 + }) +} + +func (f *GitserverService_ChangedFilesServerContextFunc) nextHook() func() context.Context { + f.mutex.Lock() + defer f.mutex.Unlock() + + if len(f.hooks) == 0 { + return f.defaultHook + } + + hook := f.hooks[0] + f.hooks = f.hooks[1:] + return hook +} + +func (f *GitserverService_ChangedFilesServerContextFunc) appendCall(r0 GitserverService_ChangedFilesServerContextFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of +// GitserverService_ChangedFilesServerContextFuncCall objects describing the +// invocations of this function. +func (f *GitserverService_ChangedFilesServerContextFunc) History() []GitserverService_ChangedFilesServerContextFuncCall { + f.mutex.Lock() + history := make([]GitserverService_ChangedFilesServerContextFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// GitserverService_ChangedFilesServerContextFuncCall is an object that +// describes an invocation of method Context on an instance of +// MockGitserverService_ChangedFilesServer. +type GitserverService_ChangedFilesServerContextFuncCall struct { + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 context.Context +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c GitserverService_ChangedFilesServerContextFuncCall) Args() []interface{} { + return []interface{}{} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c GitserverService_ChangedFilesServerContextFuncCall) Results() []interface{} { + return []interface{}{c.Result0} +} + +// GitserverService_ChangedFilesServerRecvMsgFunc describes the behavior +// when the RecvMsg method of the parent +// MockGitserverService_ChangedFilesServer instance is invoked. +type GitserverService_ChangedFilesServerRecvMsgFunc struct { + defaultHook func(interface{}) error + hooks []func(interface{}) error + history []GitserverService_ChangedFilesServerRecvMsgFuncCall + mutex sync.Mutex +} + +// RecvMsg delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockGitserverService_ChangedFilesServer) RecvMsg(v0 interface{}) error { + r0 := m.RecvMsgFunc.nextHook()(v0) + m.RecvMsgFunc.appendCall(GitserverService_ChangedFilesServerRecvMsgFuncCall{v0, r0}) + return r0 +} + +// SetDefaultHook sets function that is called when the RecvMsg method of +// the parent MockGitserverService_ChangedFilesServer instance is invoked +// and the hook queue is empty. +func (f *GitserverService_ChangedFilesServerRecvMsgFunc) SetDefaultHook(hook func(interface{}) error) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// RecvMsg method of the parent MockGitserverService_ChangedFilesServer +// instance invokes the hook at the front of the queue and discards it. +// After the queue is empty, the default hook function is invoked for any +// future action. +func (f *GitserverService_ChangedFilesServerRecvMsgFunc) PushHook(hook func(interface{}) error) { + f.mutex.Lock() + f.hooks = append(f.hooks, hook) + f.mutex.Unlock() +} + +// SetDefaultReturn calls SetDefaultHook with a function that returns the +// given values. +func (f *GitserverService_ChangedFilesServerRecvMsgFunc) SetDefaultReturn(r0 error) { + f.SetDefaultHook(func(interface{}) error { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *GitserverService_ChangedFilesServerRecvMsgFunc) PushReturn(r0 error) { + f.PushHook(func(interface{}) error { + return r0 + }) +} + +func (f *GitserverService_ChangedFilesServerRecvMsgFunc) nextHook() func(interface{}) error { + f.mutex.Lock() + defer f.mutex.Unlock() + + if len(f.hooks) == 0 { + return f.defaultHook + } + + hook := f.hooks[0] + f.hooks = f.hooks[1:] + return hook +} + +func (f *GitserverService_ChangedFilesServerRecvMsgFunc) appendCall(r0 GitserverService_ChangedFilesServerRecvMsgFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of +// GitserverService_ChangedFilesServerRecvMsgFuncCall objects describing the +// invocations of this function. +func (f *GitserverService_ChangedFilesServerRecvMsgFunc) History() []GitserverService_ChangedFilesServerRecvMsgFuncCall { + f.mutex.Lock() + history := make([]GitserverService_ChangedFilesServerRecvMsgFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// GitserverService_ChangedFilesServerRecvMsgFuncCall is an object that +// describes an invocation of method RecvMsg on an instance of +// MockGitserverService_ChangedFilesServer. +type GitserverService_ChangedFilesServerRecvMsgFuncCall struct { + // Arg0 is the value of the 1st argument passed to this method + // invocation. + Arg0 interface{} + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 error +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c GitserverService_ChangedFilesServerRecvMsgFuncCall) Args() []interface{} { + return []interface{}{c.Arg0} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c GitserverService_ChangedFilesServerRecvMsgFuncCall) Results() []interface{} { + return []interface{}{c.Result0} +} + +// GitserverService_ChangedFilesServerSendFunc describes the behavior when +// the Send method of the parent MockGitserverService_ChangedFilesServer +// instance is invoked. +type GitserverService_ChangedFilesServerSendFunc struct { + defaultHook func(*v1.ChangedFilesResponse) error + hooks []func(*v1.ChangedFilesResponse) error + history []GitserverService_ChangedFilesServerSendFuncCall + mutex sync.Mutex +} + +// Send delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockGitserverService_ChangedFilesServer) Send(v0 *v1.ChangedFilesResponse) error { + r0 := m.SendFunc.nextHook()(v0) + m.SendFunc.appendCall(GitserverService_ChangedFilesServerSendFuncCall{v0, r0}) + return r0 +} + +// SetDefaultHook sets function that is called when the Send method of the +// parent MockGitserverService_ChangedFilesServer instance is invoked and +// the hook queue is empty. +func (f *GitserverService_ChangedFilesServerSendFunc) SetDefaultHook(hook func(*v1.ChangedFilesResponse) error) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// Send method of the parent MockGitserverService_ChangedFilesServer +// instance invokes the hook at the front of the queue and discards it. +// After the queue is empty, the default hook function is invoked for any +// future action. +func (f *GitserverService_ChangedFilesServerSendFunc) PushHook(hook func(*v1.ChangedFilesResponse) error) { + f.mutex.Lock() + f.hooks = append(f.hooks, hook) + f.mutex.Unlock() +} + +// SetDefaultReturn calls SetDefaultHook with a function that returns the +// given values. +func (f *GitserverService_ChangedFilesServerSendFunc) SetDefaultReturn(r0 error) { + f.SetDefaultHook(func(*v1.ChangedFilesResponse) error { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *GitserverService_ChangedFilesServerSendFunc) PushReturn(r0 error) { + f.PushHook(func(*v1.ChangedFilesResponse) error { + return r0 + }) +} + +func (f *GitserverService_ChangedFilesServerSendFunc) nextHook() func(*v1.ChangedFilesResponse) error { + f.mutex.Lock() + defer f.mutex.Unlock() + + if len(f.hooks) == 0 { + return f.defaultHook + } + + hook := f.hooks[0] + f.hooks = f.hooks[1:] + return hook +} + +func (f *GitserverService_ChangedFilesServerSendFunc) appendCall(r0 GitserverService_ChangedFilesServerSendFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of +// GitserverService_ChangedFilesServerSendFuncCall objects describing the +// invocations of this function. +func (f *GitserverService_ChangedFilesServerSendFunc) History() []GitserverService_ChangedFilesServerSendFuncCall { + f.mutex.Lock() + history := make([]GitserverService_ChangedFilesServerSendFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// GitserverService_ChangedFilesServerSendFuncCall is an object that +// describes an invocation of method Send on an instance of +// MockGitserverService_ChangedFilesServer. +type GitserverService_ChangedFilesServerSendFuncCall struct { + // Arg0 is the value of the 1st argument passed to this method + // invocation. + Arg0 *v1.ChangedFilesResponse + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 error +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c GitserverService_ChangedFilesServerSendFuncCall) Args() []interface{} { + return []interface{}{c.Arg0} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c GitserverService_ChangedFilesServerSendFuncCall) Results() []interface{} { + return []interface{}{c.Result0} +} + +// GitserverService_ChangedFilesServerSendHeaderFunc describes the behavior +// when the SendHeader method of the parent +// MockGitserverService_ChangedFilesServer instance is invoked. +type GitserverService_ChangedFilesServerSendHeaderFunc struct { + defaultHook func(metadata.MD) error + hooks []func(metadata.MD) error + history []GitserverService_ChangedFilesServerSendHeaderFuncCall + mutex sync.Mutex +} + +// SendHeader delegates to the next hook function in the queue and stores +// the parameter and result values of this invocation. +func (m *MockGitserverService_ChangedFilesServer) SendHeader(v0 metadata.MD) error { + r0 := m.SendHeaderFunc.nextHook()(v0) + m.SendHeaderFunc.appendCall(GitserverService_ChangedFilesServerSendHeaderFuncCall{v0, r0}) + return r0 +} + +// SetDefaultHook sets function that is called when the SendHeader method of +// the parent MockGitserverService_ChangedFilesServer instance is invoked +// and the hook queue is empty. +func (f *GitserverService_ChangedFilesServerSendHeaderFunc) SetDefaultHook(hook func(metadata.MD) error) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// SendHeader method of the parent MockGitserverService_ChangedFilesServer +// instance invokes the hook at the front of the queue and discards it. +// After the queue is empty, the default hook function is invoked for any +// future action. +func (f *GitserverService_ChangedFilesServerSendHeaderFunc) PushHook(hook func(metadata.MD) error) { + f.mutex.Lock() + f.hooks = append(f.hooks, hook) + f.mutex.Unlock() +} + +// SetDefaultReturn calls SetDefaultHook with a function that returns the +// given values. +func (f *GitserverService_ChangedFilesServerSendHeaderFunc) SetDefaultReturn(r0 error) { + f.SetDefaultHook(func(metadata.MD) error { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *GitserverService_ChangedFilesServerSendHeaderFunc) PushReturn(r0 error) { + f.PushHook(func(metadata.MD) error { + return r0 + }) +} + +func (f *GitserverService_ChangedFilesServerSendHeaderFunc) nextHook() func(metadata.MD) error { + f.mutex.Lock() + defer f.mutex.Unlock() + + if len(f.hooks) == 0 { + return f.defaultHook + } + + hook := f.hooks[0] + f.hooks = f.hooks[1:] + return hook +} + +func (f *GitserverService_ChangedFilesServerSendHeaderFunc) appendCall(r0 GitserverService_ChangedFilesServerSendHeaderFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of +// GitserverService_ChangedFilesServerSendHeaderFuncCall objects describing +// the invocations of this function. +func (f *GitserverService_ChangedFilesServerSendHeaderFunc) History() []GitserverService_ChangedFilesServerSendHeaderFuncCall { + f.mutex.Lock() + history := make([]GitserverService_ChangedFilesServerSendHeaderFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// GitserverService_ChangedFilesServerSendHeaderFuncCall is an object that +// describes an invocation of method SendHeader on an instance of +// MockGitserverService_ChangedFilesServer. +type GitserverService_ChangedFilesServerSendHeaderFuncCall struct { + // Arg0 is the value of the 1st argument passed to this method + // invocation. + Arg0 metadata.MD + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 error +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c GitserverService_ChangedFilesServerSendHeaderFuncCall) Args() []interface{} { + return []interface{}{c.Arg0} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c GitserverService_ChangedFilesServerSendHeaderFuncCall) Results() []interface{} { + return []interface{}{c.Result0} +} + +// GitserverService_ChangedFilesServerSendMsgFunc describes the behavior +// when the SendMsg method of the parent +// MockGitserverService_ChangedFilesServer instance is invoked. +type GitserverService_ChangedFilesServerSendMsgFunc struct { + defaultHook func(interface{}) error + hooks []func(interface{}) error + history []GitserverService_ChangedFilesServerSendMsgFuncCall + mutex sync.Mutex +} + +// SendMsg delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockGitserverService_ChangedFilesServer) SendMsg(v0 interface{}) error { + r0 := m.SendMsgFunc.nextHook()(v0) + m.SendMsgFunc.appendCall(GitserverService_ChangedFilesServerSendMsgFuncCall{v0, r0}) + return r0 +} + +// SetDefaultHook sets function that is called when the SendMsg method of +// the parent MockGitserverService_ChangedFilesServer instance is invoked +// and the hook queue is empty. +func (f *GitserverService_ChangedFilesServerSendMsgFunc) SetDefaultHook(hook func(interface{}) error) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// SendMsg method of the parent MockGitserverService_ChangedFilesServer +// instance invokes the hook at the front of the queue and discards it. +// After the queue is empty, the default hook function is invoked for any +// future action. +func (f *GitserverService_ChangedFilesServerSendMsgFunc) PushHook(hook func(interface{}) error) { + f.mutex.Lock() + f.hooks = append(f.hooks, hook) + f.mutex.Unlock() +} + +// SetDefaultReturn calls SetDefaultHook with a function that returns the +// given values. +func (f *GitserverService_ChangedFilesServerSendMsgFunc) SetDefaultReturn(r0 error) { + f.SetDefaultHook(func(interface{}) error { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *GitserverService_ChangedFilesServerSendMsgFunc) PushReturn(r0 error) { + f.PushHook(func(interface{}) error { + return r0 + }) +} + +func (f *GitserverService_ChangedFilesServerSendMsgFunc) nextHook() func(interface{}) error { + f.mutex.Lock() + defer f.mutex.Unlock() + + if len(f.hooks) == 0 { + return f.defaultHook + } + + hook := f.hooks[0] + f.hooks = f.hooks[1:] + return hook +} + +func (f *GitserverService_ChangedFilesServerSendMsgFunc) appendCall(r0 GitserverService_ChangedFilesServerSendMsgFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of +// GitserverService_ChangedFilesServerSendMsgFuncCall objects describing the +// invocations of this function. +func (f *GitserverService_ChangedFilesServerSendMsgFunc) History() []GitserverService_ChangedFilesServerSendMsgFuncCall { + f.mutex.Lock() + history := make([]GitserverService_ChangedFilesServerSendMsgFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// GitserverService_ChangedFilesServerSendMsgFuncCall is an object that +// describes an invocation of method SendMsg on an instance of +// MockGitserverService_ChangedFilesServer. +type GitserverService_ChangedFilesServerSendMsgFuncCall struct { + // Arg0 is the value of the 1st argument passed to this method + // invocation. + Arg0 interface{} + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 error +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c GitserverService_ChangedFilesServerSendMsgFuncCall) Args() []interface{} { + return []interface{}{c.Arg0} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c GitserverService_ChangedFilesServerSendMsgFuncCall) Results() []interface{} { + return []interface{}{c.Result0} +} + +// GitserverService_ChangedFilesServerSetHeaderFunc describes the behavior +// when the SetHeader method of the parent +// MockGitserverService_ChangedFilesServer instance is invoked. +type GitserverService_ChangedFilesServerSetHeaderFunc struct { + defaultHook func(metadata.MD) error + hooks []func(metadata.MD) error + history []GitserverService_ChangedFilesServerSetHeaderFuncCall + mutex sync.Mutex +} + +// SetHeader delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockGitserverService_ChangedFilesServer) SetHeader(v0 metadata.MD) error { + r0 := m.SetHeaderFunc.nextHook()(v0) + m.SetHeaderFunc.appendCall(GitserverService_ChangedFilesServerSetHeaderFuncCall{v0, r0}) + return r0 +} + +// SetDefaultHook sets function that is called when the SetHeader method of +// the parent MockGitserverService_ChangedFilesServer instance is invoked +// and the hook queue is empty. +func (f *GitserverService_ChangedFilesServerSetHeaderFunc) SetDefaultHook(hook func(metadata.MD) error) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// SetHeader method of the parent MockGitserverService_ChangedFilesServer +// instance invokes the hook at the front of the queue and discards it. +// After the queue is empty, the default hook function is invoked for any +// future action. +func (f *GitserverService_ChangedFilesServerSetHeaderFunc) PushHook(hook func(metadata.MD) error) { + f.mutex.Lock() + f.hooks = append(f.hooks, hook) + f.mutex.Unlock() +} + +// SetDefaultReturn calls SetDefaultHook with a function that returns the +// given values. +func (f *GitserverService_ChangedFilesServerSetHeaderFunc) SetDefaultReturn(r0 error) { + f.SetDefaultHook(func(metadata.MD) error { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *GitserverService_ChangedFilesServerSetHeaderFunc) PushReturn(r0 error) { + f.PushHook(func(metadata.MD) error { + return r0 + }) +} + +func (f *GitserverService_ChangedFilesServerSetHeaderFunc) nextHook() func(metadata.MD) error { + f.mutex.Lock() + defer f.mutex.Unlock() + + if len(f.hooks) == 0 { + return f.defaultHook + } + + hook := f.hooks[0] + f.hooks = f.hooks[1:] + return hook +} + +func (f *GitserverService_ChangedFilesServerSetHeaderFunc) appendCall(r0 GitserverService_ChangedFilesServerSetHeaderFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of +// GitserverService_ChangedFilesServerSetHeaderFuncCall objects describing +// the invocations of this function. +func (f *GitserverService_ChangedFilesServerSetHeaderFunc) History() []GitserverService_ChangedFilesServerSetHeaderFuncCall { + f.mutex.Lock() + history := make([]GitserverService_ChangedFilesServerSetHeaderFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// GitserverService_ChangedFilesServerSetHeaderFuncCall is an object that +// describes an invocation of method SetHeader on an instance of +// MockGitserverService_ChangedFilesServer. +type GitserverService_ChangedFilesServerSetHeaderFuncCall struct { + // Arg0 is the value of the 1st argument passed to this method + // invocation. + Arg0 metadata.MD + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 error +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c GitserverService_ChangedFilesServerSetHeaderFuncCall) Args() []interface{} { + return []interface{}{c.Arg0} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c GitserverService_ChangedFilesServerSetHeaderFuncCall) Results() []interface{} { + return []interface{}{c.Result0} +} + +// GitserverService_ChangedFilesServerSetTrailerFunc describes the behavior +// when the SetTrailer method of the parent +// MockGitserverService_ChangedFilesServer instance is invoked. +type GitserverService_ChangedFilesServerSetTrailerFunc struct { + defaultHook func(metadata.MD) + hooks []func(metadata.MD) + history []GitserverService_ChangedFilesServerSetTrailerFuncCall + mutex sync.Mutex +} + +// SetTrailer delegates to the next hook function in the queue and stores +// the parameter and result values of this invocation. +func (m *MockGitserverService_ChangedFilesServer) SetTrailer(v0 metadata.MD) { + m.SetTrailerFunc.nextHook()(v0) + m.SetTrailerFunc.appendCall(GitserverService_ChangedFilesServerSetTrailerFuncCall{v0}) + return +} + +// SetDefaultHook sets function that is called when the SetTrailer method of +// the parent MockGitserverService_ChangedFilesServer instance is invoked +// and the hook queue is empty. +func (f *GitserverService_ChangedFilesServerSetTrailerFunc) SetDefaultHook(hook func(metadata.MD)) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// SetTrailer method of the parent MockGitserverService_ChangedFilesServer +// instance invokes the hook at the front of the queue and discards it. +// After the queue is empty, the default hook function is invoked for any +// future action. +func (f *GitserverService_ChangedFilesServerSetTrailerFunc) PushHook(hook func(metadata.MD)) { + f.mutex.Lock() + f.hooks = append(f.hooks, hook) + f.mutex.Unlock() +} + +// SetDefaultReturn calls SetDefaultHook with a function that returns the +// given values. +func (f *GitserverService_ChangedFilesServerSetTrailerFunc) SetDefaultReturn() { + f.SetDefaultHook(func(metadata.MD) { + return + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *GitserverService_ChangedFilesServerSetTrailerFunc) PushReturn() { + f.PushHook(func(metadata.MD) { + return + }) +} + +func (f *GitserverService_ChangedFilesServerSetTrailerFunc) nextHook() func(metadata.MD) { + f.mutex.Lock() + defer f.mutex.Unlock() + + if len(f.hooks) == 0 { + return f.defaultHook + } + + hook := f.hooks[0] + f.hooks = f.hooks[1:] + return hook +} + +func (f *GitserverService_ChangedFilesServerSetTrailerFunc) appendCall(r0 GitserverService_ChangedFilesServerSetTrailerFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of +// GitserverService_ChangedFilesServerSetTrailerFuncCall objects describing +// the invocations of this function. +func (f *GitserverService_ChangedFilesServerSetTrailerFunc) History() []GitserverService_ChangedFilesServerSetTrailerFuncCall { + f.mutex.Lock() + history := make([]GitserverService_ChangedFilesServerSetTrailerFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// GitserverService_ChangedFilesServerSetTrailerFuncCall is an object that +// describes an invocation of method SetTrailer on an instance of +// MockGitserverService_ChangedFilesServer. +type GitserverService_ChangedFilesServerSetTrailerFuncCall struct { + // Arg0 is the value of the 1st argument passed to this method + // invocation. + Arg0 metadata.MD +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c GitserverService_ChangedFilesServerSetTrailerFuncCall) Args() []interface{} { + return []interface{}{c.Arg0} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c GitserverService_ChangedFilesServerSetTrailerFuncCall) Results() []interface{} { + return []interface{}{} +} + // MockGitserverService_ExecServer is a mock implementation of the // GitserverService_ExecServer interface (from the package // github.com/sourcegraph/sourcegraph/internal/gitserver/v1) used for unit diff --git a/internal/gitserver/retry.go b/internal/gitserver/retry.go index 73afe671b8f..8ae51be86fa 100644 --- a/internal/gitserver/retry.go +++ b/internal/gitserver/retry.go @@ -175,4 +175,9 @@ func (r *automaticRetryClient) BehindAhead(ctx context.Context, in *proto.Behind return r.base.BehindAhead(ctx, in, opts...) } +func (r *automaticRetryClient) ChangedFiles(ctx context.Context, in *proto.ChangedFilesRequest, opts ...grpc.CallOption) (proto.GitserverService_ChangedFilesClient, error) { + opts = append(defaults.RetryPolicy, opts...) + return r.base.ChangedFiles(ctx, in, opts...) +} + var _ proto.GitserverServiceClient = &automaticRetryClient{} diff --git a/internal/gitserver/v1/gitserver.pb.go b/internal/gitserver/v1/gitserver.pb.go index c05b6d06719..332a7dd277c 100644 --- a/internal/gitserver/v1/gitserver.pb.go +++ b/internal/gitserver/v1/gitserver.pb.go @@ -337,6 +337,59 @@ func (PerforceChangelist_PerforceChangelistState) EnumDescriptor() ([]byte, []in return file_gitserver_proto_rawDescGZIP(), []int{76, 0} } +// status is the status of the path. +type ChangedFile_Status int32 + +const ( + ChangedFile_STATUS_UNSPECIFIED ChangedFile_Status = 0 + ChangedFile_STATUS_ADDED ChangedFile_Status = 1 + ChangedFile_STATUS_MODIFIED ChangedFile_Status = 2 + ChangedFile_STATUS_DELETED ChangedFile_Status = 3 +) + +// Enum value maps for ChangedFile_Status. +var ( + ChangedFile_Status_name = map[int32]string{ + 0: "STATUS_UNSPECIFIED", + 1: "STATUS_ADDED", + 2: "STATUS_MODIFIED", + 3: "STATUS_DELETED", + } + ChangedFile_Status_value = map[string]int32{ + "STATUS_UNSPECIFIED": 0, + "STATUS_ADDED": 1, + "STATUS_MODIFIED": 2, + "STATUS_DELETED": 3, + } +) + +func (x ChangedFile_Status) Enum() *ChangedFile_Status { + p := new(ChangedFile_Status) + *p = x + return p +} + +func (x ChangedFile_Status) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ChangedFile_Status) Descriptor() protoreflect.EnumDescriptor { + return file_gitserver_proto_enumTypes[6].Descriptor() +} + +func (ChangedFile_Status) Type() protoreflect.EnumType { + return &file_gitserver_proto_enumTypes[6] +} + +func (x ChangedFile_Status) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use ChangedFile_Status.Descriptor instead. +func (ChangedFile_Status) EnumDescriptor() ([]byte, []int) { + return file_gitserver_proto_rawDescGZIP(), []int{97, 0} +} + type DeleteRepositoryRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -6212,6 +6265,178 @@ func (x *BehindAheadResponse) GetAhead() uint32 { return 0 } +type ChangedFilesRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // repo_name is the name of the repo to get the changed files for. + // Note: We use field ID 2 here to reserve 1 for a future repo int32 field. + RepoName string `protobuf:"bytes,2,opt,name=repo_name,json=repoName,proto3" json:"repo_name,omitempty"` + // base is a id, for now, we allow non-utf8 revspecs. + // + // If base is empty, the parent of the head is used. + Base []byte `protobuf:"bytes,3,opt,name=base,proto3,oneof" json:"base,omitempty"` + // head is a id, for now, we allow non-utf8 revspecs. + Head []byte `protobuf:"bytes,4,opt,name=head,proto3" json:"head,omitempty"` +} + +func (x *ChangedFilesRequest) Reset() { + *x = ChangedFilesRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_gitserver_proto_msgTypes[95] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ChangedFilesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ChangedFilesRequest) ProtoMessage() {} + +func (x *ChangedFilesRequest) ProtoReflect() protoreflect.Message { + mi := &file_gitserver_proto_msgTypes[95] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ChangedFilesRequest.ProtoReflect.Descriptor instead. +func (*ChangedFilesRequest) Descriptor() ([]byte, []int) { + return file_gitserver_proto_rawDescGZIP(), []int{95} +} + +func (x *ChangedFilesRequest) GetRepoName() string { + if x != nil { + return x.RepoName + } + return "" +} + +func (x *ChangedFilesRequest) GetBase() []byte { + if x != nil { + return x.Base + } + return nil +} + +func (x *ChangedFilesRequest) GetHead() []byte { + if x != nil { + return x.Head + } + return nil +} + +type ChangedFilesResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Files []*ChangedFile `protobuf:"bytes,1,rep,name=files,proto3" json:"files,omitempty"` +} + +func (x *ChangedFilesResponse) Reset() { + *x = ChangedFilesResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_gitserver_proto_msgTypes[96] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ChangedFilesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ChangedFilesResponse) ProtoMessage() {} + +func (x *ChangedFilesResponse) ProtoReflect() protoreflect.Message { + mi := &file_gitserver_proto_msgTypes[96] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ChangedFilesResponse.ProtoReflect.Descriptor instead. +func (*ChangedFilesResponse) Descriptor() ([]byte, []int) { + return file_gitserver_proto_rawDescGZIP(), []int{96} +} + +func (x *ChangedFilesResponse) GetFiles() []*ChangedFile { + if x != nil { + return x.Files + } + return nil +} + +type ChangedFile struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // path is the file path of the file that the status is for. + Path []byte `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` + Status ChangedFile_Status `protobuf:"varint,2,opt,name=status,proto3,enum=gitserver.v1.ChangedFile_Status" json:"status,omitempty"` +} + +func (x *ChangedFile) Reset() { + *x = ChangedFile{} + if protoimpl.UnsafeEnabled { + mi := &file_gitserver_proto_msgTypes[97] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ChangedFile) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ChangedFile) ProtoMessage() {} + +func (x *ChangedFile) ProtoReflect() protoreflect.Message { + mi := &file_gitserver_proto_msgTypes[97] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ChangedFile.ProtoReflect.Descriptor instead. +func (*ChangedFile) Descriptor() ([]byte, []int) { + return file_gitserver_proto_rawDescGZIP(), []int{97} +} + +func (x *ChangedFile) GetPath() []byte { + if x != nil { + return x.Path + } + return nil +} + +func (x *ChangedFile) GetStatus() ChangedFile_Status { + if x != nil { + return x.Status + } + return ChangedFile_STATUS_UNSPECIFIED +} + type CreateCommitFromPatchBinaryRequest_Metadata struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -6240,7 +6465,7 @@ type CreateCommitFromPatchBinaryRequest_Metadata struct { func (x *CreateCommitFromPatchBinaryRequest_Metadata) Reset() { *x = CreateCommitFromPatchBinaryRequest_Metadata{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[95] + mi := &file_gitserver_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6253,7 +6478,7 @@ func (x *CreateCommitFromPatchBinaryRequest_Metadata) String() string { func (*CreateCommitFromPatchBinaryRequest_Metadata) ProtoMessage() {} func (x *CreateCommitFromPatchBinaryRequest_Metadata) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[95] + mi := &file_gitserver_proto_msgTypes[98] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6337,7 +6562,7 @@ type CreateCommitFromPatchBinaryRequest_Patch struct { func (x *CreateCommitFromPatchBinaryRequest_Patch) Reset() { *x = CreateCommitFromPatchBinaryRequest_Patch{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[96] + mi := &file_gitserver_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6350,7 +6575,7 @@ func (x *CreateCommitFromPatchBinaryRequest_Patch) String() string { func (*CreateCommitFromPatchBinaryRequest_Patch) ProtoMessage() {} func (x *CreateCommitFromPatchBinaryRequest_Patch) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[96] + mi := &file_gitserver_proto_msgTypes[99] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6386,7 +6611,7 @@ type CommitMatch_Signature struct { func (x *CommitMatch_Signature) Reset() { *x = CommitMatch_Signature{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[97] + mi := &file_gitserver_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6399,7 +6624,7 @@ func (x *CommitMatch_Signature) String() string { func (*CommitMatch_Signature) ProtoMessage() {} func (x *CommitMatch_Signature) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[97] + mi := &file_gitserver_proto_msgTypes[100] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6448,7 +6673,7 @@ type CommitMatch_MatchedString struct { func (x *CommitMatch_MatchedString) Reset() { *x = CommitMatch_MatchedString{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[98] + mi := &file_gitserver_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6461,7 +6686,7 @@ func (x *CommitMatch_MatchedString) String() string { func (*CommitMatch_MatchedString) ProtoMessage() {} func (x *CommitMatch_MatchedString) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[98] + mi := &file_gitserver_proto_msgTypes[101] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6504,7 +6729,7 @@ type CommitMatch_Range struct { func (x *CommitMatch_Range) Reset() { *x = CommitMatch_Range{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[99] + mi := &file_gitserver_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6517,7 +6742,7 @@ func (x *CommitMatch_Range) String() string { func (*CommitMatch_Range) ProtoMessage() {} func (x *CommitMatch_Range) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[99] + mi := &file_gitserver_proto_msgTypes[102] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6560,7 +6785,7 @@ type CommitMatch_Location struct { func (x *CommitMatch_Location) Reset() { *x = CommitMatch_Location{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[100] + mi := &file_gitserver_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6573,7 +6798,7 @@ func (x *CommitMatch_Location) String() string { func (*CommitMatch_Location) ProtoMessage() {} func (x *CommitMatch_Location) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[100] + mi := &file_gitserver_proto_msgTypes[103] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7381,217 +7606,246 @@ var file_gitserver_proto_rawDesc = []byte{ 0x6e, 0x64, 0x41, 0x68, 0x65, 0x61, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x62, 0x65, 0x68, 0x69, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x62, 0x65, 0x68, 0x69, 0x6e, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x61, 0x68, 0x65, 0x61, 0x64, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x61, 0x68, 0x65, 0x61, 0x64, 0x2a, 0x71, 0x0a, - 0x0c, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x1d, 0x0a, - 0x19, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x55, - 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x15, 0x0a, 0x11, - 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x41, 0x4e, - 0x44, 0x10, 0x01, 0x12, 0x14, 0x0a, 0x10, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, - 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x4f, 0x52, 0x10, 0x02, 0x12, 0x15, 0x0a, 0x11, 0x4f, 0x50, 0x45, - 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x4e, 0x4f, 0x54, 0x10, 0x03, - 0x2a, 0x5f, 0x0a, 0x0d, 0x41, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, - 0x74, 0x12, 0x1e, 0x0a, 0x1a, 0x41, 0x52, 0x43, 0x48, 0x49, 0x56, 0x45, 0x5f, 0x46, 0x4f, 0x52, - 0x4d, 0x41, 0x54, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, - 0x00, 0x12, 0x16, 0x0a, 0x12, 0x41, 0x52, 0x43, 0x48, 0x49, 0x56, 0x45, 0x5f, 0x46, 0x4f, 0x52, - 0x4d, 0x41, 0x54, 0x5f, 0x5a, 0x49, 0x50, 0x10, 0x01, 0x12, 0x16, 0x0a, 0x12, 0x41, 0x52, 0x43, - 0x48, 0x49, 0x56, 0x45, 0x5f, 0x46, 0x4f, 0x52, 0x4d, 0x41, 0x54, 0x5f, 0x54, 0x41, 0x52, 0x10, - 0x02, 0x32, 0xe6, 0x01, 0x0a, 0x1a, 0x47, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, - 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, - 0x12, 0x63, 0x0a, 0x10, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x6f, 0x72, 0x79, 0x12, 0x25, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x67, 0x69, - 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, - 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x63, 0x0a, 0x0f, 0x46, 0x65, 0x74, 0x63, 0x68, 0x52, 0x65, - 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x24, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, - 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x65, 0x74, 0x63, 0x68, 0x52, 0x65, 0x70, - 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, - 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x65, - 0x74, 0x63, 0x68, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x02, 0x32, 0x9f, 0x16, 0x0a, 0x10, 0x47, - 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, - 0x86, 0x01, 0x0a, 0x1b, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, - 0x46, 0x72, 0x6f, 0x6d, 0x50, 0x61, 0x74, 0x63, 0x68, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x12, - 0x30, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x61, 0x68, 0x65, 0x61, 0x64, 0x22, 0x68, 0x0a, + 0x13, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x46, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x65, 0x70, 0x6f, 0x5f, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x72, 0x65, 0x70, 0x6f, 0x4e, 0x61, 0x6d, + 0x65, 0x12, 0x17, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x48, + 0x00, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x88, 0x01, 0x01, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x65, + 0x61, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x68, 0x65, 0x61, 0x64, 0x42, 0x07, + 0x0a, 0x05, 0x5f, 0x62, 0x61, 0x73, 0x65, 0x22, 0x47, 0x0a, 0x14, 0x43, 0x68, 0x61, 0x6e, 0x67, + 0x65, 0x64, 0x46, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x2f, 0x0a, 0x05, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x19, + 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x64, 0x46, 0x69, 0x6c, 0x65, 0x52, 0x05, 0x66, 0x69, 0x6c, 0x65, 0x73, + 0x22, 0xb8, 0x01, 0x0a, 0x0b, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x46, 0x69, 0x6c, 0x65, + 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, + 0x70, 0x61, 0x74, 0x68, 0x12, 0x38, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x20, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x46, 0x69, 0x6c, 0x65, 0x2e, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x5b, + 0x0a, 0x06, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x54, 0x41, 0x54, + 0x55, 0x53, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, + 0x12, 0x10, 0x0a, 0x0c, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x41, 0x44, 0x44, 0x45, 0x44, + 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x4d, 0x4f, 0x44, + 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x53, 0x54, 0x41, 0x54, 0x55, + 0x53, 0x5f, 0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x44, 0x10, 0x03, 0x2a, 0x71, 0x0a, 0x0c, 0x4f, + 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x12, 0x1d, 0x0a, 0x19, 0x4f, + 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x55, 0x4e, 0x53, + 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x15, 0x0a, 0x11, 0x4f, 0x50, + 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x41, 0x4e, 0x44, 0x10, + 0x01, 0x12, 0x14, 0x0a, 0x10, 0x4f, 0x50, 0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x5f, 0x4b, 0x49, + 0x4e, 0x44, 0x5f, 0x4f, 0x52, 0x10, 0x02, 0x12, 0x15, 0x0a, 0x11, 0x4f, 0x50, 0x45, 0x52, 0x41, + 0x54, 0x4f, 0x52, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x4e, 0x4f, 0x54, 0x10, 0x03, 0x2a, 0x5f, + 0x0a, 0x0d, 0x41, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, + 0x1e, 0x0a, 0x1a, 0x41, 0x52, 0x43, 0x48, 0x49, 0x56, 0x45, 0x5f, 0x46, 0x4f, 0x52, 0x4d, 0x41, + 0x54, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, + 0x16, 0x0a, 0x12, 0x41, 0x52, 0x43, 0x48, 0x49, 0x56, 0x45, 0x5f, 0x46, 0x4f, 0x52, 0x4d, 0x41, + 0x54, 0x5f, 0x5a, 0x49, 0x50, 0x10, 0x01, 0x12, 0x16, 0x0a, 0x12, 0x41, 0x52, 0x43, 0x48, 0x49, + 0x56, 0x45, 0x5f, 0x46, 0x4f, 0x52, 0x4d, 0x41, 0x54, 0x5f, 0x54, 0x41, 0x52, 0x10, 0x02, 0x32, + 0xe6, 0x01, 0x0a, 0x1a, 0x47, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x52, 0x65, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x63, + 0x0a, 0x10, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, + 0x72, 0x79, 0x12, 0x25, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, + 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x67, 0x69, 0x74, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, + 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x00, 0x12, 0x63, 0x0a, 0x0f, 0x46, 0x65, 0x74, 0x63, 0x68, 0x52, 0x65, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x24, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x65, 0x74, 0x63, 0x68, 0x52, 0x65, 0x70, 0x6f, 0x73, + 0x69, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x67, + 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x65, 0x74, 0x63, + 0x68, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x02, 0x32, 0xfd, 0x16, 0x0a, 0x10, 0x47, 0x69, 0x74, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x86, 0x01, + 0x0a, 0x1b, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x46, 0x72, + 0x6f, 0x6d, 0x50, 0x61, 0x74, 0x63, 0x68, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x12, 0x30, 0x2e, + 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x46, 0x72, 0x6f, 0x6d, 0x50, 0x61, 0x74, + 0x63, 0x68, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x31, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x46, 0x72, 0x6f, 0x6d, 0x50, - 0x61, 0x74, 0x63, 0x68, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x31, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x46, 0x72, 0x6f, - 0x6d, 0x50, 0x61, 0x74, 0x63, 0x68, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x28, 0x01, 0x12, 0x4e, 0x0a, 0x08, 0x44, 0x69, 0x73, 0x6b, - 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1d, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x69, 0x73, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x44, 0x69, 0x73, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x41, 0x0a, 0x04, 0x45, 0x78, 0x65, 0x63, - 0x12, 0x19, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x45, 0x78, 0x65, 0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x67, 0x69, - 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x51, 0x0a, 0x09, 0x47, - 0x65, 0x74, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1e, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, - 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x62, 0x6a, 0x65, 0x63, - 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, - 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x62, 0x6a, 0x65, 0x63, - 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x63, - 0x0a, 0x0f, 0x49, 0x73, 0x52, 0x65, 0x70, 0x6f, 0x43, 0x6c, 0x6f, 0x6e, 0x65, 0x61, 0x62, 0x6c, - 0x65, 0x12, 0x24, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x49, 0x73, 0x52, 0x65, 0x70, 0x6f, 0x43, 0x6c, 0x6f, 0x6e, 0x65, 0x61, 0x62, 0x6c, 0x65, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, - 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x73, 0x52, 0x65, 0x70, 0x6f, 0x43, 0x6c, 0x6f, - 0x6e, 0x65, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, - 0x90, 0x02, 0x01, 0x12, 0x5a, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x47, 0x69, 0x74, 0x6f, 0x6c, - 0x69, 0x74, 0x65, 0x12, 0x21, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x47, 0x69, 0x74, 0x6f, 0x6c, 0x69, 0x74, 0x65, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x47, 0x69, 0x74, 0x6f, 0x6c, 0x69, - 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, - 0x4a, 0x0a, 0x06, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x12, 0x1b, 0x2e, 0x67, 0x69, 0x74, 0x73, - 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x30, 0x01, 0x12, 0x4d, 0x0a, 0x07, 0x41, - 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x12, 0x1c, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x30, 0x01, 0x12, 0x69, 0x0a, 0x11, 0x52, 0x65, - 0x70, 0x6f, 0x43, 0x6c, 0x6f, 0x6e, 0x65, 0x50, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x12, - 0x26, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, - 0x65, 0x70, 0x6f, 0x43, 0x6c, 0x6f, 0x6e, 0x65, 0x50, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, - 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x70, 0x6f, 0x43, 0x6c, 0x6f, 0x6e, 0x65, - 0x50, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x7b, 0x0a, 0x17, 0x49, 0x73, 0x50, 0x65, 0x72, 0x66, 0x6f, - 0x72, 0x63, 0x65, 0x50, 0x61, 0x74, 0x68, 0x43, 0x6c, 0x6f, 0x6e, 0x65, 0x61, 0x62, 0x6c, 0x65, - 0x12, 0x2c, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x49, 0x73, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x50, 0x61, 0x74, 0x68, 0x43, 0x6c, - 0x6f, 0x6e, 0x65, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, + 0x61, 0x74, 0x63, 0x68, 0x42, 0x69, 0x6e, 0x61, 0x72, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x00, 0x28, 0x01, 0x12, 0x4e, 0x0a, 0x08, 0x44, 0x69, 0x73, 0x6b, 0x49, 0x6e, + 0x66, 0x6f, 0x12, 0x1d, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x44, 0x69, 0x73, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x1e, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x44, 0x69, 0x73, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x41, 0x0a, 0x04, 0x45, 0x78, 0x65, 0x63, 0x12, 0x19, + 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, + 0x65, 0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x67, 0x69, 0x74, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x45, 0x78, 0x65, 0x63, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x51, 0x0a, 0x09, 0x47, 0x65, 0x74, + 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x1e, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x63, 0x0a, 0x0f, + 0x49, 0x73, 0x52, 0x65, 0x70, 0x6f, 0x43, 0x6c, 0x6f, 0x6e, 0x65, 0x61, 0x62, 0x6c, 0x65, 0x12, + 0x24, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x49, + 0x73, 0x52, 0x65, 0x70, 0x6f, 0x43, 0x6c, 0x6f, 0x6e, 0x65, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x73, 0x52, 0x65, 0x70, 0x6f, 0x43, 0x6c, 0x6f, 0x6e, 0x65, + 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, + 0x01, 0x12, 0x5a, 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x47, 0x69, 0x74, 0x6f, 0x6c, 0x69, 0x74, + 0x65, 0x12, 0x21, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x47, 0x69, 0x74, 0x6f, 0x6c, 0x69, 0x74, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x47, 0x69, 0x74, 0x6f, 0x6c, 0x69, 0x74, 0x65, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x4a, 0x0a, + 0x06, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x12, 0x1b, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x30, 0x01, 0x12, 0x4d, 0x0a, 0x07, 0x41, 0x72, 0x63, + 0x68, 0x69, 0x76, 0x65, 0x12, 0x1c, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x41, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x30, 0x01, 0x12, 0x69, 0x0a, 0x11, 0x52, 0x65, 0x70, 0x6f, + 0x43, 0x6c, 0x6f, 0x6e, 0x65, 0x50, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x12, 0x26, 0x2e, + 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x70, + 0x6f, 0x43, 0x6c, 0x6f, 0x6e, 0x65, 0x50, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x70, 0x6f, 0x43, 0x6c, 0x6f, 0x6e, 0x65, 0x50, 0x72, + 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, + 0x90, 0x02, 0x01, 0x12, 0x7b, 0x0a, 0x17, 0x49, 0x73, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, + 0x65, 0x50, 0x61, 0x74, 0x68, 0x43, 0x6c, 0x6f, 0x6e, 0x65, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x2c, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x73, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x50, 0x61, 0x74, 0x68, 0x43, 0x6c, 0x6f, 0x6e, - 0x65, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, - 0x02, 0x01, 0x12, 0x7e, 0x0a, 0x18, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x50, 0x65, 0x72, 0x66, 0x6f, - 0x72, 0x63, 0x65, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x12, 0x2d, - 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, - 0x65, 0x63, 0x6b, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x72, 0x65, 0x64, 0x65, - 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, - 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, 0x65, - 0x63, 0x6b, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, - 0x74, 0x69, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, - 0x02, 0x01, 0x12, 0x5d, 0x0a, 0x0d, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x55, 0x73, - 0x65, 0x72, 0x73, 0x12, 0x22, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x55, 0x73, 0x65, 0x72, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, - 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x55, - 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, - 0x01, 0x12, 0x7b, 0x0a, 0x17, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x50, 0x72, 0x6f, - 0x74, 0x65, 0x63, 0x74, 0x73, 0x46, 0x6f, 0x72, 0x55, 0x73, 0x65, 0x72, 0x12, 0x2c, 0x2e, 0x67, - 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, - 0x6f, 0x72, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x73, 0x46, 0x6f, 0x72, 0x55, - 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x67, 0x69, 0x74, + 0x65, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x67, + 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x73, 0x50, 0x65, + 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x50, 0x61, 0x74, 0x68, 0x43, 0x6c, 0x6f, 0x6e, 0x65, 0x61, + 0x62, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, + 0x12, 0x7e, 0x0a, 0x18, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, + 0x65, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73, 0x12, 0x2d, 0x2e, 0x67, + 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, + 0x6b, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, + 0x69, 0x61, 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x67, 0x69, + 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, + 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, + 0x61, 0x6c, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, + 0x12, 0x5d, 0x0a, 0x0d, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x55, 0x73, 0x65, 0x72, + 0x73, 0x12, 0x22, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x55, 0x73, 0x65, + 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, + 0x7b, 0x0a, 0x17, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x65, + 0x63, 0x74, 0x73, 0x46, 0x6f, 0x72, 0x55, 0x73, 0x65, 0x72, 0x12, 0x2c, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x73, 0x46, 0x6f, 0x72, 0x55, 0x73, 0x65, - 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x7e, - 0x0a, 0x18, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, - 0x74, 0x73, 0x46, 0x6f, 0x72, 0x44, 0x65, 0x70, 0x6f, 0x74, 0x12, 0x2d, 0x2e, 0x67, 0x69, 0x74, - 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, - 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x73, 0x46, 0x6f, 0x72, 0x44, 0x65, 0x70, - 0x6f, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x67, 0x69, 0x74, 0x73, - 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, - 0x65, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x73, 0x46, 0x6f, 0x72, 0x44, 0x65, 0x70, 0x6f, - 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x72, - 0x0a, 0x14, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, - 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x12, 0x29, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x47, 0x72, - 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x2a, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, - 0x6d, 0x62, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, - 0x02, 0x01, 0x12, 0x6f, 0x0a, 0x13, 0x49, 0x73, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, - 0x53, 0x75, 0x70, 0x65, 0x72, 0x55, 0x73, 0x65, 0x72, 0x12, 0x28, 0x2e, 0x67, 0x69, 0x74, 0x73, - 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x73, 0x50, 0x65, 0x72, 0x66, 0x6f, - 0x72, 0x63, 0x65, 0x53, 0x75, 0x70, 0x65, 0x72, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x49, 0x73, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x53, 0x75, 0x70, - 0x65, 0x72, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, - 0x90, 0x02, 0x01, 0x12, 0x75, 0x0a, 0x15, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x47, - 0x65, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x12, 0x2a, 0x2e, 0x67, - 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, - 0x6f, 0x72, 0x63, 0x65, 0x47, 0x65, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, - 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, + 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, - 0x47, 0x65, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x51, 0x0a, 0x09, 0x4d, 0x65, - 0x72, 0x67, 0x65, 0x42, 0x61, 0x73, 0x65, 0x12, 0x1e, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, - 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x72, 0x67, 0x65, 0x42, 0x61, 0x73, 0x65, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, - 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x72, 0x67, 0x65, 0x42, 0x61, 0x73, 0x65, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x47, 0x0a, - 0x05, 0x42, 0x6c, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x42, 0x6c, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x03, 0x90, 0x02, 0x01, 0x30, 0x01, 0x12, 0x5d, 0x0a, 0x0d, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, - 0x74, 0x42, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x12, 0x22, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, - 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x42, 0x72, - 0x61, 0x6e, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x67, 0x69, - 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x66, 0x61, 0x75, - 0x6c, 0x74, 0x42, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x50, 0x0a, 0x08, 0x52, 0x65, 0x61, 0x64, 0x46, 0x69, 0x6c, - 0x65, 0x12, 0x1d, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x52, 0x65, 0x61, 0x64, 0x46, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1e, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x52, 0x65, 0x61, 0x64, 0x46, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x03, 0x90, 0x02, 0x01, 0x30, 0x01, 0x12, 0x51, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x43, 0x6f, - 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x1e, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x63, 0x0a, 0x0f, 0x52, 0x65, - 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x24, 0x2e, - 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, - 0x6f, 0x6c, 0x76, 0x65, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, - 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x02, 0x12, - 0x50, 0x0a, 0x08, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x66, 0x73, 0x12, 0x1d, 0x2e, 0x67, 0x69, - 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, - 0x65, 0x66, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x67, 0x69, 0x74, - 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, - 0x66, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x30, - 0x01, 0x12, 0x51, 0x0a, 0x09, 0x52, 0x65, 0x76, 0x41, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x1e, + 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x73, 0x46, 0x6f, 0x72, 0x55, 0x73, 0x65, 0x72, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x7e, 0x0a, 0x18, + 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x73, + 0x46, 0x6f, 0x72, 0x44, 0x65, 0x70, 0x6f, 0x74, 0x12, 0x2d, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, + 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, + 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x73, 0x46, 0x6f, 0x72, 0x44, 0x65, 0x70, 0x6f, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x50, + 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x73, 0x46, 0x6f, 0x72, 0x44, 0x65, 0x70, 0x6f, 0x74, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x72, 0x0a, 0x14, + 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, + 0x62, 0x65, 0x72, 0x73, 0x12, 0x29, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x4d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x2a, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, + 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4d, 0x65, 0x6d, 0x62, + 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, + 0x12, 0x6f, 0x0a, 0x13, 0x49, 0x73, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x53, 0x75, + 0x70, 0x65, 0x72, 0x55, 0x73, 0x65, 0x72, 0x12, 0x28, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x73, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, + 0x65, 0x53, 0x75, 0x70, 0x65, 0x72, 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x29, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x49, 0x73, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x53, 0x75, 0x70, 0x65, 0x72, + 0x55, 0x73, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, + 0x01, 0x12, 0x75, 0x0a, 0x15, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x47, 0x65, 0x74, + 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x12, 0x2a, 0x2e, 0x67, 0x69, 0x74, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, + 0x63, 0x65, 0x47, 0x65, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x47, 0x65, + 0x74, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x51, 0x0a, 0x09, 0x4d, 0x65, 0x72, 0x67, + 0x65, 0x42, 0x61, 0x73, 0x65, 0x12, 0x1e, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x72, 0x67, 0x65, 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x72, 0x67, 0x65, 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x47, 0x0a, 0x05, 0x42, + 0x6c, 0x61, 0x6d, 0x65, 0x12, 0x1a, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1b, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x42, 0x6c, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, + 0x02, 0x01, 0x30, 0x01, 0x12, 0x5d, 0x0a, 0x0d, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x42, + 0x72, 0x61, 0x6e, 0x63, 0x68, 0x12, 0x22, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x42, 0x72, 0x61, 0x6e, + 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x67, 0x69, 0x74, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, + 0x42, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, + 0x90, 0x02, 0x01, 0x12, 0x50, 0x0a, 0x08, 0x52, 0x65, 0x61, 0x64, 0x46, 0x69, 0x6c, 0x65, 0x12, + 0x1d, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, + 0x65, 0x61, 0x64, 0x46, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, - 0x76, 0x41, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, - 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, - 0x76, 0x41, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x03, 0x90, 0x02, 0x01, 0x12, 0x4d, 0x0a, 0x07, 0x52, 0x61, 0x77, 0x44, 0x69, 0x66, 0x66, 0x12, - 0x1c, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, - 0x61, 0x77, 0x44, 0x69, 0x66, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, + 0x61, 0x64, 0x46, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, + 0x90, 0x02, 0x01, 0x30, 0x01, 0x12, 0x51, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, + 0x69, 0x74, 0x12, 0x1e, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x63, 0x0a, 0x0f, 0x52, 0x65, 0x73, 0x6f, + 0x6c, 0x76, 0x65, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x24, 0x2e, 0x67, 0x69, + 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, + 0x76, 0x65, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x25, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x02, 0x12, 0x50, 0x0a, + 0x08, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x66, 0x73, 0x12, 0x1d, 0x2e, 0x67, 0x69, 0x74, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x66, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, + 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x66, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x30, 0x01, 0x12, + 0x51, 0x0a, 0x09, 0x52, 0x65, 0x76, 0x41, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x1e, 0x2e, 0x67, + 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x76, 0x41, + 0x74, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x67, + 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x76, 0x41, + 0x74, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, + 0x02, 0x01, 0x12, 0x4d, 0x0a, 0x07, 0x52, 0x61, 0x77, 0x44, 0x69, 0x66, 0x66, 0x12, 0x1c, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x61, 0x77, - 0x44, 0x69, 0x66, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, - 0x01, 0x30, 0x01, 0x12, 0x69, 0x0a, 0x11, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, - 0x6f, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x12, 0x26, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, - 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, - 0x74, 0x6f, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x27, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x6f, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, - 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x63, - 0x0a, 0x0f, 0x46, 0x69, 0x72, 0x73, 0x74, 0x45, 0x76, 0x65, 0x72, 0x43, 0x6f, 0x6d, 0x6d, 0x69, - 0x74, 0x12, 0x24, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x46, 0x69, 0x72, 0x73, 0x74, 0x45, 0x76, 0x65, 0x72, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, - 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x69, 0x72, 0x73, 0x74, 0x45, 0x76, 0x65, 0x72, - 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, - 0x90, 0x02, 0x01, 0x12, 0x57, 0x0a, 0x0b, 0x42, 0x65, 0x68, 0x69, 0x6e, 0x64, 0x41, 0x68, 0x65, - 0x61, 0x64, 0x12, 0x20, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x42, 0x65, 0x68, 0x69, 0x6e, 0x64, 0x41, 0x68, 0x65, 0x61, 0x64, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x65, 0x68, 0x69, 0x6e, 0x64, 0x41, 0x68, 0x65, 0x61, 0x64, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x42, 0x3a, 0x5a, 0x38, - 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x67, 0x72, 0x61, 0x70, 0x68, 0x2f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x67, 0x72, 0x61, - 0x70, 0x68, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x67, 0x69, 0x74, 0x73, - 0x65, 0x72, 0x76, 0x65, 0x72, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x44, 0x69, 0x66, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x69, + 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x61, 0x77, 0x44, 0x69, + 0x66, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x30, + 0x01, 0x12, 0x69, 0x0a, 0x11, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x6f, 0x72, + 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x12, 0x26, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x6f, + 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, + 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, + 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x6f, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x63, 0x0a, 0x0f, + 0x46, 0x69, 0x72, 0x73, 0x74, 0x45, 0x76, 0x65, 0x72, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, + 0x24, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x46, + 0x69, 0x72, 0x73, 0x74, 0x45, 0x76, 0x65, 0x72, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x69, 0x72, 0x73, 0x74, 0x45, 0x76, 0x65, 0x72, 0x43, 0x6f, + 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, + 0x01, 0x12, 0x57, 0x0a, 0x0b, 0x42, 0x65, 0x68, 0x69, 0x6e, 0x64, 0x41, 0x68, 0x65, 0x61, 0x64, + 0x12, 0x20, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x42, 0x65, 0x68, 0x69, 0x6e, 0x64, 0x41, 0x68, 0x65, 0x61, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x42, 0x65, 0x68, 0x69, 0x6e, 0x64, 0x41, 0x68, 0x65, 0x61, 0x64, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x5c, 0x0a, 0x0c, 0x43, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x64, 0x46, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x21, 0x2e, 0x67, 0x69, 0x74, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, + 0x64, 0x46, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x22, 0x2e, + 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x64, 0x46, 0x69, 0x6c, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x30, 0x01, 0x42, 0x3a, 0x5a, 0x38, 0x67, 0x69, 0x74, 0x68, + 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x67, 0x72, 0x61, + 0x70, 0x68, 0x2f, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x67, 0x72, 0x61, 0x70, 0x68, 0x2f, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -7606,8 +7860,8 @@ func file_gitserver_proto_rawDescGZIP() []byte { return file_gitserver_proto_rawDescData } -var file_gitserver_proto_enumTypes = make([]protoimpl.EnumInfo, 6) -var file_gitserver_proto_msgTypes = make([]protoimpl.MessageInfo, 101) +var file_gitserver_proto_enumTypes = make([]protoimpl.EnumInfo, 7) +var file_gitserver_proto_msgTypes = make([]protoimpl.MessageInfo, 104) var file_gitserver_proto_goTypes = []interface{}{ (OperatorKind)(0), // 0: gitserver.v1.OperatorKind (ArchiveFormat)(0), // 1: gitserver.v1.ArchiveFormat @@ -7615,244 +7869,252 @@ var file_gitserver_proto_goTypes = []interface{}{ (GitRef_RefType)(0), // 3: gitserver.v1.GitRef.RefType (GitObject_ObjectType)(0), // 4: gitserver.v1.GitObject.ObjectType (PerforceChangelist_PerforceChangelistState)(0), // 5: gitserver.v1.PerforceChangelist.PerforceChangelistState - (*DeleteRepositoryRequest)(nil), // 6: gitserver.v1.DeleteRepositoryRequest - (*DeleteRepositoryResponse)(nil), // 7: gitserver.v1.DeleteRepositoryResponse - (*FetchRepositoryRequest)(nil), // 8: gitserver.v1.FetchRepositoryRequest - (*FetchRepositoryResponse)(nil), // 9: gitserver.v1.FetchRepositoryResponse - (*ContributorCountsRequest)(nil), // 10: gitserver.v1.ContributorCountsRequest - (*ContributorCount)(nil), // 11: gitserver.v1.ContributorCount - (*ContributorCountsResponse)(nil), // 12: gitserver.v1.ContributorCountsResponse - (*RawDiffRequest)(nil), // 13: gitserver.v1.RawDiffRequest - (*RawDiffResponse)(nil), // 14: gitserver.v1.RawDiffResponse - (*ListRefsRequest)(nil), // 15: gitserver.v1.ListRefsRequest - (*ListRefsResponse)(nil), // 16: gitserver.v1.ListRefsResponse - (*GitRef)(nil), // 17: gitserver.v1.GitRef - (*ResolveRevisionRequest)(nil), // 18: gitserver.v1.ResolveRevisionRequest - (*ResolveRevisionResponse)(nil), // 19: gitserver.v1.ResolveRevisionResponse - (*RevAtTimeRequest)(nil), // 20: gitserver.v1.RevAtTimeRequest - (*RevAtTimeResponse)(nil), // 21: gitserver.v1.RevAtTimeResponse - (*GetCommitRequest)(nil), // 22: gitserver.v1.GetCommitRequest - (*GetCommitResponse)(nil), // 23: gitserver.v1.GetCommitResponse - (*GitCommit)(nil), // 24: gitserver.v1.GitCommit - (*GitSignature)(nil), // 25: gitserver.v1.GitSignature - (*BlameRequest)(nil), // 26: gitserver.v1.BlameRequest - (*BlameRange)(nil), // 27: gitserver.v1.BlameRange - (*BlameResponse)(nil), // 28: gitserver.v1.BlameResponse - (*BlameHunk)(nil), // 29: gitserver.v1.BlameHunk - (*BlameAuthor)(nil), // 30: gitserver.v1.BlameAuthor - (*PreviousCommit)(nil), // 31: gitserver.v1.PreviousCommit - (*DefaultBranchRequest)(nil), // 32: gitserver.v1.DefaultBranchRequest - (*DefaultBranchResponse)(nil), // 33: gitserver.v1.DefaultBranchResponse - (*ReadFileRequest)(nil), // 34: gitserver.v1.ReadFileRequest - (*ReadFileResponse)(nil), // 35: gitserver.v1.ReadFileResponse - (*DiskInfoRequest)(nil), // 36: gitserver.v1.DiskInfoRequest - (*DiskInfoResponse)(nil), // 37: gitserver.v1.DiskInfoResponse - (*PatchCommitInfo)(nil), // 38: gitserver.v1.PatchCommitInfo - (*PushConfig)(nil), // 39: gitserver.v1.PushConfig - (*CreateCommitFromPatchBinaryRequest)(nil), // 40: gitserver.v1.CreateCommitFromPatchBinaryRequest - (*CreateCommitFromPatchError)(nil), // 41: gitserver.v1.CreateCommitFromPatchError - (*CreateCommitFromPatchBinaryResponse)(nil), // 42: gitserver.v1.CreateCommitFromPatchBinaryResponse - (*ExecRequest)(nil), // 43: gitserver.v1.ExecRequest - (*ExecResponse)(nil), // 44: gitserver.v1.ExecResponse - (*RepoNotFoundPayload)(nil), // 45: gitserver.v1.RepoNotFoundPayload - (*RevisionNotFoundPayload)(nil), // 46: gitserver.v1.RevisionNotFoundPayload - (*FileNotFoundPayload)(nil), // 47: gitserver.v1.FileNotFoundPayload - (*ExecStatusPayload)(nil), // 48: gitserver.v1.ExecStatusPayload - (*SearchRequest)(nil), // 49: gitserver.v1.SearchRequest - (*RevisionSpecifier)(nil), // 50: gitserver.v1.RevisionSpecifier - (*AuthorMatchesNode)(nil), // 51: gitserver.v1.AuthorMatchesNode - (*CommitterMatchesNode)(nil), // 52: gitserver.v1.CommitterMatchesNode - (*CommitBeforeNode)(nil), // 53: gitserver.v1.CommitBeforeNode - (*CommitAfterNode)(nil), // 54: gitserver.v1.CommitAfterNode - (*MessageMatchesNode)(nil), // 55: gitserver.v1.MessageMatchesNode - (*DiffMatchesNode)(nil), // 56: gitserver.v1.DiffMatchesNode - (*DiffModifiesFileNode)(nil), // 57: gitserver.v1.DiffModifiesFileNode - (*BooleanNode)(nil), // 58: gitserver.v1.BooleanNode - (*OperatorNode)(nil), // 59: gitserver.v1.OperatorNode - (*QueryNode)(nil), // 60: gitserver.v1.QueryNode - (*SearchResponse)(nil), // 61: gitserver.v1.SearchResponse - (*CommitMatch)(nil), // 62: gitserver.v1.CommitMatch - (*ArchiveRequest)(nil), // 63: gitserver.v1.ArchiveRequest - (*ArchiveResponse)(nil), // 64: gitserver.v1.ArchiveResponse - (*IsRepoCloneableRequest)(nil), // 65: gitserver.v1.IsRepoCloneableRequest - (*IsRepoCloneableResponse)(nil), // 66: gitserver.v1.IsRepoCloneableResponse - (*RepoCloneProgressRequest)(nil), // 67: gitserver.v1.RepoCloneProgressRequest - (*RepoCloneProgressResponse)(nil), // 68: gitserver.v1.RepoCloneProgressResponse - (*ListGitoliteRequest)(nil), // 69: gitserver.v1.ListGitoliteRequest - (*GitoliteRepo)(nil), // 70: gitserver.v1.GitoliteRepo - (*ListGitoliteResponse)(nil), // 71: gitserver.v1.ListGitoliteResponse - (*GetObjectRequest)(nil), // 72: gitserver.v1.GetObjectRequest - (*GetObjectResponse)(nil), // 73: gitserver.v1.GetObjectResponse - (*GitObject)(nil), // 74: gitserver.v1.GitObject - (*IsPerforcePathCloneableRequest)(nil), // 75: gitserver.v1.IsPerforcePathCloneableRequest - (*IsPerforcePathCloneableResponse)(nil), // 76: gitserver.v1.IsPerforcePathCloneableResponse - (*CheckPerforceCredentialsRequest)(nil), // 77: gitserver.v1.CheckPerforceCredentialsRequest - (*CheckPerforceCredentialsResponse)(nil), // 78: gitserver.v1.CheckPerforceCredentialsResponse - (*PerforceConnectionDetails)(nil), // 79: gitserver.v1.PerforceConnectionDetails - (*PerforceGetChangelistRequest)(nil), // 80: gitserver.v1.PerforceGetChangelistRequest - (*PerforceGetChangelistResponse)(nil), // 81: gitserver.v1.PerforceGetChangelistResponse - (*PerforceChangelist)(nil), // 82: gitserver.v1.PerforceChangelist - (*IsPerforceSuperUserRequest)(nil), // 83: gitserver.v1.IsPerforceSuperUserRequest - (*IsPerforceSuperUserResponse)(nil), // 84: gitserver.v1.IsPerforceSuperUserResponse - (*PerforceProtectsForDepotRequest)(nil), // 85: gitserver.v1.PerforceProtectsForDepotRequest - (*PerforceProtectsForDepotResponse)(nil), // 86: gitserver.v1.PerforceProtectsForDepotResponse - (*PerforceProtectsForUserRequest)(nil), // 87: gitserver.v1.PerforceProtectsForUserRequest - (*PerforceProtectsForUserResponse)(nil), // 88: gitserver.v1.PerforceProtectsForUserResponse - (*PerforceProtect)(nil), // 89: gitserver.v1.PerforceProtect - (*PerforceGroupMembersRequest)(nil), // 90: gitserver.v1.PerforceGroupMembersRequest - (*PerforceGroupMembersResponse)(nil), // 91: gitserver.v1.PerforceGroupMembersResponse - (*PerforceUsersRequest)(nil), // 92: gitserver.v1.PerforceUsersRequest - (*PerforceUsersResponse)(nil), // 93: gitserver.v1.PerforceUsersResponse - (*PerforceUser)(nil), // 94: gitserver.v1.PerforceUser - (*MergeBaseRequest)(nil), // 95: gitserver.v1.MergeBaseRequest - (*MergeBaseResponse)(nil), // 96: gitserver.v1.MergeBaseResponse - (*FirstEverCommitRequest)(nil), // 97: gitserver.v1.FirstEverCommitRequest - (*FirstEverCommitResponse)(nil), // 98: gitserver.v1.FirstEverCommitResponse - (*BehindAheadRequest)(nil), // 99: gitserver.v1.BehindAheadRequest - (*BehindAheadResponse)(nil), // 100: gitserver.v1.BehindAheadResponse - (*CreateCommitFromPatchBinaryRequest_Metadata)(nil), // 101: gitserver.v1.CreateCommitFromPatchBinaryRequest.Metadata - (*CreateCommitFromPatchBinaryRequest_Patch)(nil), // 102: gitserver.v1.CreateCommitFromPatchBinaryRequest.Patch - (*CommitMatch_Signature)(nil), // 103: gitserver.v1.CommitMatch.Signature - (*CommitMatch_MatchedString)(nil), // 104: gitserver.v1.CommitMatch.MatchedString - (*CommitMatch_Range)(nil), // 105: gitserver.v1.CommitMatch.Range - (*CommitMatch_Location)(nil), // 106: gitserver.v1.CommitMatch.Location - (*timestamppb.Timestamp)(nil), // 107: google.protobuf.Timestamp + (ChangedFile_Status)(0), // 6: gitserver.v1.ChangedFile.Status + (*DeleteRepositoryRequest)(nil), // 7: gitserver.v1.DeleteRepositoryRequest + (*DeleteRepositoryResponse)(nil), // 8: gitserver.v1.DeleteRepositoryResponse + (*FetchRepositoryRequest)(nil), // 9: gitserver.v1.FetchRepositoryRequest + (*FetchRepositoryResponse)(nil), // 10: gitserver.v1.FetchRepositoryResponse + (*ContributorCountsRequest)(nil), // 11: gitserver.v1.ContributorCountsRequest + (*ContributorCount)(nil), // 12: gitserver.v1.ContributorCount + (*ContributorCountsResponse)(nil), // 13: gitserver.v1.ContributorCountsResponse + (*RawDiffRequest)(nil), // 14: gitserver.v1.RawDiffRequest + (*RawDiffResponse)(nil), // 15: gitserver.v1.RawDiffResponse + (*ListRefsRequest)(nil), // 16: gitserver.v1.ListRefsRequest + (*ListRefsResponse)(nil), // 17: gitserver.v1.ListRefsResponse + (*GitRef)(nil), // 18: gitserver.v1.GitRef + (*ResolveRevisionRequest)(nil), // 19: gitserver.v1.ResolveRevisionRequest + (*ResolveRevisionResponse)(nil), // 20: gitserver.v1.ResolveRevisionResponse + (*RevAtTimeRequest)(nil), // 21: gitserver.v1.RevAtTimeRequest + (*RevAtTimeResponse)(nil), // 22: gitserver.v1.RevAtTimeResponse + (*GetCommitRequest)(nil), // 23: gitserver.v1.GetCommitRequest + (*GetCommitResponse)(nil), // 24: gitserver.v1.GetCommitResponse + (*GitCommit)(nil), // 25: gitserver.v1.GitCommit + (*GitSignature)(nil), // 26: gitserver.v1.GitSignature + (*BlameRequest)(nil), // 27: gitserver.v1.BlameRequest + (*BlameRange)(nil), // 28: gitserver.v1.BlameRange + (*BlameResponse)(nil), // 29: gitserver.v1.BlameResponse + (*BlameHunk)(nil), // 30: gitserver.v1.BlameHunk + (*BlameAuthor)(nil), // 31: gitserver.v1.BlameAuthor + (*PreviousCommit)(nil), // 32: gitserver.v1.PreviousCommit + (*DefaultBranchRequest)(nil), // 33: gitserver.v1.DefaultBranchRequest + (*DefaultBranchResponse)(nil), // 34: gitserver.v1.DefaultBranchResponse + (*ReadFileRequest)(nil), // 35: gitserver.v1.ReadFileRequest + (*ReadFileResponse)(nil), // 36: gitserver.v1.ReadFileResponse + (*DiskInfoRequest)(nil), // 37: gitserver.v1.DiskInfoRequest + (*DiskInfoResponse)(nil), // 38: gitserver.v1.DiskInfoResponse + (*PatchCommitInfo)(nil), // 39: gitserver.v1.PatchCommitInfo + (*PushConfig)(nil), // 40: gitserver.v1.PushConfig + (*CreateCommitFromPatchBinaryRequest)(nil), // 41: gitserver.v1.CreateCommitFromPatchBinaryRequest + (*CreateCommitFromPatchError)(nil), // 42: gitserver.v1.CreateCommitFromPatchError + (*CreateCommitFromPatchBinaryResponse)(nil), // 43: gitserver.v1.CreateCommitFromPatchBinaryResponse + (*ExecRequest)(nil), // 44: gitserver.v1.ExecRequest + (*ExecResponse)(nil), // 45: gitserver.v1.ExecResponse + (*RepoNotFoundPayload)(nil), // 46: gitserver.v1.RepoNotFoundPayload + (*RevisionNotFoundPayload)(nil), // 47: gitserver.v1.RevisionNotFoundPayload + (*FileNotFoundPayload)(nil), // 48: gitserver.v1.FileNotFoundPayload + (*ExecStatusPayload)(nil), // 49: gitserver.v1.ExecStatusPayload + (*SearchRequest)(nil), // 50: gitserver.v1.SearchRequest + (*RevisionSpecifier)(nil), // 51: gitserver.v1.RevisionSpecifier + (*AuthorMatchesNode)(nil), // 52: gitserver.v1.AuthorMatchesNode + (*CommitterMatchesNode)(nil), // 53: gitserver.v1.CommitterMatchesNode + (*CommitBeforeNode)(nil), // 54: gitserver.v1.CommitBeforeNode + (*CommitAfterNode)(nil), // 55: gitserver.v1.CommitAfterNode + (*MessageMatchesNode)(nil), // 56: gitserver.v1.MessageMatchesNode + (*DiffMatchesNode)(nil), // 57: gitserver.v1.DiffMatchesNode + (*DiffModifiesFileNode)(nil), // 58: gitserver.v1.DiffModifiesFileNode + (*BooleanNode)(nil), // 59: gitserver.v1.BooleanNode + (*OperatorNode)(nil), // 60: gitserver.v1.OperatorNode + (*QueryNode)(nil), // 61: gitserver.v1.QueryNode + (*SearchResponse)(nil), // 62: gitserver.v1.SearchResponse + (*CommitMatch)(nil), // 63: gitserver.v1.CommitMatch + (*ArchiveRequest)(nil), // 64: gitserver.v1.ArchiveRequest + (*ArchiveResponse)(nil), // 65: gitserver.v1.ArchiveResponse + (*IsRepoCloneableRequest)(nil), // 66: gitserver.v1.IsRepoCloneableRequest + (*IsRepoCloneableResponse)(nil), // 67: gitserver.v1.IsRepoCloneableResponse + (*RepoCloneProgressRequest)(nil), // 68: gitserver.v1.RepoCloneProgressRequest + (*RepoCloneProgressResponse)(nil), // 69: gitserver.v1.RepoCloneProgressResponse + (*ListGitoliteRequest)(nil), // 70: gitserver.v1.ListGitoliteRequest + (*GitoliteRepo)(nil), // 71: gitserver.v1.GitoliteRepo + (*ListGitoliteResponse)(nil), // 72: gitserver.v1.ListGitoliteResponse + (*GetObjectRequest)(nil), // 73: gitserver.v1.GetObjectRequest + (*GetObjectResponse)(nil), // 74: gitserver.v1.GetObjectResponse + (*GitObject)(nil), // 75: gitserver.v1.GitObject + (*IsPerforcePathCloneableRequest)(nil), // 76: gitserver.v1.IsPerforcePathCloneableRequest + (*IsPerforcePathCloneableResponse)(nil), // 77: gitserver.v1.IsPerforcePathCloneableResponse + (*CheckPerforceCredentialsRequest)(nil), // 78: gitserver.v1.CheckPerforceCredentialsRequest + (*CheckPerforceCredentialsResponse)(nil), // 79: gitserver.v1.CheckPerforceCredentialsResponse + (*PerforceConnectionDetails)(nil), // 80: gitserver.v1.PerforceConnectionDetails + (*PerforceGetChangelistRequest)(nil), // 81: gitserver.v1.PerforceGetChangelistRequest + (*PerforceGetChangelistResponse)(nil), // 82: gitserver.v1.PerforceGetChangelistResponse + (*PerforceChangelist)(nil), // 83: gitserver.v1.PerforceChangelist + (*IsPerforceSuperUserRequest)(nil), // 84: gitserver.v1.IsPerforceSuperUserRequest + (*IsPerforceSuperUserResponse)(nil), // 85: gitserver.v1.IsPerforceSuperUserResponse + (*PerforceProtectsForDepotRequest)(nil), // 86: gitserver.v1.PerforceProtectsForDepotRequest + (*PerforceProtectsForDepotResponse)(nil), // 87: gitserver.v1.PerforceProtectsForDepotResponse + (*PerforceProtectsForUserRequest)(nil), // 88: gitserver.v1.PerforceProtectsForUserRequest + (*PerforceProtectsForUserResponse)(nil), // 89: gitserver.v1.PerforceProtectsForUserResponse + (*PerforceProtect)(nil), // 90: gitserver.v1.PerforceProtect + (*PerforceGroupMembersRequest)(nil), // 91: gitserver.v1.PerforceGroupMembersRequest + (*PerforceGroupMembersResponse)(nil), // 92: gitserver.v1.PerforceGroupMembersResponse + (*PerforceUsersRequest)(nil), // 93: gitserver.v1.PerforceUsersRequest + (*PerforceUsersResponse)(nil), // 94: gitserver.v1.PerforceUsersResponse + (*PerforceUser)(nil), // 95: gitserver.v1.PerforceUser + (*MergeBaseRequest)(nil), // 96: gitserver.v1.MergeBaseRequest + (*MergeBaseResponse)(nil), // 97: gitserver.v1.MergeBaseResponse + (*FirstEverCommitRequest)(nil), // 98: gitserver.v1.FirstEverCommitRequest + (*FirstEverCommitResponse)(nil), // 99: gitserver.v1.FirstEverCommitResponse + (*BehindAheadRequest)(nil), // 100: gitserver.v1.BehindAheadRequest + (*BehindAheadResponse)(nil), // 101: gitserver.v1.BehindAheadResponse + (*ChangedFilesRequest)(nil), // 102: gitserver.v1.ChangedFilesRequest + (*ChangedFilesResponse)(nil), // 103: gitserver.v1.ChangedFilesResponse + (*ChangedFile)(nil), // 104: gitserver.v1.ChangedFile + (*CreateCommitFromPatchBinaryRequest_Metadata)(nil), // 105: gitserver.v1.CreateCommitFromPatchBinaryRequest.Metadata + (*CreateCommitFromPatchBinaryRequest_Patch)(nil), // 106: gitserver.v1.CreateCommitFromPatchBinaryRequest.Patch + (*CommitMatch_Signature)(nil), // 107: gitserver.v1.CommitMatch.Signature + (*CommitMatch_MatchedString)(nil), // 108: gitserver.v1.CommitMatch.MatchedString + (*CommitMatch_Range)(nil), // 109: gitserver.v1.CommitMatch.Range + (*CommitMatch_Location)(nil), // 110: gitserver.v1.CommitMatch.Location + (*timestamppb.Timestamp)(nil), // 111: google.protobuf.Timestamp } var file_gitserver_proto_depIdxs = []int32{ - 107, // 0: gitserver.v1.FetchRepositoryResponse.last_fetched:type_name -> google.protobuf.Timestamp - 107, // 1: gitserver.v1.FetchRepositoryResponse.last_changed:type_name -> google.protobuf.Timestamp - 107, // 2: gitserver.v1.ContributorCountsRequest.after:type_name -> google.protobuf.Timestamp - 25, // 3: gitserver.v1.ContributorCount.author:type_name -> gitserver.v1.GitSignature - 11, // 4: gitserver.v1.ContributorCountsResponse.counts:type_name -> gitserver.v1.ContributorCount + 111, // 0: gitserver.v1.FetchRepositoryResponse.last_fetched:type_name -> google.protobuf.Timestamp + 111, // 1: gitserver.v1.FetchRepositoryResponse.last_changed:type_name -> google.protobuf.Timestamp + 111, // 2: gitserver.v1.ContributorCountsRequest.after:type_name -> google.protobuf.Timestamp + 26, // 3: gitserver.v1.ContributorCount.author:type_name -> gitserver.v1.GitSignature + 12, // 4: gitserver.v1.ContributorCountsResponse.counts:type_name -> gitserver.v1.ContributorCount 2, // 5: gitserver.v1.RawDiffRequest.comparison_type:type_name -> gitserver.v1.RawDiffRequest.ComparisonType - 17, // 6: gitserver.v1.ListRefsResponse.refs:type_name -> gitserver.v1.GitRef - 107, // 7: gitserver.v1.GitRef.created_at:type_name -> google.protobuf.Timestamp + 18, // 6: gitserver.v1.ListRefsResponse.refs:type_name -> gitserver.v1.GitRef + 111, // 7: gitserver.v1.GitRef.created_at:type_name -> google.protobuf.Timestamp 3, // 8: gitserver.v1.GitRef.ref_type:type_name -> gitserver.v1.GitRef.RefType - 107, // 9: gitserver.v1.RevAtTimeRequest.time:type_name -> google.protobuf.Timestamp - 24, // 10: gitserver.v1.GetCommitResponse.commit:type_name -> gitserver.v1.GitCommit - 25, // 11: gitserver.v1.GitCommit.author:type_name -> gitserver.v1.GitSignature - 25, // 12: gitserver.v1.GitCommit.committer:type_name -> gitserver.v1.GitSignature - 107, // 13: gitserver.v1.GitSignature.date:type_name -> google.protobuf.Timestamp - 27, // 14: gitserver.v1.BlameRequest.range:type_name -> gitserver.v1.BlameRange - 29, // 15: gitserver.v1.BlameResponse.hunk:type_name -> gitserver.v1.BlameHunk - 30, // 16: gitserver.v1.BlameHunk.author:type_name -> gitserver.v1.BlameAuthor - 31, // 17: gitserver.v1.BlameHunk.previous_commit:type_name -> gitserver.v1.PreviousCommit - 107, // 18: gitserver.v1.BlameAuthor.date:type_name -> google.protobuf.Timestamp - 107, // 19: gitserver.v1.PatchCommitInfo.date:type_name -> google.protobuf.Timestamp - 101, // 20: gitserver.v1.CreateCommitFromPatchBinaryRequest.metadata:type_name -> gitserver.v1.CreateCommitFromPatchBinaryRequest.Metadata - 102, // 21: gitserver.v1.CreateCommitFromPatchBinaryRequest.patch:type_name -> gitserver.v1.CreateCommitFromPatchBinaryRequest.Patch - 50, // 22: gitserver.v1.SearchRequest.revisions:type_name -> gitserver.v1.RevisionSpecifier - 60, // 23: gitserver.v1.SearchRequest.query:type_name -> gitserver.v1.QueryNode - 107, // 24: gitserver.v1.CommitBeforeNode.timestamp:type_name -> google.protobuf.Timestamp - 107, // 25: gitserver.v1.CommitAfterNode.timestamp:type_name -> google.protobuf.Timestamp + 111, // 9: gitserver.v1.RevAtTimeRequest.time:type_name -> google.protobuf.Timestamp + 25, // 10: gitserver.v1.GetCommitResponse.commit:type_name -> gitserver.v1.GitCommit + 26, // 11: gitserver.v1.GitCommit.author:type_name -> gitserver.v1.GitSignature + 26, // 12: gitserver.v1.GitCommit.committer:type_name -> gitserver.v1.GitSignature + 111, // 13: gitserver.v1.GitSignature.date:type_name -> google.protobuf.Timestamp + 28, // 14: gitserver.v1.BlameRequest.range:type_name -> gitserver.v1.BlameRange + 30, // 15: gitserver.v1.BlameResponse.hunk:type_name -> gitserver.v1.BlameHunk + 31, // 16: gitserver.v1.BlameHunk.author:type_name -> gitserver.v1.BlameAuthor + 32, // 17: gitserver.v1.BlameHunk.previous_commit:type_name -> gitserver.v1.PreviousCommit + 111, // 18: gitserver.v1.BlameAuthor.date:type_name -> google.protobuf.Timestamp + 111, // 19: gitserver.v1.PatchCommitInfo.date:type_name -> google.protobuf.Timestamp + 105, // 20: gitserver.v1.CreateCommitFromPatchBinaryRequest.metadata:type_name -> gitserver.v1.CreateCommitFromPatchBinaryRequest.Metadata + 106, // 21: gitserver.v1.CreateCommitFromPatchBinaryRequest.patch:type_name -> gitserver.v1.CreateCommitFromPatchBinaryRequest.Patch + 51, // 22: gitserver.v1.SearchRequest.revisions:type_name -> gitserver.v1.RevisionSpecifier + 61, // 23: gitserver.v1.SearchRequest.query:type_name -> gitserver.v1.QueryNode + 111, // 24: gitserver.v1.CommitBeforeNode.timestamp:type_name -> google.protobuf.Timestamp + 111, // 25: gitserver.v1.CommitAfterNode.timestamp:type_name -> google.protobuf.Timestamp 0, // 26: gitserver.v1.OperatorNode.kind:type_name -> gitserver.v1.OperatorKind - 60, // 27: gitserver.v1.OperatorNode.operands:type_name -> gitserver.v1.QueryNode - 51, // 28: gitserver.v1.QueryNode.author_matches:type_name -> gitserver.v1.AuthorMatchesNode - 52, // 29: gitserver.v1.QueryNode.committer_matches:type_name -> gitserver.v1.CommitterMatchesNode - 53, // 30: gitserver.v1.QueryNode.commit_before:type_name -> gitserver.v1.CommitBeforeNode - 54, // 31: gitserver.v1.QueryNode.commit_after:type_name -> gitserver.v1.CommitAfterNode - 55, // 32: gitserver.v1.QueryNode.message_matches:type_name -> gitserver.v1.MessageMatchesNode - 56, // 33: gitserver.v1.QueryNode.diff_matches:type_name -> gitserver.v1.DiffMatchesNode - 57, // 34: gitserver.v1.QueryNode.diff_modifies_file:type_name -> gitserver.v1.DiffModifiesFileNode - 58, // 35: gitserver.v1.QueryNode.boolean:type_name -> gitserver.v1.BooleanNode - 59, // 36: gitserver.v1.QueryNode.operator:type_name -> gitserver.v1.OperatorNode - 62, // 37: gitserver.v1.SearchResponse.match:type_name -> gitserver.v1.CommitMatch - 103, // 38: gitserver.v1.CommitMatch.author:type_name -> gitserver.v1.CommitMatch.Signature - 103, // 39: gitserver.v1.CommitMatch.committer:type_name -> gitserver.v1.CommitMatch.Signature - 104, // 40: gitserver.v1.CommitMatch.message:type_name -> gitserver.v1.CommitMatch.MatchedString - 104, // 41: gitserver.v1.CommitMatch.diff:type_name -> gitserver.v1.CommitMatch.MatchedString + 61, // 27: gitserver.v1.OperatorNode.operands:type_name -> gitserver.v1.QueryNode + 52, // 28: gitserver.v1.QueryNode.author_matches:type_name -> gitserver.v1.AuthorMatchesNode + 53, // 29: gitserver.v1.QueryNode.committer_matches:type_name -> gitserver.v1.CommitterMatchesNode + 54, // 30: gitserver.v1.QueryNode.commit_before:type_name -> gitserver.v1.CommitBeforeNode + 55, // 31: gitserver.v1.QueryNode.commit_after:type_name -> gitserver.v1.CommitAfterNode + 56, // 32: gitserver.v1.QueryNode.message_matches:type_name -> gitserver.v1.MessageMatchesNode + 57, // 33: gitserver.v1.QueryNode.diff_matches:type_name -> gitserver.v1.DiffMatchesNode + 58, // 34: gitserver.v1.QueryNode.diff_modifies_file:type_name -> gitserver.v1.DiffModifiesFileNode + 59, // 35: gitserver.v1.QueryNode.boolean:type_name -> gitserver.v1.BooleanNode + 60, // 36: gitserver.v1.QueryNode.operator:type_name -> gitserver.v1.OperatorNode + 63, // 37: gitserver.v1.SearchResponse.match:type_name -> gitserver.v1.CommitMatch + 107, // 38: gitserver.v1.CommitMatch.author:type_name -> gitserver.v1.CommitMatch.Signature + 107, // 39: gitserver.v1.CommitMatch.committer:type_name -> gitserver.v1.CommitMatch.Signature + 108, // 40: gitserver.v1.CommitMatch.message:type_name -> gitserver.v1.CommitMatch.MatchedString + 108, // 41: gitserver.v1.CommitMatch.diff:type_name -> gitserver.v1.CommitMatch.MatchedString 1, // 42: gitserver.v1.ArchiveRequest.format:type_name -> gitserver.v1.ArchiveFormat - 70, // 43: gitserver.v1.ListGitoliteResponse.repos:type_name -> gitserver.v1.GitoliteRepo - 74, // 44: gitserver.v1.GetObjectResponse.object:type_name -> gitserver.v1.GitObject + 71, // 43: gitserver.v1.ListGitoliteResponse.repos:type_name -> gitserver.v1.GitoliteRepo + 75, // 44: gitserver.v1.GetObjectResponse.object:type_name -> gitserver.v1.GitObject 4, // 45: gitserver.v1.GitObject.type:type_name -> gitserver.v1.GitObject.ObjectType - 79, // 46: gitserver.v1.IsPerforcePathCloneableRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails - 79, // 47: gitserver.v1.CheckPerforceCredentialsRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails - 79, // 48: gitserver.v1.PerforceGetChangelistRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails - 82, // 49: gitserver.v1.PerforceGetChangelistResponse.changelist:type_name -> gitserver.v1.PerforceChangelist - 107, // 50: gitserver.v1.PerforceChangelist.creation_date:type_name -> google.protobuf.Timestamp + 80, // 46: gitserver.v1.IsPerforcePathCloneableRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails + 80, // 47: gitserver.v1.CheckPerforceCredentialsRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails + 80, // 48: gitserver.v1.PerforceGetChangelistRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails + 83, // 49: gitserver.v1.PerforceGetChangelistResponse.changelist:type_name -> gitserver.v1.PerforceChangelist + 111, // 50: gitserver.v1.PerforceChangelist.creation_date:type_name -> google.protobuf.Timestamp 5, // 51: gitserver.v1.PerforceChangelist.state:type_name -> gitserver.v1.PerforceChangelist.PerforceChangelistState - 79, // 52: gitserver.v1.IsPerforceSuperUserRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails - 79, // 53: gitserver.v1.PerforceProtectsForDepotRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails - 89, // 54: gitserver.v1.PerforceProtectsForDepotResponse.protects:type_name -> gitserver.v1.PerforceProtect - 79, // 55: gitserver.v1.PerforceProtectsForUserRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails - 89, // 56: gitserver.v1.PerforceProtectsForUserResponse.protects:type_name -> gitserver.v1.PerforceProtect - 79, // 57: gitserver.v1.PerforceGroupMembersRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails - 79, // 58: gitserver.v1.PerforceUsersRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails - 94, // 59: gitserver.v1.PerforceUsersResponse.users:type_name -> gitserver.v1.PerforceUser - 24, // 60: gitserver.v1.FirstEverCommitResponse.commit:type_name -> gitserver.v1.GitCommit - 38, // 61: gitserver.v1.CreateCommitFromPatchBinaryRequest.Metadata.commit_info:type_name -> gitserver.v1.PatchCommitInfo - 39, // 62: gitserver.v1.CreateCommitFromPatchBinaryRequest.Metadata.push:type_name -> gitserver.v1.PushConfig - 107, // 63: gitserver.v1.CommitMatch.Signature.date:type_name -> google.protobuf.Timestamp - 105, // 64: gitserver.v1.CommitMatch.MatchedString.ranges:type_name -> gitserver.v1.CommitMatch.Range - 106, // 65: gitserver.v1.CommitMatch.Range.start:type_name -> gitserver.v1.CommitMatch.Location - 106, // 66: gitserver.v1.CommitMatch.Range.end:type_name -> gitserver.v1.CommitMatch.Location - 6, // 67: gitserver.v1.GitserverRepositoryService.DeleteRepository:input_type -> gitserver.v1.DeleteRepositoryRequest - 8, // 68: gitserver.v1.GitserverRepositoryService.FetchRepository:input_type -> gitserver.v1.FetchRepositoryRequest - 40, // 69: gitserver.v1.GitserverService.CreateCommitFromPatchBinary:input_type -> gitserver.v1.CreateCommitFromPatchBinaryRequest - 36, // 70: gitserver.v1.GitserverService.DiskInfo:input_type -> gitserver.v1.DiskInfoRequest - 43, // 71: gitserver.v1.GitserverService.Exec:input_type -> gitserver.v1.ExecRequest - 72, // 72: gitserver.v1.GitserverService.GetObject:input_type -> gitserver.v1.GetObjectRequest - 65, // 73: gitserver.v1.GitserverService.IsRepoCloneable:input_type -> gitserver.v1.IsRepoCloneableRequest - 69, // 74: gitserver.v1.GitserverService.ListGitolite:input_type -> gitserver.v1.ListGitoliteRequest - 49, // 75: gitserver.v1.GitserverService.Search:input_type -> gitserver.v1.SearchRequest - 63, // 76: gitserver.v1.GitserverService.Archive:input_type -> gitserver.v1.ArchiveRequest - 67, // 77: gitserver.v1.GitserverService.RepoCloneProgress:input_type -> gitserver.v1.RepoCloneProgressRequest - 75, // 78: gitserver.v1.GitserverService.IsPerforcePathCloneable:input_type -> gitserver.v1.IsPerforcePathCloneableRequest - 77, // 79: gitserver.v1.GitserverService.CheckPerforceCredentials:input_type -> gitserver.v1.CheckPerforceCredentialsRequest - 92, // 80: gitserver.v1.GitserverService.PerforceUsers:input_type -> gitserver.v1.PerforceUsersRequest - 87, // 81: gitserver.v1.GitserverService.PerforceProtectsForUser:input_type -> gitserver.v1.PerforceProtectsForUserRequest - 85, // 82: gitserver.v1.GitserverService.PerforceProtectsForDepot:input_type -> gitserver.v1.PerforceProtectsForDepotRequest - 90, // 83: gitserver.v1.GitserverService.PerforceGroupMembers:input_type -> gitserver.v1.PerforceGroupMembersRequest - 83, // 84: gitserver.v1.GitserverService.IsPerforceSuperUser:input_type -> gitserver.v1.IsPerforceSuperUserRequest - 80, // 85: gitserver.v1.GitserverService.PerforceGetChangelist:input_type -> gitserver.v1.PerforceGetChangelistRequest - 95, // 86: gitserver.v1.GitserverService.MergeBase:input_type -> gitserver.v1.MergeBaseRequest - 26, // 87: gitserver.v1.GitserverService.Blame:input_type -> gitserver.v1.BlameRequest - 32, // 88: gitserver.v1.GitserverService.DefaultBranch:input_type -> gitserver.v1.DefaultBranchRequest - 34, // 89: gitserver.v1.GitserverService.ReadFile:input_type -> gitserver.v1.ReadFileRequest - 22, // 90: gitserver.v1.GitserverService.GetCommit:input_type -> gitserver.v1.GetCommitRequest - 18, // 91: gitserver.v1.GitserverService.ResolveRevision:input_type -> gitserver.v1.ResolveRevisionRequest - 15, // 92: gitserver.v1.GitserverService.ListRefs:input_type -> gitserver.v1.ListRefsRequest - 20, // 93: gitserver.v1.GitserverService.RevAtTime:input_type -> gitserver.v1.RevAtTimeRequest - 13, // 94: gitserver.v1.GitserverService.RawDiff:input_type -> gitserver.v1.RawDiffRequest - 10, // 95: gitserver.v1.GitserverService.ContributorCounts:input_type -> gitserver.v1.ContributorCountsRequest - 97, // 96: gitserver.v1.GitserverService.FirstEverCommit:input_type -> gitserver.v1.FirstEverCommitRequest - 99, // 97: gitserver.v1.GitserverService.BehindAhead:input_type -> gitserver.v1.BehindAheadRequest - 7, // 98: gitserver.v1.GitserverRepositoryService.DeleteRepository:output_type -> gitserver.v1.DeleteRepositoryResponse - 9, // 99: gitserver.v1.GitserverRepositoryService.FetchRepository:output_type -> gitserver.v1.FetchRepositoryResponse - 42, // 100: gitserver.v1.GitserverService.CreateCommitFromPatchBinary:output_type -> gitserver.v1.CreateCommitFromPatchBinaryResponse - 37, // 101: gitserver.v1.GitserverService.DiskInfo:output_type -> gitserver.v1.DiskInfoResponse - 44, // 102: gitserver.v1.GitserverService.Exec:output_type -> gitserver.v1.ExecResponse - 73, // 103: gitserver.v1.GitserverService.GetObject:output_type -> gitserver.v1.GetObjectResponse - 66, // 104: gitserver.v1.GitserverService.IsRepoCloneable:output_type -> gitserver.v1.IsRepoCloneableResponse - 71, // 105: gitserver.v1.GitserverService.ListGitolite:output_type -> gitserver.v1.ListGitoliteResponse - 61, // 106: gitserver.v1.GitserverService.Search:output_type -> gitserver.v1.SearchResponse - 64, // 107: gitserver.v1.GitserverService.Archive:output_type -> gitserver.v1.ArchiveResponse - 68, // 108: gitserver.v1.GitserverService.RepoCloneProgress:output_type -> gitserver.v1.RepoCloneProgressResponse - 76, // 109: gitserver.v1.GitserverService.IsPerforcePathCloneable:output_type -> gitserver.v1.IsPerforcePathCloneableResponse - 78, // 110: gitserver.v1.GitserverService.CheckPerforceCredentials:output_type -> gitserver.v1.CheckPerforceCredentialsResponse - 93, // 111: gitserver.v1.GitserverService.PerforceUsers:output_type -> gitserver.v1.PerforceUsersResponse - 88, // 112: gitserver.v1.GitserverService.PerforceProtectsForUser:output_type -> gitserver.v1.PerforceProtectsForUserResponse - 86, // 113: gitserver.v1.GitserverService.PerforceProtectsForDepot:output_type -> gitserver.v1.PerforceProtectsForDepotResponse - 91, // 114: gitserver.v1.GitserverService.PerforceGroupMembers:output_type -> gitserver.v1.PerforceGroupMembersResponse - 84, // 115: gitserver.v1.GitserverService.IsPerforceSuperUser:output_type -> gitserver.v1.IsPerforceSuperUserResponse - 81, // 116: gitserver.v1.GitserverService.PerforceGetChangelist:output_type -> gitserver.v1.PerforceGetChangelistResponse - 96, // 117: gitserver.v1.GitserverService.MergeBase:output_type -> gitserver.v1.MergeBaseResponse - 28, // 118: gitserver.v1.GitserverService.Blame:output_type -> gitserver.v1.BlameResponse - 33, // 119: gitserver.v1.GitserverService.DefaultBranch:output_type -> gitserver.v1.DefaultBranchResponse - 35, // 120: gitserver.v1.GitserverService.ReadFile:output_type -> gitserver.v1.ReadFileResponse - 23, // 121: gitserver.v1.GitserverService.GetCommit:output_type -> gitserver.v1.GetCommitResponse - 19, // 122: gitserver.v1.GitserverService.ResolveRevision:output_type -> gitserver.v1.ResolveRevisionResponse - 16, // 123: gitserver.v1.GitserverService.ListRefs:output_type -> gitserver.v1.ListRefsResponse - 21, // 124: gitserver.v1.GitserverService.RevAtTime:output_type -> gitserver.v1.RevAtTimeResponse - 14, // 125: gitserver.v1.GitserverService.RawDiff:output_type -> gitserver.v1.RawDiffResponse - 12, // 126: gitserver.v1.GitserverService.ContributorCounts:output_type -> gitserver.v1.ContributorCountsResponse - 98, // 127: gitserver.v1.GitserverService.FirstEverCommit:output_type -> gitserver.v1.FirstEverCommitResponse - 100, // 128: gitserver.v1.GitserverService.BehindAhead:output_type -> gitserver.v1.BehindAheadResponse - 98, // [98:129] is the sub-list for method output_type - 67, // [67:98] is the sub-list for method input_type - 67, // [67:67] is the sub-list for extension type_name - 67, // [67:67] is the sub-list for extension extendee - 0, // [0:67] is the sub-list for field type_name + 80, // 52: gitserver.v1.IsPerforceSuperUserRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails + 80, // 53: gitserver.v1.PerforceProtectsForDepotRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails + 90, // 54: gitserver.v1.PerforceProtectsForDepotResponse.protects:type_name -> gitserver.v1.PerforceProtect + 80, // 55: gitserver.v1.PerforceProtectsForUserRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails + 90, // 56: gitserver.v1.PerforceProtectsForUserResponse.protects:type_name -> gitserver.v1.PerforceProtect + 80, // 57: gitserver.v1.PerforceGroupMembersRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails + 80, // 58: gitserver.v1.PerforceUsersRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails + 95, // 59: gitserver.v1.PerforceUsersResponse.users:type_name -> gitserver.v1.PerforceUser + 25, // 60: gitserver.v1.FirstEverCommitResponse.commit:type_name -> gitserver.v1.GitCommit + 104, // 61: gitserver.v1.ChangedFilesResponse.files:type_name -> gitserver.v1.ChangedFile + 6, // 62: gitserver.v1.ChangedFile.status:type_name -> gitserver.v1.ChangedFile.Status + 39, // 63: gitserver.v1.CreateCommitFromPatchBinaryRequest.Metadata.commit_info:type_name -> gitserver.v1.PatchCommitInfo + 40, // 64: gitserver.v1.CreateCommitFromPatchBinaryRequest.Metadata.push:type_name -> gitserver.v1.PushConfig + 111, // 65: gitserver.v1.CommitMatch.Signature.date:type_name -> google.protobuf.Timestamp + 109, // 66: gitserver.v1.CommitMatch.MatchedString.ranges:type_name -> gitserver.v1.CommitMatch.Range + 110, // 67: gitserver.v1.CommitMatch.Range.start:type_name -> gitserver.v1.CommitMatch.Location + 110, // 68: gitserver.v1.CommitMatch.Range.end:type_name -> gitserver.v1.CommitMatch.Location + 7, // 69: gitserver.v1.GitserverRepositoryService.DeleteRepository:input_type -> gitserver.v1.DeleteRepositoryRequest + 9, // 70: gitserver.v1.GitserverRepositoryService.FetchRepository:input_type -> gitserver.v1.FetchRepositoryRequest + 41, // 71: gitserver.v1.GitserverService.CreateCommitFromPatchBinary:input_type -> gitserver.v1.CreateCommitFromPatchBinaryRequest + 37, // 72: gitserver.v1.GitserverService.DiskInfo:input_type -> gitserver.v1.DiskInfoRequest + 44, // 73: gitserver.v1.GitserverService.Exec:input_type -> gitserver.v1.ExecRequest + 73, // 74: gitserver.v1.GitserverService.GetObject:input_type -> gitserver.v1.GetObjectRequest + 66, // 75: gitserver.v1.GitserverService.IsRepoCloneable:input_type -> gitserver.v1.IsRepoCloneableRequest + 70, // 76: gitserver.v1.GitserverService.ListGitolite:input_type -> gitserver.v1.ListGitoliteRequest + 50, // 77: gitserver.v1.GitserverService.Search:input_type -> gitserver.v1.SearchRequest + 64, // 78: gitserver.v1.GitserverService.Archive:input_type -> gitserver.v1.ArchiveRequest + 68, // 79: gitserver.v1.GitserverService.RepoCloneProgress:input_type -> gitserver.v1.RepoCloneProgressRequest + 76, // 80: gitserver.v1.GitserverService.IsPerforcePathCloneable:input_type -> gitserver.v1.IsPerforcePathCloneableRequest + 78, // 81: gitserver.v1.GitserverService.CheckPerforceCredentials:input_type -> gitserver.v1.CheckPerforceCredentialsRequest + 93, // 82: gitserver.v1.GitserverService.PerforceUsers:input_type -> gitserver.v1.PerforceUsersRequest + 88, // 83: gitserver.v1.GitserverService.PerforceProtectsForUser:input_type -> gitserver.v1.PerforceProtectsForUserRequest + 86, // 84: gitserver.v1.GitserverService.PerforceProtectsForDepot:input_type -> gitserver.v1.PerforceProtectsForDepotRequest + 91, // 85: gitserver.v1.GitserverService.PerforceGroupMembers:input_type -> gitserver.v1.PerforceGroupMembersRequest + 84, // 86: gitserver.v1.GitserverService.IsPerforceSuperUser:input_type -> gitserver.v1.IsPerforceSuperUserRequest + 81, // 87: gitserver.v1.GitserverService.PerforceGetChangelist:input_type -> gitserver.v1.PerforceGetChangelistRequest + 96, // 88: gitserver.v1.GitserverService.MergeBase:input_type -> gitserver.v1.MergeBaseRequest + 27, // 89: gitserver.v1.GitserverService.Blame:input_type -> gitserver.v1.BlameRequest + 33, // 90: gitserver.v1.GitserverService.DefaultBranch:input_type -> gitserver.v1.DefaultBranchRequest + 35, // 91: gitserver.v1.GitserverService.ReadFile:input_type -> gitserver.v1.ReadFileRequest + 23, // 92: gitserver.v1.GitserverService.GetCommit:input_type -> gitserver.v1.GetCommitRequest + 19, // 93: gitserver.v1.GitserverService.ResolveRevision:input_type -> gitserver.v1.ResolveRevisionRequest + 16, // 94: gitserver.v1.GitserverService.ListRefs:input_type -> gitserver.v1.ListRefsRequest + 21, // 95: gitserver.v1.GitserverService.RevAtTime:input_type -> gitserver.v1.RevAtTimeRequest + 14, // 96: gitserver.v1.GitserverService.RawDiff:input_type -> gitserver.v1.RawDiffRequest + 11, // 97: gitserver.v1.GitserverService.ContributorCounts:input_type -> gitserver.v1.ContributorCountsRequest + 98, // 98: gitserver.v1.GitserverService.FirstEverCommit:input_type -> gitserver.v1.FirstEverCommitRequest + 100, // 99: gitserver.v1.GitserverService.BehindAhead:input_type -> gitserver.v1.BehindAheadRequest + 102, // 100: gitserver.v1.GitserverService.ChangedFiles:input_type -> gitserver.v1.ChangedFilesRequest + 8, // 101: gitserver.v1.GitserverRepositoryService.DeleteRepository:output_type -> gitserver.v1.DeleteRepositoryResponse + 10, // 102: gitserver.v1.GitserverRepositoryService.FetchRepository:output_type -> gitserver.v1.FetchRepositoryResponse + 43, // 103: gitserver.v1.GitserverService.CreateCommitFromPatchBinary:output_type -> gitserver.v1.CreateCommitFromPatchBinaryResponse + 38, // 104: gitserver.v1.GitserverService.DiskInfo:output_type -> gitserver.v1.DiskInfoResponse + 45, // 105: gitserver.v1.GitserverService.Exec:output_type -> gitserver.v1.ExecResponse + 74, // 106: gitserver.v1.GitserverService.GetObject:output_type -> gitserver.v1.GetObjectResponse + 67, // 107: gitserver.v1.GitserverService.IsRepoCloneable:output_type -> gitserver.v1.IsRepoCloneableResponse + 72, // 108: gitserver.v1.GitserverService.ListGitolite:output_type -> gitserver.v1.ListGitoliteResponse + 62, // 109: gitserver.v1.GitserverService.Search:output_type -> gitserver.v1.SearchResponse + 65, // 110: gitserver.v1.GitserverService.Archive:output_type -> gitserver.v1.ArchiveResponse + 69, // 111: gitserver.v1.GitserverService.RepoCloneProgress:output_type -> gitserver.v1.RepoCloneProgressResponse + 77, // 112: gitserver.v1.GitserverService.IsPerforcePathCloneable:output_type -> gitserver.v1.IsPerforcePathCloneableResponse + 79, // 113: gitserver.v1.GitserverService.CheckPerforceCredentials:output_type -> gitserver.v1.CheckPerforceCredentialsResponse + 94, // 114: gitserver.v1.GitserverService.PerforceUsers:output_type -> gitserver.v1.PerforceUsersResponse + 89, // 115: gitserver.v1.GitserverService.PerforceProtectsForUser:output_type -> gitserver.v1.PerforceProtectsForUserResponse + 87, // 116: gitserver.v1.GitserverService.PerforceProtectsForDepot:output_type -> gitserver.v1.PerforceProtectsForDepotResponse + 92, // 117: gitserver.v1.GitserverService.PerforceGroupMembers:output_type -> gitserver.v1.PerforceGroupMembersResponse + 85, // 118: gitserver.v1.GitserverService.IsPerforceSuperUser:output_type -> gitserver.v1.IsPerforceSuperUserResponse + 82, // 119: gitserver.v1.GitserverService.PerforceGetChangelist:output_type -> gitserver.v1.PerforceGetChangelistResponse + 97, // 120: gitserver.v1.GitserverService.MergeBase:output_type -> gitserver.v1.MergeBaseResponse + 29, // 121: gitserver.v1.GitserverService.Blame:output_type -> gitserver.v1.BlameResponse + 34, // 122: gitserver.v1.GitserverService.DefaultBranch:output_type -> gitserver.v1.DefaultBranchResponse + 36, // 123: gitserver.v1.GitserverService.ReadFile:output_type -> gitserver.v1.ReadFileResponse + 24, // 124: gitserver.v1.GitserverService.GetCommit:output_type -> gitserver.v1.GetCommitResponse + 20, // 125: gitserver.v1.GitserverService.ResolveRevision:output_type -> gitserver.v1.ResolveRevisionResponse + 17, // 126: gitserver.v1.GitserverService.ListRefs:output_type -> gitserver.v1.ListRefsResponse + 22, // 127: gitserver.v1.GitserverService.RevAtTime:output_type -> gitserver.v1.RevAtTimeResponse + 15, // 128: gitserver.v1.GitserverService.RawDiff:output_type -> gitserver.v1.RawDiffResponse + 13, // 129: gitserver.v1.GitserverService.ContributorCounts:output_type -> gitserver.v1.ContributorCountsResponse + 99, // 130: gitserver.v1.GitserverService.FirstEverCommit:output_type -> gitserver.v1.FirstEverCommitResponse + 101, // 131: gitserver.v1.GitserverService.BehindAhead:output_type -> gitserver.v1.BehindAheadResponse + 103, // 132: gitserver.v1.GitserverService.ChangedFiles:output_type -> gitserver.v1.ChangedFilesResponse + 101, // [101:133] is the sub-list for method output_type + 69, // [69:101] is the sub-list for method input_type + 69, // [69:69] is the sub-list for extension type_name + 69, // [69:69] is the sub-list for extension extendee + 0, // [0:69] is the sub-list for field type_name } func init() { file_gitserver_proto_init() } @@ -9002,7 +9264,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[95].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CreateCommitFromPatchBinaryRequest_Metadata); i { + switch v := v.(*ChangedFilesRequest); i { case 0: return &v.state case 1: @@ -9014,7 +9276,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[96].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CreateCommitFromPatchBinaryRequest_Patch); i { + switch v := v.(*ChangedFilesResponse); i { case 0: return &v.state case 1: @@ -9026,7 +9288,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[97].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CommitMatch_Signature); i { + switch v := v.(*ChangedFile); i { case 0: return &v.state case 1: @@ -9038,7 +9300,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[98].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CommitMatch_MatchedString); i { + switch v := v.(*CreateCommitFromPatchBinaryRequest_Metadata); i { case 0: return &v.state case 1: @@ -9050,7 +9312,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[99].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CommitMatch_Range); i { + switch v := v.(*CreateCommitFromPatchBinaryRequest_Patch); i { case 0: return &v.state case 1: @@ -9062,6 +9324,42 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[100].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CommitMatch_Signature); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_gitserver_proto_msgTypes[101].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CommitMatch_MatchedString); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_gitserver_proto_msgTypes[102].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CommitMatch_Range); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_gitserver_proto_msgTypes[103].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CommitMatch_Location); i { case 0: return &v.state @@ -9098,13 +9396,14 @@ func file_gitserver_proto_init() { (*SearchResponse_LimitHit)(nil), } file_gitserver_proto_msgTypes[95].OneofWrappers = []interface{}{} + file_gitserver_proto_msgTypes[98].OneofWrappers = []interface{}{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_gitserver_proto_rawDesc, - NumEnums: 6, - NumMessages: 101, + NumEnums: 7, + NumMessages: 104, NumExtensions: 0, NumServices: 2, }, diff --git a/internal/gitserver/v1/gitserver.proto b/internal/gitserver/v1/gitserver.proto index 95308138bfa..6334caff85c 100644 --- a/internal/gitserver/v1/gitserver.proto +++ b/internal/gitserver/v1/gitserver.proto @@ -248,6 +248,20 @@ service GitserverService { rpc BehindAhead(BehindAheadRequest) returns (BehindAheadResponse) { option idempotency_level = NO_SIDE_EFFECTS; } + + // ChangedFiles returns the list of files that have been added, modified, or + // deleted in the entire repository between the two given identifiers (e.g., commit, branch, tag). + // + // - Renamed files are represented as a deletion of the old path and an addition of the new path. + // - No copy detection is performed. + // - The only file status codes returned are 'A' (added), 'M' (modified), or 'D' (deleted). + // + // If `base` is omitted, the parent of `head` is used as the base. + // + // If either the `base` or `head` id does not exist, an error with a `RevisionNotFoundPayload` is returned. + rpc ChangedFiles(ChangedFilesRequest) returns (stream ChangedFilesResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } } message ContributorCountsRequest { @@ -1084,3 +1098,32 @@ message BehindAheadResponse { // ahead is the number of commits that are solely reachable in "right" but not "left". uint32 ahead = 2; } + +message ChangedFilesRequest { + // repo_name is the name of the repo to get the changed files for. + // Note: We use field ID 2 here to reserve 1 for a future repo int32 field. + string repo_name = 2; + // base is a id, for now, we allow non-utf8 revspecs. + // + // If base is empty, the parent of the head is used. + optional bytes base = 3; + // head is a id, for now, we allow non-utf8 revspecs. + bytes head = 4; +} + +message ChangedFilesResponse { + repeated ChangedFile files = 1; +} + +message ChangedFile { + // path is the file path of the file that the status is for. + bytes path = 1; + // status is the status of the path. + enum Status { + STATUS_UNSPECIFIED = 0; + STATUS_ADDED = 1; + STATUS_MODIFIED = 2; + STATUS_DELETED = 3; + } + Status status = 2; +} diff --git a/internal/gitserver/v1/gitserver_grpc.pb.go b/internal/gitserver/v1/gitserver_grpc.pb.go index b922a22e066..0f3d248a8fd 100644 --- a/internal/gitserver/v1/gitserver_grpc.pb.go +++ b/internal/gitserver/v1/gitserver_grpc.pb.go @@ -184,6 +184,7 @@ const ( GitserverService_ContributorCounts_FullMethodName = "/gitserver.v1.GitserverService/ContributorCounts" GitserverService_FirstEverCommit_FullMethodName = "/gitserver.v1.GitserverService/FirstEverCommit" GitserverService_BehindAhead_FullMethodName = "/gitserver.v1.GitserverService/BehindAhead" + GitserverService_ChangedFiles_FullMethodName = "/gitserver.v1.GitserverService/ChangedFiles" ) // GitserverServiceClient is the client API for GitserverService service. @@ -340,6 +341,17 @@ type GitserverServiceClient interface { // If the given repo is not cloned, it will be enqueued for cloning and a // NotFound error will be returned, with a RepoNotFoundPayload in the details. BehindAhead(ctx context.Context, in *BehindAheadRequest, opts ...grpc.CallOption) (*BehindAheadResponse, error) + // ChangedFiles returns the list of files that have been added, modified, or + // deleted in the entire repository between the two given identifiers (e.g., commit, branch, tag). + // + // - Renamed files are represented as a deletion of the old path and an addition of the new path. + // - No copy detection is performed. + // - The only file status codes returned are 'A' (added), 'M' (modified), or 'D' (deleted). + // + // If `base` is omitted, the parent of `head` is used as the base. + // + // If either the `base` or `head` id does not exist, an error with a `RevisionNotFoundPayload` is returned. + ChangedFiles(ctx context.Context, in *ChangedFilesRequest, opts ...grpc.CallOption) (GitserverService_ChangedFilesClient, error) } type gitserverServiceClient struct { @@ -797,6 +809,38 @@ func (c *gitserverServiceClient) BehindAhead(ctx context.Context, in *BehindAhea return out, nil } +func (c *gitserverServiceClient) ChangedFiles(ctx context.Context, in *ChangedFilesRequest, opts ...grpc.CallOption) (GitserverService_ChangedFilesClient, error) { + stream, err := c.cc.NewStream(ctx, &GitserverService_ServiceDesc.Streams[8], GitserverService_ChangedFiles_FullMethodName, opts...) + if err != nil { + return nil, err + } + x := &gitserverServiceChangedFilesClient{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 GitserverService_ChangedFilesClient interface { + Recv() (*ChangedFilesResponse, error) + grpc.ClientStream +} + +type gitserverServiceChangedFilesClient struct { + grpc.ClientStream +} + +func (x *gitserverServiceChangedFilesClient) Recv() (*ChangedFilesResponse, error) { + m := new(ChangedFilesResponse) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + // GitserverServiceServer is the server API for GitserverService service. // All implementations must embed UnimplementedGitserverServiceServer // for forward compatibility @@ -951,6 +995,17 @@ type GitserverServiceServer interface { // If the given repo is not cloned, it will be enqueued for cloning and a // NotFound error will be returned, with a RepoNotFoundPayload in the details. BehindAhead(context.Context, *BehindAheadRequest) (*BehindAheadResponse, error) + // ChangedFiles returns the list of files that have been added, modified, or + // deleted in the entire repository between the two given identifiers (e.g., commit, branch, tag). + // + // - Renamed files are represented as a deletion of the old path and an addition of the new path. + // - No copy detection is performed. + // - The only file status codes returned are 'A' (added), 'M' (modified), or 'D' (deleted). + // + // If `base` is omitted, the parent of `head` is used as the base. + // + // If either the `base` or `head` id does not exist, an error with a `RevisionNotFoundPayload` is returned. + ChangedFiles(*ChangedFilesRequest, GitserverService_ChangedFilesServer) error mustEmbedUnimplementedGitserverServiceServer() } @@ -1045,6 +1100,9 @@ func (UnimplementedGitserverServiceServer) FirstEverCommit(context.Context, *Fir func (UnimplementedGitserverServiceServer) BehindAhead(context.Context, *BehindAheadRequest) (*BehindAheadResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method BehindAhead not implemented") } +func (UnimplementedGitserverServiceServer) ChangedFiles(*ChangedFilesRequest, GitserverService_ChangedFilesServer) error { + return status.Errorf(codes.Unimplemented, "method ChangedFiles not implemented") +} func (UnimplementedGitserverServiceServer) mustEmbedUnimplementedGitserverServiceServer() {} // UnsafeGitserverServiceServer may be embedded to opt out of forward compatibility for this service. @@ -1609,6 +1667,27 @@ func _GitserverService_BehindAhead_Handler(srv interface{}, ctx context.Context, return interceptor(ctx, in, info, handler) } +func _GitserverService_ChangedFiles_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(ChangedFilesRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(GitserverServiceServer).ChangedFiles(m, &gitserverServiceChangedFilesServer{stream}) +} + +type GitserverService_ChangedFilesServer interface { + Send(*ChangedFilesResponse) error + grpc.ServerStream +} + +type gitserverServiceChangedFilesServer struct { + grpc.ServerStream +} + +func (x *gitserverServiceChangedFilesServer) Send(m *ChangedFilesResponse) error { + return x.ServerStream.SendMsg(m) +} + // GitserverService_ServiceDesc is the grpc.ServiceDesc for GitserverService service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) @@ -1742,6 +1821,11 @@ var GitserverService_ServiceDesc = grpc.ServiceDesc{ Handler: _GitserverService_RawDiff_Handler, ServerStreams: true, }, + { + StreamName: "ChangedFiles", + Handler: _GitserverService_ChangedFiles_Handler, + ServerStreams: true, + }, }, Metadata: "gitserver.proto", } diff --git a/mockgen.temp.yaml b/mockgen.temp.yaml index 7d664edbf5f..ef884cc1e57 100644 --- a/mockgen.temp.yaml +++ b/mockgen.temp.yaml @@ -146,6 +146,8 @@ - GitserverService_ListRefsClient - GitserverService_RawDiffServer - GitserverService_RawDiffClient + - GitserverService_ChangedFilesServer + - GitserverService_ChangedFilesClient - filename: cmd/gitserver/internal/git/mock.go path: github.com/sourcegraph/sourcegraph/cmd/gitserver/internal/git interfaces: