From b3a07ae9c5ed69e3c4418807550abf95b2b2aa1e Mon Sep 17 00:00:00 2001 From: Erik Seliger Date: Sat, 11 May 2024 00:19:36 +0200 Subject: [PATCH] gitserver: Add CommitLog API to replace client-side Commits This PR moves the Commits API to the server side and is the last gRPC API to migrate. Test plan: Existing tests are still passing, moved the ~extensive unit test coverage this had on the client side to the server side. --- cmd/frontend/graphqlbackend/git_commits.go | 21 +- .../graphqlbackend/repository_contributors.go | 3 +- cmd/gitserver/internal/git/gitcli/BUILD.bazel | 2 + .../internal/git/gitcli/commitlog.go | 193 + .../internal/git/gitcli/commitlog_test.go | 376 ++ cmd/gitserver/internal/git/gitcli/odb.go | 14 +- cmd/gitserver/internal/git/gitcli/odb_test.go | 5 + cmd/gitserver/internal/git/iface.go | 54 + cmd/gitserver/internal/git/mock.go | 124 + cmd/gitserver/internal/git/observability.go | 57 + cmd/gitserver/internal/server_grpc.go | 126 + cmd/gitserver/internal/server_grpc_logger.go | 39 + internal/codeintel/policies/matcher.go | 4 +- .../codeintel/policies/matcher_common_test.go | 8 +- .../policies/matcher_retention_test.go | 2 +- .../background/commitgraph/job_commitgraph.go | 2 +- internal/gitserver/commands.go | 299 +- internal/gitserver/commands_test.go | 411 -- internal/gitserver/errwrap.go | 17 + internal/gitserver/gitdomain/BUILD.bazel | 4 + .../gitdomain/date.go} | 2 +- .../gitdomain/date_test.go} | 2 +- internal/gitserver/mock.go | 137 + internal/gitserver/retry.go | 5 + internal/gitserver/v1/gitserver.pb.go | 3829 +++++++++-------- internal/gitserver/v1/gitserver.proto | 67 + internal/gitserver/v1/gitserver_grpc.pb.go | 64 + internal/insights/gitserver/client.go | 2 +- .../own/background/recent_contributors.go | 2 +- internal/search/commit/commit.go | 4 +- internal/search/query/BUILD.bazel | 5 +- internal/search/query/predicate.go | 5 +- internal/search/query/validate.go | 3 +- internal/search/repos/repos.go | 9 +- 34 files changed, 3493 insertions(+), 2404 deletions(-) create mode 100644 cmd/gitserver/internal/git/gitcli/commitlog.go create mode 100644 cmd/gitserver/internal/git/gitcli/commitlog_test.go rename internal/{search/query/date_format.go => gitserver/gitdomain/date.go} (99%) rename internal/{search/query/date_format_test.go => gitserver/gitdomain/date_test.go} (99%) diff --git a/cmd/frontend/graphqlbackend/git_commits.go b/cmd/frontend/graphqlbackend/git_commits.go index 6e527f7c5ba8..845396b648db 100644 --- a/cmd/frontend/graphqlbackend/git_commits.go +++ b/cmd/frontend/graphqlbackend/git_commits.go @@ -5,6 +5,7 @@ import ( "context" "strconv" "sync" + "time" "github.com/sourcegraph/sourcegraph/cmd/frontend/graphqlbackend/graphqlutil" "github.com/sourcegraph/sourcegraph/internal/database" @@ -89,14 +90,30 @@ func (r *gitCommitConnectionResolver) compute(ctx context.Context) ([]*gitdomain return nil, errors.Wrap(err, "failed to resolve revision range") } + var before, after time.Time + + if r.after != nil { + after, err = gitdomain.ParseGitDate(*r.after, time.Now) + if err != nil { + return nil, errors.Wrap(err, "failed to parse after") + } + } + + if r.before != nil { + before, err = gitdomain.ParseGitDate(*r.before, time.Now) + if err != nil { + return nil, errors.Wrap(err, "failed to parse before") + } + } + return r.gitserverClient.Commits(ctx, r.repo.RepoName(), gitserver.CommitsOptions{ Ranges: []string{cmp.Or(r.revisionRange, "HEAD")}, N: uint(n), MessageQuery: pointers.DerefZero(r.query), Author: pointers.DerefZero(r.author), - After: pointers.DerefZero(r.after), + After: after, Skip: uint(afterCursor), - Before: pointers.DerefZero(r.before), + Before: before, Path: pointers.DerefZero(r.path), Follow: r.follow, }) diff --git a/cmd/frontend/graphqlbackend/repository_contributors.go b/cmd/frontend/graphqlbackend/repository_contributors.go index c6fe79cd5cb3..33e088596615 100644 --- a/cmd/frontend/graphqlbackend/repository_contributors.go +++ b/cmd/frontend/graphqlbackend/repository_contributors.go @@ -10,7 +10,6 @@ import ( "github.com/sourcegraph/sourcegraph/internal/database" "github.com/sourcegraph/sourcegraph/internal/gitserver" "github.com/sourcegraph/sourcegraph/internal/gitserver/gitdomain" - "github.com/sourcegraph/sourcegraph/internal/search/query" "github.com/sourcegraph/sourcegraph/lib/errors" ) @@ -27,7 +26,7 @@ func (r *RepositoryResolver) Contributors(args *struct { var after time.Time if args.AfterDate != nil && *args.AfterDate != "" { var err error - after, err = query.ParseGitDate(*args.AfterDate, time.Now) + after, err = gitdomain.ParseGitDate(*args.AfterDate, time.Now) if err != nil { return nil, errors.Wrap(err, "failed to parse after date") } diff --git a/cmd/gitserver/internal/git/gitcli/BUILD.bazel b/cmd/gitserver/internal/git/gitcli/BUILD.bazel index 999724d83b63..ed3800d37558 100644 --- a/cmd/gitserver/internal/git/gitcli/BUILD.bazel +++ b/cmd/gitserver/internal/git/gitcli/BUILD.bazel @@ -8,6 +8,7 @@ go_library( "blame.go", "clibackend.go", "command.go", + "commitlog.go", "commits.go", "config.go", "contributors.go", @@ -54,6 +55,7 @@ go_test( srcs = [ "archivereader_test.go", "blame_test.go", + "commitlog_test.go", "commits_test.go", "config_test.go", "contributors_test.go", diff --git a/cmd/gitserver/internal/git/gitcli/commitlog.go b/cmd/gitserver/internal/git/gitcli/commitlog.go new file mode 100644 index 000000000000..f66086fc1ad4 --- /dev/null +++ b/cmd/gitserver/internal/git/gitcli/commitlog.go @@ -0,0 +1,193 @@ +package gitcli + +import ( + "bufio" + "bytes" + "context" + "io" + "strconv" + "time" + + "github.com/sourcegraph/sourcegraph/cmd/gitserver/internal/git" + "github.com/sourcegraph/sourcegraph/internal/api" + "github.com/sourcegraph/sourcegraph/internal/gitserver/gitdomain" + "github.com/sourcegraph/sourcegraph/lib/errors" +) + +func (g *gitCLIBackend) CommitLog(ctx context.Context, opt git.CommitLogOpts) (git.CommitLogIterator, error) { + for _, r := range opt.Ranges { + if err := checkSpecArgSafety(r); err != nil { + return nil, err + } + } + + if len(opt.Ranges) > 0 && opt.AllRefs { + return nil, errors.New("cannot specify both a Range and AllRefs") + } + if len(opt.Ranges) == 0 && !opt.AllRefs { + return nil, errors.New("must specify a Range or AllRefs") + } + + args, err := buildCommitLogArgs(opt) + if err != nil { + return nil, err + } + + r, err := g.NewCommand(ctx, WithArguments(args...)) + if err != nil { + return nil, err + } + + return newCommitLogIterator(g.repoName, r), nil +} + +func buildCommitLogArgs(opt git.CommitLogOpts) ([]string, error) { + args := []string{"log", logFormatWithoutRefs} + + if opt.MaxCommits != 0 { + args = append(args, "-n", strconv.FormatUint(uint64(opt.MaxCommits), 10)) + } + if opt.Skip != 0 { + args = append(args, "--skip="+strconv.FormatUint(uint64(opt.Skip), 10)) + } + + if opt.AuthorQuery != "" { + args = append(args, "--fixed-strings", "--author="+opt.AuthorQuery) + } + + if !opt.After.IsZero() { + args = append(args, "--after="+opt.After.Format(time.RFC3339)) + } + if !opt.Before.IsZero() { + args = append(args, "--before="+opt.Before.Format(time.RFC3339)) + } + switch opt.Order { + case git.CommitLogOrderCommitDate: + args = append(args, "--date-order") + case git.CommitLogOrderTopoDate: + args = append(args, "--topo-order") + case git.CommitLogOrderDefault: + // nothing to do + default: + return nil, errors.Newf("invalid ordering %d", opt.Order) + } + + if opt.MessageQuery != "" { + args = append(args, "--fixed-strings", "--regexp-ignore-case", "--grep="+opt.MessageQuery) + } + + if opt.FollowOnlyFirstParent { + args = append(args, "--first-parent") + } + + args = append(args, opt.Ranges...) + if opt.AllRefs { + args = append(args, "--all") + } + + if opt.IncludeModifiedFiles { + args = append(args, "--name-only") + } + if opt.FollowPathRenames { + args = append(args, "--follow") + } + if opt.Path != "" { + args = append(args, "--", opt.Path) + } + + return args, nil +} + +func newCommitLogIterator(repoName api.RepoName, r io.ReadCloser) *commitLogIterator { + commitScanner := bufio.NewScanner(r) + // We use an increased buffer size since sub-repo permissions + // can result in very lengthy output. + commitScanner.Buffer(make([]byte, 0, 65536), 4294967296) + commitScanner.Split(commitSplitFunc) + + return &commitLogIterator{ + Closer: r, + repoName: repoName, + sc: commitScanner, + } +} + +type commitLogIterator struct { + io.Closer + repoName api.RepoName + sc *bufio.Scanner +} + +func (it *commitLogIterator) Next() (*git.GitCommitWithFiles, error) { + if !it.sc.Scan() { + if err := it.sc.Err(); err != nil { + // If exit code is 128 and `fatal: bad object` is part of stderr, most likely we + // are referencing a commit that does not exist. + // We want to return a gitdomain.RevisionNotFoundError in that case. + var e *CommandFailedError + if errors.As(err, &e) && e.ExitStatus == 128 { + if bytes.Contains(e.Stderr, []byte("not a tree object")) || bytes.Contains(e.Stderr, []byte("fatal: bad object")) { + return nil, &gitdomain.RevisionNotFoundError{Repo: it.repoName, Spec: "TODO"} // string(opt.Range)} + } + if bytes.Contains(e.Stderr, []byte("fatal: ambiguous argument")) && bytes.Contains(e.Stderr, []byte("unknown revision or path not in the working tree.")) { + return nil, &gitdomain.RevisionNotFoundError{Repo: it.repoName, Spec: "TODO"} // string(opt.Range)} + } + if bytes.Contains(e.Stderr, []byte("fatal: your current branch")) && bytes.Contains(e.Stderr, []byte("does not have any commits yet")) { + return nil, io.EOF + } + } + return nil, err + } + return nil, io.EOF + } + + rawCommit := it.sc.Bytes() + commit, err := parseCommitFromLog(rawCommit) + if err != nil { + return nil, err + } + return commit, nil +} + +func (it *commitLogIterator) Close() error { + err := it.Closer.Close() + if err != nil { + var e *CommandFailedError + if errors.As(err, &e) && e.ExitStatus == 128 { + if bytes.Contains(e.Stderr, []byte("not a tree object")) || bytes.Contains(e.Stderr, []byte("fatal: bad object")) { + return &gitdomain.RevisionNotFoundError{Repo: it.repoName, Spec: "TODO"} // string(opt.Range)} + } + if bytes.Contains(e.Stderr, []byte("fatal: your current branch")) && bytes.Contains(e.Stderr, []byte("does not have any commits yet")) { + return nil + } + } + } + return err +} + +func commitSplitFunc(data []byte, atEOF bool) (advance int, token []byte, err error) { + if len(data) == 0 { + // Request more data + return 0, nil, nil + } + + // Safety check: ensure we are always starting with a record separator + if data[0] != '\x1e' { + return 0, nil, errors.New("internal error: data should always start with an ASCII record separator") + } + + loc := bytes.IndexByte(data[1:], '\x1e') + if loc < 0 { + // We can't find the start of the next record + if atEOF { + // If we're at the end of the stream, just return the rest as the last record + return len(data), data[1:], bufio.ErrFinalToken + } else { + // If we're not at the end of the stream, request more data + return 0, nil, nil + } + } + nextStart := loc + 1 // correct for searching at an offset + + return nextStart, data[1:nextStart], nil +} diff --git a/cmd/gitserver/internal/git/gitcli/commitlog_test.go b/cmd/gitserver/internal/git/gitcli/commitlog_test.go new file mode 100644 index 000000000000..e2c0bf68ef9f --- /dev/null +++ b/cmd/gitserver/internal/git/gitcli/commitlog_test.go @@ -0,0 +1,376 @@ +package gitcli + +import ( + "context" + "fmt" + "io" + "testing" + "time" + + "github.com/stretchr/testify/require" + + "github.com/sourcegraph/sourcegraph/cmd/gitserver/internal/git" + "github.com/sourcegraph/sourcegraph/internal/api" + "github.com/sourcegraph/sourcegraph/internal/gitserver/gitdomain" + "github.com/sourcegraph/sourcegraph/lib/errors" +) + +func TestGitCLIBackend_CommitLog(t *testing.T) { + // TODO: + // Add tests for: + // - AllRefs + // - FollowOnlyFirstParent + // - Order + // - FollowPathRenames + + ctx := context.Background() + + // Prepare repo state: + backend := BackendWithRepoCommands(t, + "echo Hello > f", + "git add f", + "GIT_COMMITTER_NAME=c GIT_COMMITTER_EMAIL=c@c.com GIT_COMMITTER_DATE=2006-01-02T15:04:05Z git commit -m foo --author='Foo Author ' --date 2006-01-02T15:04:05Z", + "git tag testbase", + "echo World > f2", + "git add f2", + "GIT_COMMITTER_NAME=c GIT_COMMITTER_EMAIL=c@c.com GIT_COMMITTER_DATE=2006-01-02T15:04:07Z git commit -m bar --author='Bar Author ' --date 2006-01-02T15:04:06Z", + ) + + allGitCommits := []*git.GitCommitWithFiles{ + { + Commit: &gitdomain.Commit{ + ID: "2b2289762392764ed127587b0d5fd88a2f16b7c1", + Author: gitdomain.Signature{Name: "Bar Author", Email: "bar@sourcegraph.com", Date: mustParseTime(time.RFC3339, "2006-01-02T15:04:06Z")}, + Committer: &gitdomain.Signature{Name: "c", Email: "c@c.com", Date: mustParseTime(time.RFC3339, "2006-01-02T15:04:07Z")}, + Message: "bar", + Parents: []api.CommitID{"5fab3adc1e398e749749271d14ab843759b192cf"}, + }, + }, + { + Commit: &gitdomain.Commit{ + ID: "5fab3adc1e398e749749271d14ab843759b192cf", + Author: gitdomain.Signature{Name: "Foo Author", Email: "foo@sourcegraph.com", Date: mustParseTime(time.RFC3339, "2006-01-02T15:04:05Z")}, + Committer: &gitdomain.Signature{Name: "c", Email: "c@c.com", Date: mustParseTime(time.RFC3339, "2006-01-02T15:04:05Z")}, + Message: "foo", + Parents: nil, + }, + }, + } + + readCommitIterator := func(t *testing.T, it git.CommitLogIterator) []*git.GitCommitWithFiles { + cs := []*git.GitCommitWithFiles{} + for { + c, err := it.Next() + if err != nil { + if errors.Is(err, io.EOF) { + break + } + require.NoError(t, err) + } + cs = append(cs, c) + } + return cs + } + + t.Run("empty repo", func(t *testing.T) { + backend := BackendWithRepoCommands(t) + it, err := backend.CommitLog(ctx, git.CommitLogOpts{ + MaxCommits: 2, + Ranges: []string{"HEAD"}, + }) + require.NoError(t, err) + _, err = it.Next() + require.Error(t, err) + require.True(t, errors.Is(err, io.EOF)) + require.NoError(t, it.Close()) + }) + + t.Run("commit doesn't exist", func(t *testing.T) { + backend := BackendWithRepoCommands(t) + it, err := backend.CommitLog(ctx, git.CommitLogOpts{ + MaxCommits: 1, + Ranges: []string{"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"}, + }) + require.NoError(t, err) + _, err = it.Next() + require.True(t, errors.HasType(err, &gitdomain.RevisionNotFoundError{})) + _ = it.Close() + }) + + t.Run("log commits including root", func(t *testing.T) { + it, err := backend.CommitLog(ctx, git.CommitLogOpts{ + Ranges: []string{"HEAD"}, + }) + require.NoError(t, err) + + got := readCommitIterator(t, it) + require.NoError(t, it.Close()) + + require.Equal(t, allGitCommits, got) + + t.Run("commit range", func(t *testing.T) { + it, err := backend.CommitLog(ctx, git.CommitLogOpts{ + Ranges: []string{"HEAD^...HEAD"}, + }) + require.NoError(t, err) + + got := readCommitIterator(t, it) + require.NoError(t, it.Close()) + + require.Equal(t, allGitCommits[:1], got) + }) + + t.Run("MaxCommits", func(t *testing.T) { + it, err := backend.CommitLog(ctx, git.CommitLogOpts{ + Ranges: []string{"HEAD"}, + MaxCommits: 1, + }) + require.NoError(t, err) + got := readCommitIterator(t, it) + require.NoError(t, it.Close()) + require.Equal(t, allGitCommits[:1], got) + }) + t.Run("Skip", func(t *testing.T) { + it, err := backend.CommitLog(ctx, git.CommitLogOpts{ + Ranges: []string{"HEAD"}, + Skip: 1, + }) + require.NoError(t, err) + got := readCommitIterator(t, it) + require.NoError(t, it.Close()) + require.Equal(t, allGitCommits[1:], got) + + it, err = backend.CommitLog(ctx, git.CommitLogOpts{ + Ranges: []string{"HEAD"}, + Skip: 2, + }) + require.NoError(t, err) + got = readCommitIterator(t, it) + require.NoError(t, it.Close()) + require.Equal(t, []*git.GitCommitWithFiles{}, got) + }) + }) + t.Run("before", func(t *testing.T) { + it, err := backend.CommitLog(ctx, git.CommitLogOpts{ + Ranges: []string{"HEAD"}, + Before: mustParseTime(time.RFC3339, "2006-01-02T15:04:06Z"), + }) + require.NoError(t, err) + got := readCommitIterator(t, it) + require.NoError(t, it.Close()) + require.Equal(t, allGitCommits[1:], got) + }) + t.Run("after", func(t *testing.T) { + testCases := []struct { + label string + commitDates []string + after string + revspec string + want bool + }{ + { + label: "after specific date", + commitDates: []string{ + "2006-01-02T15:04:05Z", + "2007-01-02T15:04:05Z", + "2008-01-02T15:04:05Z", + }, + after: "2006-01-02T15:04:05Z", + revspec: "master", + want: true, + }, + { + label: "after 1 year ago", + commitDates: []string{ + "2016-01-02T15:04:05Z", + "2017-01-02T15:04:05Z", + "2017-01-02T15:04:06Z", + }, + after: "1 year ago", + revspec: "master", + want: false, + }, + { + label: "after too recent date", + commitDates: []string{ + "2006-01-02T15:04:05Z", + "2007-01-02T15:04:05Z", + "2008-01-02T15:04:05Z", + }, + after: "2010-01-02T15:04:05Z", + revspec: "HEAD", + want: false, + }, + { + label: "commit 1 second after", + commitDates: []string{ + "2006-01-02T15:04:05Z", + "2007-01-02T15:04:05Z", + "2007-01-02T15:04:06Z", + }, + after: "2007-01-02T15:04:05Z", + revspec: "HEAD", + want: true, + }, + { + label: "after 10 years ago", + commitDates: []string{ + "2016-01-02T15:04:05Z", + "2017-01-02T15:04:05Z", + "2017-01-02T15:04:06Z", + }, + after: "10 years ago", + revspec: "HEAD", + want: true, + }, + } + + for _, tc := range testCases { + t.Run(tc.label, func(t *testing.T) { + gitCommands := make([]string, len(tc.commitDates)) + for i, date := range tc.commitDates { + gitCommands[i] = fmt.Sprintf("GIT_COMMITTER_NAME=a GIT_COMMITTER_EMAIL=a@a.com GIT_COMMITTER_DATE=%s git commit --allow-empty -m foo --author='a '", date) + } + backend := BackendWithRepoCommands(t, + gitCommands..., + ) + after, err := gitdomain.ParseGitDate(tc.after, time.Now) + require.NoError(t, err) + it, err := backend.CommitLog(ctx, git.CommitLogOpts{ + MaxCommits: 2, + Ranges: []string{tc.revspec}, + After: after, + }) + require.NoError(t, err) + + got := readCommitIterator(t, it) + + require.True(t, len(got) > 0 == tc.want) + }) + } + }) + t.Run("include modified files", func(t *testing.T) { + it, err := backend.CommitLog(ctx, git.CommitLogOpts{ + Ranges: []string{"HEAD"}, + IncludeModifiedFiles: true, + }) + require.NoError(t, err) + + got := readCommitIterator(t, it) + require.NoError(t, it.Close()) + + want := []*git.GitCommitWithFiles{ + { + Commit: allGitCommits[0].Commit, + ModifiedFiles: []string{"f2"}, + }, + { + Commit: allGitCommits[1].Commit, + ModifiedFiles: []string{"f"}, + }, + } + + require.Equal(t, want, got) + }) + t.Run("for path", func(t *testing.T) { + it, err := backend.CommitLog(ctx, git.CommitLogOpts{ + Ranges: []string{"HEAD"}, + Path: "f", + }) + require.NoError(t, err) + + got := readCommitIterator(t, it) + require.NoError(t, it.Close()) + + require.Equal(t, allGitCommits[1:], got) + t.Run("unknownpath", func(t *testing.T) { + it, err := backend.CommitLog(ctx, git.CommitLogOpts{ + Ranges: []string{"HEAD"}, + Path: "notfound", + }) + require.NoError(t, err) + + got := readCommitIterator(t, it) + require.NoError(t, it.Close()) + + require.Empty(t, got) + }) + t.Run("non-utf-8", func(t *testing.T) { + it, err := backend.CommitLog(ctx, git.CommitLogOpts{ + Ranges: []string{"HEAD"}, + Path: "a\xc0rn", + }) + require.NoError(t, err) + + got := readCommitIterator(t, it) + require.NoError(t, it.Close()) + + require.Empty(t, got) + }) + }) + t.Run("message query", func(t *testing.T) { + it, err := backend.CommitLog(ctx, git.CommitLogOpts{ + Ranges: []string{"HEAD"}, + MessageQuery: "foo", + }) + require.NoError(t, err) + + got := readCommitIterator(t, it) + require.NoError(t, it.Close()) + + require.Equal(t, allGitCommits[1:], got) + }) + t.Run("author query", func(t *testing.T) { + it, err := backend.CommitLog(ctx, git.CommitLogOpts{ + Ranges: []string{"HEAD"}, + AuthorQuery: "Foo Author", + }) + require.NoError(t, err) + + got := readCommitIterator(t, it) + require.NoError(t, it.Close()) + + require.Equal(t, allGitCommits[1:], got) + }) + t.Run("not found range", func(t *testing.T) { + // Prepare repo state: + backend := BackendWithRepoCommands(t, + "echo line1 > f", + "git add f", + "git commit -m foo --author='Foo Author '", + "git tag test", + ) + + it, err := backend.CommitLog(ctx, git.CommitLogOpts{ + Ranges: []string{"test", "HEAD", "not found"}, + }) + require.NoError(t, err) + _, err = it.Next() + require.True(t, errors.HasType(err, &gitdomain.RevisionNotFoundError{})) + + // Verify ordering doesn't matter and we return an error for any missing range: + it, err = backend.CommitLog(ctx, git.CommitLogOpts{ + Ranges: []string{"not found", "test", "HEAD"}, + }) + require.NoError(t, err) + _, err = it.Next() + require.Error(t, err) + require.True(t, errors.HasType(err, &gitdomain.RevisionNotFoundError{})) + }) + // Verify that if the context is canceled, the iterator returns an error. + t.Run("context cancelation", func(t *testing.T) { + ctx, cancel := context.WithCancel(ctx) + t.Cleanup(cancel) + + it, err := backend.CommitLog(ctx, git.CommitLogOpts{AllRefs: true}) + require.NoError(t, err) + + cancel() + + _, err = it.Next() + require.Error(t, err) + require.True(t, errors.Is(err, context.Canceled), "unexpected error: %v", err) + + require.True(t, errors.Is(it.Close(), context.Canceled), "unexpected error: %v", err) + }) +} diff --git a/cmd/gitserver/internal/git/gitcli/odb.go b/cmd/gitserver/internal/git/gitcli/odb.go index ee08920cc21f..0c1bc33a31ef 100644 --- a/cmd/gitserver/internal/git/gitcli/odb.go +++ b/cmd/gitserver/internal/git/gitcli/odb.go @@ -50,7 +50,7 @@ func (g *gitCLIBackend) GetCommit(ctx context.Context, commit api.CommitID, incl return nil, err } - c, err := parseCommitLogOutput(bytes.TrimPrefix(rawCommit, []byte{'\x1e'})) + c, err := parseCommitFromLog(bytes.TrimPrefix(rawCommit, []byte{'\x1e'})) if err != nil { return nil, errors.Wrap(err, "failed to parse commit log output") } @@ -88,19 +88,15 @@ const ( logFormatWithoutRefs = "--format=format:%x1e%H%x00%aN%x00%aE%x00%at%x00%cN%x00%cE%x00%ct%x00%B%x00%P%x00" ) -func parseCommitLogOutput(rawCommit []byte) (*git.GitCommitWithFiles, error) { +// parseCommitFromLog parses the next commit from data and returns the commit and the remaining +// data. The data arg is a byte array that contains NUL-separated log fields as formatted by +// logFormatFlag. +func parseCommitFromLog(rawCommit []byte) (*git.GitCommitWithFiles, error) { parts := bytes.Split(rawCommit, []byte{'\x00'}) if len(parts) != partsPerCommit { return nil, errors.Newf("internal error: expected %d parts, got %d", partsPerCommit, len(parts)) } - return parseCommitFromLog(parts) -} - -// parseCommitFromLog parses the next commit from data and returns the commit and the remaining -// data. The data arg is a byte array that contains NUL-separated log fields as formatted by -// logFormatFlag. -func parseCommitFromLog(parts [][]byte) (*git.GitCommitWithFiles, error) { // log outputs are newline separated, so all but the 1st commit ID part // has an erroneous leading newline. parts[0] = bytes.TrimPrefix(parts[0], []byte{'\n'}) diff --git a/cmd/gitserver/internal/git/gitcli/odb_test.go b/cmd/gitserver/internal/git/gitcli/odb_test.go index b4df9d6f73a7..e786abe56941 100644 --- a/cmd/gitserver/internal/git/gitcli/odb_test.go +++ b/cmd/gitserver/internal/git/gitcli/odb_test.go @@ -8,6 +8,7 @@ import ( "os" "path/filepath" "runtime" + "strings" "testing" "time" @@ -823,3 +824,7 @@ func TestGitCLIBackend_ReadDir(t *testing.T) { require.True(t, fis[3].IsDir()) }) } + +func TestLogPartsPerCommitInSync(t *testing.T) { + require.Equal(t, partsPerCommit-1, strings.Count(logFormatWithoutRefs, "%x00")) +} diff --git a/cmd/gitserver/internal/git/iface.go b/cmd/gitserver/internal/git/iface.go index e31acf71e412..a80da29d2af3 100644 --- a/cmd/gitserver/internal/git/iface.go +++ b/cmd/gitserver/internal/git/iface.go @@ -111,6 +111,9 @@ type GitBackend interface { // The caller must call Close on the returned ReadDirIterator when done. ReadDir(ctx context.Context, commit api.CommitID, path string, recursive bool) (ReadDirIterator, error) + // CommitLog returns a list of commits in the given boundaries specified by opt. + CommitLog(ctx context.Context, opt CommitLogOpts) (CommitLogIterator, error) + // Exec is a temporary helper to run arbitrary git commands from the exec endpoint. // No new usages of it should be introduced and once the migration is done we will // remove this method. @@ -163,6 +166,57 @@ type GitBackend interface { RefHash(ctx context.Context) ([]byte, error) } +type CommitLogOrder int + +const ( + CommitLogOrderDefault CommitLogOrder = iota + CommitLogOrderCommitDate + CommitLogOrderTopoDate +) + +type CommitLogOpts struct { + Ranges []string + AllRefs bool + After time.Time + Before time.Time + // MaxCommits is an optional parameter to specify the maximum number of commits + // to return. If max_commits is 0, all commits that match the criteria will be + // returned. + MaxCommits uint32 + // Skip is an optional parameter to specify the number of commits to skip. + // This can be used to implement a poor mans pagination. + // TODO: We want to switch to more proper gRPC pagination here later. + Skip uint32 + // When finding commits to include, follow only the first parent commit upon + // seeing a merge commit. This option can give a better overview when viewing + // the evolution of a particular topic branch, because merges into a topic + // branch tend to be only about adjusting to updated upstream from time to time, + // and this option allows you to ignore the individual commits brought in to + // your history by such a merge. + FollowOnlyFirstParent bool + // If true, the modified_files field in the GetCommitResponse will be + // populated. + IncludeModifiedFiles bool + Order CommitLogOrder + // Include only commits whose commit message contains this substring. + MessageQuery string + // include only commits whose author matches this. + AuthorQuery string + // include only commits that touch this file path. + Path string + // Follow the history of the path beyond renames, only effective when used with + // `path`. + FollowPathRenames bool +} + +// CommitLogIterator iterates over commits. +type CommitLogIterator interface { + // Next returns the next commit and the files it modifies, if requested. + Next() (*GitCommitWithFiles, error) + // Close releases resources associated with the iterator. + Close() error +} + type GitDiffComparisonType int const ( diff --git a/cmd/gitserver/internal/git/mock.go b/cmd/gitserver/internal/git/mock.go index 071dfbf73a6b..f7761f72899c 100644 --- a/cmd/gitserver/internal/git/mock.go +++ b/cmd/gitserver/internal/git/mock.go @@ -297,6 +297,9 @@ type MockGitBackend struct { // ChangedFilesFunc is an instance of a mock function object controlling // the behavior of the method ChangedFiles. ChangedFilesFunc *GitBackendChangedFilesFunc + // CommitLogFunc is an instance of a mock function object controlling + // the behavior of the method CommitLog. + CommitLogFunc *GitBackendCommitLogFunc // ConfigFunc is an instance of a mock function object controlling the // behavior of the method Config. ConfigFunc *GitBackendConfigFunc @@ -377,6 +380,11 @@ func NewMockGitBackend() *MockGitBackend { return }, }, + CommitLogFunc: &GitBackendCommitLogFunc{ + defaultHook: func(context.Context, CommitLogOpts) (r0 CommitLogIterator, r1 error) { + return + }, + }, ConfigFunc: &GitBackendConfigFunc{ defaultHook: func() (r0 GitConfigBackend) { return @@ -494,6 +502,11 @@ func NewStrictMockGitBackend() *MockGitBackend { panic("unexpected invocation of MockGitBackend.ChangedFiles") }, }, + CommitLogFunc: &GitBackendCommitLogFunc{ + defaultHook: func(context.Context, CommitLogOpts) (CommitLogIterator, error) { + panic("unexpected invocation of MockGitBackend.CommitLog") + }, + }, ConfigFunc: &GitBackendConfigFunc{ defaultHook: func() GitConfigBackend { panic("unexpected invocation of MockGitBackend.Config") @@ -603,6 +616,9 @@ func NewMockGitBackendFrom(i GitBackend) *MockGitBackend { ChangedFilesFunc: &GitBackendChangedFilesFunc{ defaultHook: i.ChangedFiles, }, + CommitLogFunc: &GitBackendCommitLogFunc{ + defaultHook: i.CommitLog, + }, ConfigFunc: &GitBackendConfigFunc{ defaultHook: i.Config, }, @@ -1109,6 +1125,114 @@ func (c GitBackendChangedFilesFuncCall) Results() []interface{} { return []interface{}{c.Result0, c.Result1} } +// GitBackendCommitLogFunc describes the behavior when the CommitLog method +// of the parent MockGitBackend instance is invoked. +type GitBackendCommitLogFunc struct { + defaultHook func(context.Context, CommitLogOpts) (CommitLogIterator, error) + hooks []func(context.Context, CommitLogOpts) (CommitLogIterator, error) + history []GitBackendCommitLogFuncCall + mutex sync.Mutex +} + +// CommitLog delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockGitBackend) CommitLog(v0 context.Context, v1 CommitLogOpts) (CommitLogIterator, error) { + r0, r1 := m.CommitLogFunc.nextHook()(v0, v1) + m.CommitLogFunc.appendCall(GitBackendCommitLogFuncCall{v0, v1, r0, r1}) + return r0, r1 +} + +// SetDefaultHook sets function that is called when the CommitLog method of +// the parent MockGitBackend instance is invoked and the hook queue is +// empty. +func (f *GitBackendCommitLogFunc) SetDefaultHook(hook func(context.Context, CommitLogOpts) (CommitLogIterator, error)) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// CommitLog method of the parent MockGitBackend 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 *GitBackendCommitLogFunc) PushHook(hook func(context.Context, CommitLogOpts) (CommitLogIterator, 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 *GitBackendCommitLogFunc) SetDefaultReturn(r0 CommitLogIterator, r1 error) { + f.SetDefaultHook(func(context.Context, CommitLogOpts) (CommitLogIterator, error) { + return r0, r1 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *GitBackendCommitLogFunc) PushReturn(r0 CommitLogIterator, r1 error) { + f.PushHook(func(context.Context, CommitLogOpts) (CommitLogIterator, error) { + return r0, r1 + }) +} + +func (f *GitBackendCommitLogFunc) nextHook() func(context.Context, CommitLogOpts) (CommitLogIterator, 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 *GitBackendCommitLogFunc) appendCall(r0 GitBackendCommitLogFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of GitBackendCommitLogFuncCall objects +// describing the invocations of this function. +func (f *GitBackendCommitLogFunc) History() []GitBackendCommitLogFuncCall { + f.mutex.Lock() + history := make([]GitBackendCommitLogFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// GitBackendCommitLogFuncCall is an object that describes an invocation of +// method CommitLog on an instance of MockGitBackend. +type GitBackendCommitLogFuncCall 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 CommitLogOpts + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 CommitLogIterator + // 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 GitBackendCommitLogFuncCall) Args() []interface{} { + return []interface{}{c.Arg0, c.Arg1} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c GitBackendCommitLogFuncCall) Results() []interface{} { + return []interface{}{c.Result0, c.Result1} +} + // GitBackendConfigFunc describes the behavior when the Config method of the // parent MockGitBackend instance is invoked. type GitBackendConfigFunc struct { diff --git a/cmd/gitserver/internal/git/observability.go b/cmd/gitserver/internal/git/observability.go index f16581115c02..b12149232d99 100644 --- a/cmd/gitserver/internal/git/observability.go +++ b/cmd/gitserver/internal/git/observability.go @@ -480,6 +480,61 @@ func (b *observableBackend) RefHash(ctx context.Context) (_ []byte, err error) { return b.backend.RefHash(ctx) } +func (b *observableBackend) CommitLog(ctx context.Context, opt CommitLogOpts) (_ CommitLogIterator, err error) { + ctx, errCollector, endObservation := b.operations.commitLog.WithErrors(ctx, &err, observation.Args{ + Attrs: []attribute.KeyValue{ + attribute.StringSlice("ranges", opt.Ranges), + attribute.Bool("allRefs", opt.AllRefs), + attribute.Stringer("after", opt.After), + attribute.Stringer("before", opt.Before), + attribute.Int("maxCommits", int(opt.MaxCommits)), + attribute.Int("skip", int(opt.Skip)), + attribute.Bool("followOnlyFirstParent", opt.FollowOnlyFirstParent), + attribute.Bool("includeModifiedFiles", opt.IncludeModifiedFiles), + attribute.Int("order", int(opt.Order)), + attribute.String("messageQuery", opt.MessageQuery), + attribute.String("authorQuery", opt.AuthorQuery), + attribute.Bool("followPathRenames", opt.FollowPathRenames), + attribute.String("path", opt.Path), + }, + }) + ctx, cancel := context.WithCancel(ctx) + endObservation.OnCancel(ctx, 1, observation.Args{}) + + concurrentOps.WithLabelValues("CommitLog").Inc() + + it, err := b.backend.CommitLog(ctx, opt) + if err != nil { + concurrentOps.WithLabelValues("CommitLog").Dec() + cancel() + return nil, err + } + + return &observableCommitLogIterator{ + inner: it, + onClose: func(err error) { + concurrentOps.WithLabelValues("CommitLog").Dec() + errCollector.Collect(&err) + cancel() + }, + }, nil +} + +type observableCommitLogIterator struct { + inner CommitLogIterator + onClose func(err error) +} + +func (hr *observableCommitLogIterator) Next() (*GitCommitWithFiles, error) { + return hr.inner.Next() +} + +func (hr *observableCommitLogIterator) Close() error { + err := hr.inner.Close() + hr.onClose(err) + return err +} + type operations struct { configGet *observation.Operation configSet *observation.Operation @@ -505,6 +560,7 @@ type operations struct { readDir *observation.Operation latestCommitTimestamp *observation.Operation refHash *observation.Operation + commitLog *observation.Operation } func newOperations(observationCtx *observation.Context) *operations { @@ -557,6 +613,7 @@ func newOperations(observationCtx *observation.Context) *operations { readDir: op("read-dir"), latestCommitTimestamp: op("latest-commit-timestamp"), refHash: op("ref-hash"), + commitLog: op("commit-log"), } } diff --git a/cmd/gitserver/internal/server_grpc.go b/cmd/gitserver/internal/server_grpc.go index cd7743e77699..80d9d41d4207 100644 --- a/cmd/gitserver/internal/server_grpc.go +++ b/cmd/gitserver/internal/server_grpc.go @@ -1707,6 +1707,132 @@ func (gs *grpcServer) ReadDir(req *proto.ReadDirRequest, ss proto.GitserverServi return nil } +func (gs *grpcServer) CommitLog(req *proto.CommitLogRequest, ss proto.GitserverService_CommitLogServer) (err error) { + ctx := ss.Context() + + accesslog.Record( + ctx, + req.GetRepoName(), + log.Strings("ranges", byteSlicesToStrings(req.GetRanges())), + log.String("path", string(req.GetPath())), + ) + + if req.GetRepoName() == "" { + return status.New(codes.InvalidArgument, "repo must be specified").Err() + } + + if len(req.GetRanges()) == 0 && !req.GetAllRefs() { + return status.New(codes.InvalidArgument, "must specify ranges or all_refs").Err() + } + + if len(req.GetRanges()) > 0 && req.GetAllRefs() { + return status.New(codes.InvalidArgument, "cannot specify both ranges and all_refs").Err() + } + + repoName := api.RepoName(req.GetRepoName()) + repoDir := gs.fs.RepoDir(repoName) + + if err := gs.checkRepoExists(ctx, repoName); err != nil { + return err + } + + backend := gs.gitBackendSource(repoDir, repoName) + + var order git.CommitLogOrder + switch req.GetOrder() { + case proto.CommitLogRequest_COMMIT_LOG_ORDER_COMMIT_DATE: + order = git.CommitLogOrderCommitDate + case proto.CommitLogRequest_COMMIT_LOG_ORDER_TOPO_DATE: + order = git.CommitLogOrderTopoDate + case proto.CommitLogRequest_COMMIT_LOG_ORDER_UNSPECIFIED: + order = git.CommitLogOrderDefault + } + + it, err := backend.CommitLog(ctx, git.CommitLogOpts{ + Ranges: byteSlicesToStrings(req.GetRanges()), + AllRefs: req.GetAllRefs(), + After: req.GetAfter().AsTime(), + Before: req.GetBefore().AsTime(), + MaxCommits: req.GetMaxCommits(), + Skip: req.GetSkip(), + FollowOnlyFirstParent: req.GetFollowOnlyFirstParent(), + IncludeModifiedFiles: req.GetIncludeModifiedFiles(), + MessageQuery: string(req.GetMessageQuery()), + AuthorQuery: string(req.GetAuthorQuery()), + Path: string(req.GetPath()), + FollowPathRenames: req.GetFollowPathRenames(), + Order: order, + }) + if err != nil { + gs.svc.LogIfCorrupt(ctx, repoName, err) + return err + } + + defer func() { + closeErr := it.Close() + if closeErr == nil { + return + } + + if err == nil { + err = closeErr + return + } + }() + + sendFunc := func(cs []*proto.GetCommitResponse) error { + return ss.Send(&proto.CommitLogResponse{Commits: cs}) + } + + // We use a chunker here to make sure we don't send too large gRPC messages. + // For repos with thousands or even millions of files, sending them all in one + // message would be very slow, but sending them all in individual messages + // would also be slow, so we chunk them instead. + chunker := chunk.New(sendFunc) + + for { + commit, err := it.Next() + if err != nil { + if err == io.EOF { + break + } + // TODO: Can this happen here? + var e *gitdomain.RevisionNotFoundError + if errors.As(err, &e) { + s, err := status.New(codes.NotFound, "revision not found").WithDetails(&proto.RevisionNotFoundPayload{ + Repo: req.GetRepoName(), + Spec: e.Spec, + }) + if err != nil { + return err + } + return s.Err() + } + return err + } + + modifiedFiles := make([][]byte, len(commit.ModifiedFiles)) + for i, f := range commit.ModifiedFiles { + modifiedFiles[i] = []byte(f) + } + + err = chunker.Send(&proto.GetCommitResponse{ + Commit: commit.ToProto(), + ModifiedFiles: modifiedFiles, + }) + if err != nil { + return errors.Wrap(err, "failed to send commits chunk") + } + } + + err = chunker.Flush() + if err != nil { + return errors.Wrap(err, "failed to flush commits") + } + + 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 abade3922daa..b798f65c637d 100644 --- a/cmd/gitserver/internal/server_grpc_logger.go +++ b/cmd/gitserver/internal/server_grpc_logger.go @@ -1089,6 +1089,45 @@ func readDirRequestToLogFields(req *proto.ReadDirRequest) []log.Field { } } +func (l *loggingGRPCServer) CommitLog(request *proto.CommitLogRequest, server proto.GitserverService_CommitLogServer) error { + start := time.Now() + + defer func() { + elapsed := time.Since(start) + + doLog( + l.logger, + proto.GitserverService_CommitLog_FullMethodName, + status.Code(server.Context().Err()), + trace.Context(server.Context()).TraceID, + elapsed, + + commitLogRequestToLogFields(request)..., + ) + }() + + return l.base.CommitLog(request, server) +} + +func commitLogRequestToLogFields(req *proto.CommitLogRequest) []log.Field { + return []log.Field{ + log.String("repoName", req.GetRepoName()), + log.Strings("ranges", byteSlicesToStrings(req.GetRanges())), + log.Bool("allRefs", req.GetAllRefs()), + log.Time("after", req.GetAfter().AsTime()), + log.Time("before", req.GetBefore().AsTime()), + log.Int("maxCommits", int(req.GetMaxCommits())), + log.Int("skip", int(req.GetSkip())), + log.Bool("followOnlyFirstParent", req.GetFollowOnlyFirstParent()), + log.Bool("includeModifiedFiles", req.GetIncludeModifiedFiles()), + log.Int("order", int(req.GetOrder())), + log.String("messageQuery", string(req.GetMessageQuery())), + log.String("authorQuery", string(req.GetAuthorQuery())), + log.Bool("followPathRenames", req.GetFollowPathRenames()), + log.String("path", string(req.GetPath())), + } +} + type loggingRepositoryServiceServer struct { base proto.GitserverRepositoryServiceServer logger log.Logger diff --git a/internal/codeintel/policies/matcher.go b/internal/codeintel/policies/matcher.go index 3937079a9bc1..97b4c47e458a 100644 --- a/internal/codeintel/policies/matcher.go +++ b/internal/codeintel/policies/matcher.go @@ -269,9 +269,9 @@ func commitsUniqueToBranch(ctx context.Context, gitserverClient gitserver.Client rng = fmt.Sprintf("HEAD..%s", commitID) } - var after string + var after time.Time if maxCommitAge != nil { - after = maxCommitAge.Format(time.RFC3339) + after = *maxCommitAge } commits, err := gitserverClient.Commits(ctx, repo, gitserver.CommitsOptions{ diff --git a/internal/codeintel/policies/matcher_common_test.go b/internal/codeintel/policies/matcher_common_test.go index 1824956d3944..c036e010d166 100644 --- a/internal/codeintel/policies/matcher_common_test.go +++ b/internal/codeintel/policies/matcher_common_test.go @@ -109,14 +109,10 @@ func testUploadExpirerMockGitserverClient(defaultBranchName string, now time.Tim Date: createdAt[commit], }, } - if opts.After == "" { + if opts.After.IsZero() { commits = append(commits, c) } else { - after, err := time.Parse(time.RFC3339, opts.After) - if err != nil { - return nil, err - } - if !createdAt[commit].Before(after) { + if !createdAt[commit].Before(opts.After) { commits = append(commits, c) } } diff --git a/internal/codeintel/policies/matcher_retention_test.go b/internal/codeintel/policies/matcher_retention_test.go index 04b4af6262fc..be43cc86495e 100644 --- a/internal/codeintel/policies/matcher_retention_test.go +++ b/internal/codeintel/policies/matcher_retention_test.go @@ -32,7 +32,7 @@ func TestCommitsDescribedByPolicyForRetention(t *testing.T) { } for i, call := range gitserverClient.CommitsFunc.History() { - if call.Arg2.After != "" { + if !call.Arg2.After.IsZero() { t.Errorf("unexpected restriction of git results by date: call #%d", i) } } diff --git a/internal/codeintel/uploads/internal/background/commitgraph/job_commitgraph.go b/internal/codeintel/uploads/internal/background/commitgraph/job_commitgraph.go index 13c3c4e8b0d9..0338e45b7de6 100644 --- a/internal/codeintel/uploads/internal/background/commitgraph/job_commitgraph.go +++ b/internal/codeintel/uploads/internal/background/commitgraph/job_commitgraph.go @@ -155,7 +155,7 @@ func (s *commitGraphUpdater) getCommitGraph(ctx context.Context, repositoryID in commits, err := s.gitserverClient.Commits(ctx, repo, gitserver.CommitsOptions{ AllRefs: true, Order: gitserver.CommitsOrderTopoDate, - After: commitDate.Format(time.RFC3339), + After: commitDate, }) if err != nil { return nil, errors.Wrap(err, "gitserver.Commits") diff --git a/internal/gitserver/commands.go b/internal/gitserver/commands.go index 786518b41343..c4b5cddf4b71 100644 --- a/internal/gitserver/commands.go +++ b/internal/gitserver/commands.go @@ -1,14 +1,11 @@ package gitserver import ( - "bufio" - "bytes" "context" "fmt" "io" "io/fs" "os" - "strconv" "strings" "sync" "time" @@ -212,15 +209,6 @@ func (c *clientImplementor) ContributorCount(ctx context.Context, repo api.RepoN return counts, nil } -// checkSpecArgSafety returns a non-nil err if spec begins with a "-", which -// could cause it to be interpreted as a git command line argument. -func checkSpecArgSafety(spec string) error { - if strings.HasPrefix(spec, "-") { - return errors.Errorf("invalid git revision spec %q (begins with '-')", spec) - } - return nil -} - // DevNullSHA 4b825dc642cb6eb9a060e54bf8d69288fbee4904 is `git hash-object -t // tree /dev/null`, which is used as the base when computing the `git diff` of // the root commit. @@ -959,9 +947,9 @@ type CommitsOptions struct { MessageQuery string // include only commits whose commit message contains this substring - Author string // include only commits whose author matches this - After string // include only commits after this date - Before string // include only commits before this date + Author string // include only commits whose author matches this + After time.Time // include only commits after this date + Before time.Time // include only commits before this date Order CommitsOrder @@ -978,7 +966,47 @@ type CommitsOptions struct { FirstParent bool // When true return the names of the files changed in the commit - NameOnly bool + IncludeFiles bool +} + +func (opt CommitsOptions) ToProto() (*proto.CommitLogRequest, error) { + if len(opt.Ranges) > 0 && opt.AllRefs { + return nil, errors.New("cannot specify both a range and AllRefs") + } + if len(opt.Ranges) == 0 && !opt.AllRefs { + return nil, errors.New("must specify a range or AllRefs") + } + + p := &proto.CommitLogRequest{ + MaxCommits: uint32(opt.N), + Skip: uint32(opt.Skip), + FollowOnlyFirstParent: opt.FirstParent, + MessageQuery: []byte(opt.MessageQuery), + AuthorQuery: []byte(opt.Author), + Path: []byte(opt.Path), + FollowPathRenames: opt.Follow, + IncludeModifiedFiles: opt.IncludeFiles, + AllRefs: opt.AllRefs, + After: timestamppb.New(opt.After), + Before: timestamppb.New(opt.Before), + } + + for _, r := range opt.Ranges { + p.Ranges = append(p.Ranges, []byte(r)) + } + + switch opt.Order { + case CommitsOrderCommitDate: + p.Order = proto.CommitLogRequest_COMMIT_LOG_ORDER_COMMIT_DATE + case CommitsOrderTopoDate: + p.Order = proto.CommitLogRequest_COMMIT_LOG_ORDER_TOPO_DATE + case CommitsOrderDefault: + // nothing to do + default: + return nil, errors.Newf("invalid ordering %d", opt.Order) + } + + return p, nil } func (c *clientImplementor) GetCommit(ctx context.Context, repo api.RepoName, id api.CommitID) (_ *gitdomain.Commit, err error) { @@ -1030,7 +1058,7 @@ func (c *clientImplementor) GetCommit(ctx context.Context, repo api.RepoName, id // Commits returns all commits matching the options. func (c *clientImplementor) Commits(ctx context.Context, repo api.RepoName, opt CommitsOptions) (_ []*gitdomain.Commit, err error) { - opt = addNameOnly(opt, c.subRepoPermsChecker) + opt = maybeIncludeFiles(opt, c.subRepoPermsChecker) ctx, _, endObservation := c.operations.commits.With(ctx, &err, observation.Args{ MetricLabelValues: []string{c.scope}, Attrs: []attribute.KeyValue{ @@ -1040,12 +1068,6 @@ func (c *clientImplementor) Commits(ctx context.Context, repo api.RepoName, opt }) defer endObservation(1, observation.Args{}) - for _, r := range opt.Ranges { - if err := checkSpecArgSafety(r); err != nil { - return nil, err - } - } - wrappedCommits, err := c.getWrappedCommits(ctx, repo, opt) if err != nil { return nil, err @@ -1101,21 +1123,41 @@ func hasAccessToCommit(ctx context.Context, commit *wrappedCommit, repoName api. return false, nil } -func isBadObjectErr(output, obj string) bool { - return output == "fatal: bad object "+obj -} - func (c *clientImplementor) getWrappedCommits(ctx context.Context, repo api.RepoName, opt CommitsOptions) ([]*wrappedCommit, error) { - args, err := commitLogArgs([]string{"log", logFormatWithoutRefs}, opt) + cli, err := c.clientSource.ClientForRepo(ctx, repo) + if err != nil { + return nil, err + } + + popt, err := opt.ToProto() if err != nil { return nil, err } + popt.RepoName = string(repo) - cmd := c.gitCommand(repo, args...) - wrappedCommits, err := runCommitLog(ctx, cmd, opt) + cc, err := cli.CommitLog(ctx, popt) if err != nil { return nil, err } + + wrappedCommits := []*wrappedCommit{} + for { + chunk, err := cc.Recv() + if err != nil { + if errors.Is(err, io.EOF) { + break + } + return nil, err + } + for _, c := range chunk.GetCommits() { + commit := c.GetCommit() + wrappedCommits = append(wrappedCommits, &wrappedCommit{ + Commit: gitdomain.CommitFromProto(commit), + files: byteSlicesToStrings(c.GetModifiedFiles()), + }) + } + } + return wrappedCommits, nil } @@ -1180,142 +1222,11 @@ func joinCommits(previous, next []*gitdomain.Commit, desiredTotal uint) []*gitdo return allCommits } -// runCommitLog sends the git command to gitserver. It interprets missing -// revision responses and converts them into RevisionNotFoundError. -// It is declared as a variable so that we can swap it out in tests -var runCommitLog = func(ctx context.Context, cmd GitCommand, opt CommitsOptions) ([]*wrappedCommit, error) { - data, stderr, err := cmd.DividedOutput(ctx) - if err != nil { - data = bytes.TrimSpace(data) - for _, r := range opt.Ranges { - if isBadObjectErr(string(stderr), r) { - return nil, &gitdomain.RevisionNotFoundError{Repo: cmd.Repo(), Spec: r} - } - } - return nil, errors.WithMessage(err, fmt.Sprintf("git command %v failed (output: %q)", cmd.Args(), data)) - } - - return parseCommitLogOutput(bytes.NewReader(data)) -} - -func parseCommitLogOutput(r io.Reader) ([]*wrappedCommit, error) { - commitScanner := bufio.NewScanner(r) - // We use an increased buffer size since sub-repo permissions - // can result in very lengthy output. - commitScanner.Buffer(make([]byte, 0, 65536), 4294967296) - commitScanner.Split(commitSplitFunc) - - var commits []*wrappedCommit - for commitScanner.Scan() { - rawCommit := commitScanner.Bytes() - parts := bytes.Split(rawCommit, []byte{'\x00'}) - if len(parts) != partsPerCommit { - return nil, errors.Newf("internal error: expected %d parts, got %d", partsPerCommit, len(parts)) - } - - commit, err := parseCommitFromLog(parts) - if err != nil { - return nil, err - } - commits = append(commits, commit) - } - return commits, nil -} - -func commitSplitFunc(data []byte, atEOF bool) (advance int, token []byte, err error) { - if len(data) == 0 { - // Request more data - return 0, nil, nil - } - - // Safety check: ensure we are always starting with a record separator - if data[0] != '\x1e' { - return 0, nil, errors.New("internal error: data should always start with an ASCII record separator") - } - - loc := bytes.IndexByte(data[1:], '\x1e') - if loc < 0 { - // We can't find the start of the next record - if atEOF { - // If we're at the end of the stream, just return the rest as the last record - return len(data), data[1:], bufio.ErrFinalToken - } else { - // If we're not at the end of the stream, request more data - return 0, nil, nil - } - } - nextStart := loc + 1 // correct for searching at an offset - - return nextStart, data[1:nextStart], nil -} - type wrappedCommit struct { *gitdomain.Commit files []string } -func commitLogArgs(initialArgs []string, opt CommitsOptions) (args []string, err error) { - for _, r := range opt.Ranges { - if err := checkSpecArgSafety(r); err != nil { - return nil, err - } - } - args = initialArgs - if opt.N != 0 { - args = append(args, "-n", strconv.FormatUint(uint64(opt.N), 10)) - } - if opt.Skip != 0 { - args = append(args, "--skip="+strconv.FormatUint(uint64(opt.Skip), 10)) - } - - if opt.Author != "" { - args = append(args, "--fixed-strings", "--author="+opt.Author) - } - - if opt.After != "" { - args = append(args, "--after="+opt.After) - } - if opt.Before != "" { - args = append(args, "--before="+opt.Before) - } - switch opt.Order { - case CommitsOrderCommitDate: - args = append(args, "--date-order") - case CommitsOrderTopoDate: - args = append(args, "--topo-order") - case CommitsOrderDefault: - // nothing to do - default: - return nil, errors.Newf("invalid ordering %d", opt.Order) - } - - if opt.MessageQuery != "" { - args = append(args, "--fixed-strings", "--regexp-ignore-case", "--grep="+opt.MessageQuery) - } - - if opt.FirstParent { - args = append(args, "--first-parent") - } - - args = append(args, opt.Ranges...) - if opt.AllRefs { - args = append(args, "--all") - } - if len(opt.Ranges) > 0 && opt.AllRefs { - return nil, errors.New("cannot specify both a Range and AllRefs") - } - if opt.NameOnly { - args = append(args, "--name-only") - } - if opt.Follow { - args = append(args, "--follow") - } - if opt.Path != "" { - args = append(args, "--", opt.Path) - } - return args, nil -} - // FirstEverCommit returns the first commit ever made to the repository. func (c *clientImplementor) FirstEverCommit(ctx context.Context, repo api.RepoName) (commit *gitdomain.Commit, err error) { ctx, _, endObservation := c.operations.firstEverCommit.With(ctx, &err, observation.Args{ @@ -1341,68 +1252,6 @@ func (c *clientImplementor) FirstEverCommit(ctx context.Context, repo api.RepoNa return gitdomain.CommitFromProto(result.GetCommit()), nil } -const ( - partsPerCommit = 10 // number of \x00-separated fields per commit - - // This format string has 10 parts: - // 1) oid - // 2) author name - // 3) author email - // 4) author time - // 5) committer name - // 6) committer email - // 7) committer time - // 8) message body - // 9) parent hashes - // 10) modified files (optional) - // - // Each commit starts with an ASCII record separator byte (0x1E), and - // each field of the commit is separated by a null byte (0x00). - // - // Refs are slow, and are intentionally not included because they are usually not needed. - logFormatWithoutRefs = "--format=format:%x1e%H%x00%aN%x00%aE%x00%at%x00%cN%x00%cE%x00%ct%x00%B%x00%P%x00" -) - -// parseCommitFromLog parses the next commit from data and returns the commit and the remaining -// data. The data arg is a byte array that contains NUL-separated log fields as formatted by -// logFormatFlag. -func parseCommitFromLog(parts [][]byte) (*wrappedCommit, error) { - // log outputs are newline separated, so all but the 1st commit ID part - // has an erroneous leading newline. - parts[0] = bytes.TrimPrefix(parts[0], []byte{'\n'}) - commitID := api.CommitID(parts[0]) - - authorTime, err := strconv.ParseInt(string(parts[3]), 10, 64) - if err != nil { - return nil, errors.Errorf("parsing git commit author time: %s", err) - } - committerTime, err := strconv.ParseInt(string(parts[6]), 10, 64) - if err != nil { - return nil, errors.Errorf("parsing git commit committer time: %s", err) - } - - var parents []api.CommitID - if parentPart := parts[8]; len(parentPart) > 0 { - parentIDs := bytes.Split(parentPart, []byte{' '}) - parents = make([]api.CommitID, len(parentIDs)) - for i, id := range parentIDs { - parents[i] = api.CommitID(id) - } - } - - fileNames := strings.Split(string(bytes.TrimSpace(parts[9])), "\n") - - return &wrappedCommit{ - Commit: &gitdomain.Commit{ - ID: commitID, - Author: gitdomain.Signature{Name: string(parts[1]), Email: string(parts[2]), Date: time.Unix(authorTime, 0).UTC()}, - Committer: &gitdomain.Signature{Name: string(parts[4]), Email: string(parts[5]), Date: time.Unix(committerTime, 0).UTC()}, - Message: gitdomain.Message(strings.TrimSuffix(string(parts[7]), "\n")), - Parents: parents, - }, files: fileNames, - }, nil -} - type ArchiveFormat string const ( @@ -1518,10 +1367,10 @@ func (br *archiveReader) Close() error { return nil } -func addNameOnly(opt CommitsOptions, checker authz.SubRepoPermissionChecker) CommitsOptions { +func maybeIncludeFiles(opt CommitsOptions, checker authz.SubRepoPermissionChecker) CommitsOptions { if authz.SubRepoEnabled(checker) { // If sub-repo permissions enabled, must fetch files modified w/ commits to determine if user has access to view this commit - opt.NameOnly = true + opt.IncludeFiles = true } return opt } diff --git a/internal/gitserver/commands_test.go b/internal/gitserver/commands_test.go index 2e9ffd2190c2..671fb8aff84c 100644 --- a/internal/gitserver/commands_test.go +++ b/internal/gitserver/commands_test.go @@ -2,12 +2,10 @@ package gitserver import ( "context" - "fmt" "io" "math/rand" "os" "reflect" - "strings" "testing" "time" @@ -140,216 +138,6 @@ func TestDiffWithSubRepoFiltering(t *testing.T) { } } -func TestLogPartsPerCommitInSync(t *testing.T) { - require.Equal(t, partsPerCommit-1, strings.Count(logFormatWithoutRefs, "%x00")) -} - -func TestCommits_After(t *testing.T) { - ClientMocks.LocalGitserver = true - defer ResetClientMocks() - ctx := actor.WithActor(context.Background(), &actor.Actor{ - UID: 1, - }) - - testCases := []struct { - label string - commitDates []string - after string - revspec string - want, wantSubRepoTest bool - }{ - { - label: "after specific date", - commitDates: []string{ - "2006-01-02T15:04:05Z", - "2007-01-02T15:04:05Z", - "2008-01-02T15:04:05Z", - }, - after: "2006-01-02T15:04:05Z", - revspec: "master", - want: true, - wantSubRepoTest: true, - }, - { - label: "after 1 year ago", - commitDates: []string{ - "2016-01-02T15:04:05Z", - "2017-01-02T15:04:05Z", - "2017-01-02T15:04:06Z", - }, - after: "1 year ago", - revspec: "master", - want: false, - wantSubRepoTest: false, - }, - { - label: "after too recent date", - commitDates: []string{ - "2006-01-02T15:04:05Z", - "2007-01-02T15:04:05Z", - "2008-01-02T15:04:05Z", - }, - after: "2010-01-02T15:04:05Z", - revspec: "HEAD", - want: false, - wantSubRepoTest: false, - }, - { - label: "commit 1 second after", - commitDates: []string{ - "2006-01-02T15:04:05Z", - "2007-01-02T15:04:05Z", - "2007-01-02T15:04:06Z", - }, - after: "2007-01-02T15:04:05Z", - revspec: "HEAD", - want: true, - wantSubRepoTest: false, - }, - { - label: "after 10 years ago", - commitDates: []string{ - "2016-01-02T15:04:05Z", - "2017-01-02T15:04:05Z", - "2017-01-02T15:04:06Z", - }, - after: "10 years ago", - revspec: "HEAD", - want: true, - wantSubRepoTest: true, - }, - } - - t.Run("basic", func(t *testing.T) { - for _, tc := range testCases { - t.Run(tc.label, func(t *testing.T) { - client := NewTestClient(t) - - gitCommands := make([]string, len(tc.commitDates)) - for i, date := range tc.commitDates { - gitCommands[i] = fmt.Sprintf("GIT_COMMITTER_NAME=a GIT_COMMITTER_EMAIL=a@a.com GIT_COMMITTER_DATE=%s git commit --allow-empty -m foo --author='a '", date) - } - repo := MakeGitRepository(t, gitCommands...) - got, err := client.Commits(ctx, repo, CommitsOptions{ - N: 2, - Ranges: []string{tc.revspec}, - After: tc.after, - }) - require.NoError(t, err) - - if len(got) > 0 != tc.want { - t.Errorf("got %t commits, want %t", len(got) > 0, tc.want) - } - }) - } - }) - - t.Run("with sub-repo permissions", func(t *testing.T) { - for _, tc := range testCases { - t.Run(tc.label, func(t *testing.T) { - gitCommands := make([]string, len(tc.commitDates)) - for i, date := range tc.commitDates { - fileName := fmt.Sprintf("file%d", i) - gitCommands = append(gitCommands, fmt.Sprintf("touch %s", fileName), fmt.Sprintf("git add %s", fileName)) - gitCommands = append(gitCommands, fmt.Sprintf("GIT_COMMITTER_NAME=a GIT_COMMITTER_EMAIL=a@a.com GIT_COMMITTER_DATE=%s git commit -m commit%d --author='a '", date, i)) - } - // Case where user can't view commit 2, but can view commits 0 and 1. In each test case the result should match the case where no sub-repo perms enabled - checker := getTestSubRepoPermsChecker("file2") - client := NewTestClient(t).WithChecker(checker) - repo := MakeGitRepository(t, gitCommands...) - got, err := client.Commits(ctx, repo, CommitsOptions{ - N: 2, - After: tc.after, - Ranges: []string{tc.revspec}, - }) - if err != nil { - t.Errorf("got error: %s", err) - } - if len(got) > 0 != tc.want { - t.Errorf("got %t commits, want %t", len(got) > 0, tc.want) - } - - // Case where user can't view commit 1 or commit 2, which will mean in some cases since len(Commits)>0 will be false due to those commits not being visible. - checker = getTestSubRepoPermsChecker("file1", "file2") - client = NewTestClient(t).WithChecker(checker) - got, err = client.Commits(ctx, repo, CommitsOptions{ - N: 2, - After: tc.after, - Ranges: []string{tc.revspec}, - }) - if err != nil { - t.Errorf("got error: %s", err) - } - if len(got) > 0 != tc.wantSubRepoTest { - t.Errorf("got %t commits, want %t", len(got) > 0, tc.wantSubRepoTest) - } - }) - } - }) -} - -var nonExistentCommitID = api.CommitID(strings.Repeat("a", 40)) - -func TestRepository_Commits(t *testing.T) { - ClientMocks.LocalGitserver = true - defer ResetClientMocks() - ctx := actor.WithActor(context.Background(), &actor.Actor{ - UID: 1, - }) - - // TODO(sqs): test CommitsOptions.Base - - gitCommands := []string{ - "git commit --allow-empty -m foo", - "GIT_COMMITTER_NAME=c GIT_COMMITTER_EMAIL=c@c.com GIT_COMMITTER_DATE=2006-01-02T15:04:07Z git commit --allow-empty -m bar --author='a ' --date 2006-01-02T15:04:06Z", - } - wantGitCommits := []*gitdomain.Commit{ - { - ID: "b266c7e3ca00b1a17ad0b1449825d0854225c007", - Author: gitdomain.Signature{Name: "a", Email: "a@a.com", Date: MustParseTime(time.RFC3339, "2006-01-02T15:04:06Z")}, - Committer: &gitdomain.Signature{Name: "c", Email: "c@c.com", Date: MustParseTime(time.RFC3339, "2006-01-02T15:04:07Z")}, - Message: "bar", - Parents: []api.CommitID{"ea167fe3d76b1e5fd3ed8ca44cbd2fe3897684f8"}, - }, - { - ID: "ea167fe3d76b1e5fd3ed8ca44cbd2fe3897684f8", - Author: gitdomain.Signature{Name: "a", Email: "a@a.com", Date: MustParseTime(time.RFC3339, "2006-01-02T15:04:05Z")}, - Committer: &gitdomain.Signature{Name: "a", Email: "a@a.com", Date: MustParseTime(time.RFC3339, "2006-01-02T15:04:05Z")}, - Message: "foo", - Parents: nil, - }, - } - tests := map[string]struct { - repo api.RepoName - id api.CommitID - wantCommits []*gitdomain.Commit - wantTotal uint - }{ - "git cmd": { - repo: MakeGitRepository(t, gitCommands...), - id: "b266c7e3ca00b1a17ad0b1449825d0854225c007", - wantCommits: wantGitCommits, - wantTotal: 2, - }, - } - client := NewClient("test") - runCommitsTests := func(checker authz.SubRepoPermissionChecker) { - for label, test := range tests { - t.Run(label, func(t *testing.T) { - testCommits(ctx, label, test.repo, CommitsOptions{Ranges: []string{string(test.id)}}, checker, test.wantCommits, t) - - // Test that trying to get a nonexistent commit returns RevisionNotFoundError. - if _, err := client.Commits(ctx, test.repo, CommitsOptions{Ranges: []string{string(nonExistentCommitID)}}); !errors.HasType(err, &gitdomain.RevisionNotFoundError{}) { - t.Errorf("%s: for nonexistent commit: got err %v, want RevisionNotFoundError", label, err) - } - }) - } - } - runCommitsTests(nil) - checker := getTestSubRepoPermsChecker() - runCommitsTests(checker) -} - func TestCommits_SubRepoPerms(t *testing.T) { ClientMocks.LocalGitserver = true defer ResetClientMocks() @@ -534,186 +322,6 @@ func TestCommits_SubRepoPerms_ReturnNCommits(t *testing.T) { } } -func TestRepository_Commits_options(t *testing.T) { - ClientMocks.LocalGitserver = true - defer ResetClientMocks() - ctx := context.Background() - ctx = actor.WithActor(ctx, actor.FromUser(42)) - - gitCommands := []string{ - "git commit --allow-empty -m foo", - "GIT_COMMITTER_NAME=c GIT_COMMITTER_EMAIL=c@c.com GIT_COMMITTER_DATE=2006-01-02T15:04:07Z git commit --allow-empty -m bar --author='a ' --date 2006-01-02T15:04:06Z", - "GIT_COMMITTER_NAME=c GIT_COMMITTER_EMAIL=c@c.com GIT_COMMITTER_DATE=2006-01-02T15:04:08Z git commit --allow-empty -m qux --author='a ' --date 2006-01-02T15:04:08Z", - } - wantGitCommits := []*gitdomain.Commit{ - { - ID: "b266c7e3ca00b1a17ad0b1449825d0854225c007", - Author: gitdomain.Signature{Name: "a", Email: "a@a.com", Date: MustParseTime(time.RFC3339, "2006-01-02T15:04:06Z")}, - Committer: &gitdomain.Signature{Name: "c", Email: "c@c.com", Date: MustParseTime(time.RFC3339, "2006-01-02T15:04:07Z")}, - Message: "bar", - Parents: []api.CommitID{"ea167fe3d76b1e5fd3ed8ca44cbd2fe3897684f8"}, - }, - } - wantGitCommits2 := []*gitdomain.Commit{ - { - ID: "ade564eba4cf904492fb56dcd287ac633e6e082c", - Author: gitdomain.Signature{Name: "a", Email: "a@a.com", Date: MustParseTime(time.RFC3339, "2006-01-02T15:04:08Z")}, - Committer: &gitdomain.Signature{Name: "c", Email: "c@c.com", Date: MustParseTime(time.RFC3339, "2006-01-02T15:04:08Z")}, - Message: "qux", - Parents: []api.CommitID{"b266c7e3ca00b1a17ad0b1449825d0854225c007"}, - }, - } - tests := map[string]struct { - opt CommitsOptions - wantCommits []*gitdomain.Commit - wantTotal uint - }{ - "git cmd": { - opt: CommitsOptions{Ranges: []string{"ade564eba4cf904492fb56dcd287ac633e6e082c"}, N: 1, Skip: 1}, - wantCommits: wantGitCommits, - wantTotal: 1, - }, - "git cmd Head": { - opt: CommitsOptions{ - Ranges: []string{"b266c7e3ca00b1a17ad0b1449825d0854225c007...ade564eba4cf904492fb56dcd287ac633e6e082c"}, - }, - wantCommits: wantGitCommits2, - wantTotal: 1, - }, - "before": { - opt: CommitsOptions{ - Before: "2006-01-02T15:04:07Z", - Ranges: []string{"HEAD"}, - N: 1, - }, - wantCommits: []*gitdomain.Commit{ - { - ID: "b266c7e3ca00b1a17ad0b1449825d0854225c007", - Author: gitdomain.Signature{Name: "a", Email: "a@a.com", Date: MustParseTime(time.RFC3339, "2006-01-02T15:04:06Z")}, - Committer: &gitdomain.Signature{Name: "c", Email: "c@c.com", Date: MustParseTime(time.RFC3339, "2006-01-02T15:04:07Z")}, - Message: "bar", - Parents: []api.CommitID{"ea167fe3d76b1e5fd3ed8ca44cbd2fe3897684f8"}, - }, - }, - wantTotal: 1, - }, - } - runCommitsTests := func(checker authz.SubRepoPermissionChecker) { - for label, test := range tests { - t.Run(label, func(t *testing.T) { - repo := MakeGitRepository(t, gitCommands...) - testCommits(ctx, label, repo, test.opt, checker, test.wantCommits, t) - }) - } - // Added for awareness if this error message changes. Insights record last repo indexing and consider empty - // repos a success case. - subRepo := "" - if checker != nil { - subRepo = " sub repo enabled" - } - t.Run("empty repo"+subRepo, func(t *testing.T) { - repo := MakeGitRepository(t) - before := "" - after := time.Date(2022, 11, 11, 12, 10, 0, 4, time.UTC).Format(time.RFC3339) - client := NewTestClient(t).WithChecker(checker) - _, err := client.Commits(ctx, repo, CommitsOptions{N: 0, Order: CommitsOrderCommitDate, After: after, Before: before}) - if err == nil { - t.Error("expected error, got nil") - } - wantErr := `git command [git log --format=format:%x1e%H%x00%aN%x00%aE%x00%at%x00%cN%x00%cE%x00%ct%x00%B%x00%P%x00 --after=` + after + " --date-order" - if subRepo != "" { - wantErr += " --name-only" - } - wantErr += `] failed (output: ""): exit status 128` - if err.Error() != wantErr { - t.Errorf("expected:%v got:%v", wantErr, err.Error()) - } - }) - } - runCommitsTests(nil) - checker := getTestSubRepoPermsChecker() - runCommitsTests(checker) -} - -func TestRepository_Commits_options_path(t *testing.T) { - ClientMocks.LocalGitserver = true - defer ResetClientMocks() - ctx := actor.WithActor(context.Background(), &actor.Actor{ - UID: 1, - }) - - gitCommands := []string{ - "git commit --allow-empty -m commit1", - "touch file1", - "touch --date=2006-01-02T15:04:05Z file1 || touch -t " + times[0] + " file1", - "git add file1", - "git commit -m commit2", - "GIT_COMMITTER_NAME=c GIT_COMMITTER_EMAIL=c@c.com GIT_COMMITTER_DATE=2006-01-02T15:04:07Z git commit --allow-empty -m commit3 --author='a ' --date 2006-01-02T15:04:06Z", - } - wantGitCommits := []*gitdomain.Commit{ - { - ID: "546a3ef26e581624ef997cb8c0ba01ee475fc1dc", - Author: gitdomain.Signature{Name: "a", Email: "a@a.com", Date: MustParseTime(time.RFC3339, "2006-01-02T15:04:05Z")}, - Committer: &gitdomain.Signature{Name: "a", Email: "a@a.com", Date: MustParseTime(time.RFC3339, "2006-01-02T15:04:05Z")}, - Message: "commit2", - Parents: []api.CommitID{"a04652fa1998a0a7d2f2f77ecb7021de943d3aab"}, - }, - } - tests := map[string]struct { - opt CommitsOptions - wantCommits []*gitdomain.Commit - }{ - "git cmd Path 0": { - opt: CommitsOptions{ - Ranges: []string{"master"}, - Path: "doesnt-exist", - }, - wantCommits: nil, - }, - "git cmd Path 1": { - opt: CommitsOptions{ - Ranges: []string{"master"}, - Path: "file1", - }, - wantCommits: wantGitCommits, - }, - "git cmd non utf8": { - opt: CommitsOptions{ - Ranges: []string{"master"}, - Author: "a\xc0rn", - }, - wantCommits: nil, - }, - } - - runCommitsTest := func(checker authz.SubRepoPermissionChecker) { - for label, test := range tests { - t.Run(label, func(t *testing.T) { - repo := MakeGitRepository(t, gitCommands...) - testCommits(ctx, label, repo, test.opt, checker, test.wantCommits, t) - }) - } - } - runCommitsTest(nil) - checker := getTestSubRepoPermsChecker() - runCommitsTest(checker) -} - -func testCommits(ctx context.Context, label string, repo api.RepoName, opt CommitsOptions, checker authz.SubRepoPermissionChecker, wantCommits []*gitdomain.Commit, t *testing.T) { - t.Helper() - client := NewTestClient(t).WithChecker(checker) - commits, err := client.Commits(ctx, repo, opt) - if err != nil { - t.Errorf("%s: Commits(): %s", label, err) - return - } - - if len(commits) != len(wantCommits) { - t.Errorf("%s: got %d commits, want %d", label, len(commits), len(wantCommits)) - } - checkCommits(t, commits, wantCommits) -} - func checkCommits(t *testing.T, commits, wantCommits []*gitdomain.Commit) { t.Helper() for i := 0; i < len(commits) || i < len(wantCommits); i++ { @@ -748,25 +356,6 @@ func getTestSubRepoPermsChecker(noAccessPaths ...string) authz.SubRepoPermission return checker } -func CommitsEqual(a, b *gitdomain.Commit) bool { - if (a == nil) != (b == nil) { - return false - } - if a.Author.Date != b.Author.Date { - return false - } - a.Author.Date = b.Author.Date - if ac, bc := a.Committer, b.Committer; ac != nil && bc != nil { - if ac.Date != bc.Date { - return false - } - ac.Date = bc.Date - } else if !(ac == nil && bc == nil) { - return false - } - return reflect.DeepEqual(a, b) -} - func usePermissionsForFilePermissionsFunc(m *authz.MockSubRepoPermissionChecker) { m.FilePermissionsFuncFunc.SetDefaultHook(func(ctx context.Context, userID int32, repo api.RepoName) (authz.FilePermissionFunc, error) { return func(path string) (authz.Perms, error) { diff --git a/internal/gitserver/errwrap.go b/internal/gitserver/errwrap.go index 3be139ea9ea2..0ab2782bfd19 100644 --- a/internal/gitserver/errwrap.go +++ b/internal/gitserver/errwrap.go @@ -369,4 +369,21 @@ func (r *errorTranslatingReadDirClient) Recv() (*proto.ReadDirResponse, error) { return res, convertGRPCErrorToGitDomainError(err) } +func (r *errorTranslatingClient) CommitLog(ctx context.Context, in *proto.CommitLogRequest, opts ...grpc.CallOption) (proto.GitserverService_CommitLogClient, error) { + cc, err := r.base.CommitLog(ctx, in, opts...) + if err != nil { + return nil, convertGRPCErrorToGitDomainError(err) + } + return &errorTranslatingCommitLogClient{cc}, nil +} + +type errorTranslatingCommitLogClient struct { + proto.GitserverService_CommitLogClient +} + +func (r *errorTranslatingCommitLogClient) Recv() (*proto.CommitLogResponse, error) { + res, err := r.GitserverService_CommitLogClient.Recv() + return res, convertGRPCErrorToGitDomainError(err) +} + var _ proto.GitserverServiceClient = &errorTranslatingClient{} diff --git a/internal/gitserver/gitdomain/BUILD.bazel b/internal/gitserver/gitdomain/BUILD.bazel index 06934da204e0..05157eea6ee9 100644 --- a/internal/gitserver/gitdomain/BUILD.bazel +++ b/internal/gitserver/gitdomain/BUILD.bazel @@ -5,6 +5,7 @@ go_library( name = "gitdomain", srcs = [ "common.go", + "date.go", "errors.go", "log.go", ], @@ -18,6 +19,7 @@ go_library( "//internal/lazyregexp", "//lib/errors", "@com_github_gobwas_glob//:glob", + "@com_github_tj_go_naturaldate//:go-naturaldate", "@org_golang_google_protobuf//types/known/timestamppb", ], ) @@ -27,6 +29,7 @@ go_test( timeout = "short", srcs = [ "common_test.go", + "date_test.go", "log_test.go", ], embed = [":gitdomain"], @@ -37,6 +40,7 @@ go_test( "//internal/gitserver/v1:gitserver", "@com_github_google_go_cmp//cmp", "@com_github_stretchr_testify//assert", + "@com_github_stretchr_testify//require", "@org_golang_google_protobuf//proto", ], ) diff --git a/internal/search/query/date_format.go b/internal/gitserver/gitdomain/date.go similarity index 99% rename from internal/search/query/date_format.go rename to internal/gitserver/gitdomain/date.go index d1d3643d8dc9..dde50b79974c 100644 --- a/internal/search/query/date_format.go +++ b/internal/gitserver/gitdomain/date.go @@ -1,4 +1,4 @@ -package query +package gitdomain import ( "strconv" diff --git a/internal/search/query/date_format_test.go b/internal/gitserver/gitdomain/date_test.go similarity index 99% rename from internal/search/query/date_format_test.go rename to internal/gitserver/gitdomain/date_test.go index 632d0b8481ed..33206b57e3a3 100644 --- a/internal/search/query/date_format_test.go +++ b/internal/gitserver/gitdomain/date_test.go @@ -1,4 +1,4 @@ -package query +package gitdomain import ( "testing" diff --git a/internal/gitserver/mock.go b/internal/gitserver/mock.go index 0056048f0777..4654cb57cc1c 100644 --- a/internal/gitserver/mock.go +++ b/internal/gitserver/mock.go @@ -35,6 +35,9 @@ type MockGitserverServiceClient struct { // CheckPerforceCredentialsFunc is an instance of a mock function object // controlling the behavior of the method CheckPerforceCredentials. CheckPerforceCredentialsFunc *GitserverServiceClientCheckPerforceCredentialsFunc + // CommitLogFunc is an instance of a mock function object controlling + // the behavior of the method CommitLog. + CommitLogFunc *GitserverServiceClientCommitLogFunc // ContributorCountsFunc is an instance of a mock function object // controlling the behavior of the method ContributorCounts. ContributorCountsFunc *GitserverServiceClientContributorCountsFunc @@ -149,6 +152,11 @@ func NewMockGitserverServiceClient() *MockGitserverServiceClient { return }, }, + CommitLogFunc: &GitserverServiceClientCommitLogFunc{ + defaultHook: func(context.Context, *v1.CommitLogRequest, ...grpc.CallOption) (r0 v1.GitserverService_CommitLogClient, r1 error) { + return + }, + }, ContributorCountsFunc: &GitserverServiceClientContributorCountsFunc{ defaultHook: func(context.Context, *v1.ContributorCountsRequest, ...grpc.CallOption) (r0 *v1.ContributorCountsResponse, r1 error) { return @@ -317,6 +325,11 @@ func NewStrictMockGitserverServiceClient() *MockGitserverServiceClient { panic("unexpected invocation of MockGitserverServiceClient.CheckPerforceCredentials") }, }, + CommitLogFunc: &GitserverServiceClientCommitLogFunc{ + defaultHook: func(context.Context, *v1.CommitLogRequest, ...grpc.CallOption) (v1.GitserverService_CommitLogClient, error) { + panic("unexpected invocation of MockGitserverServiceClient.CommitLog") + }, + }, ContributorCountsFunc: &GitserverServiceClientContributorCountsFunc{ defaultHook: func(context.Context, *v1.ContributorCountsRequest, ...grpc.CallOption) (*v1.ContributorCountsResponse, error) { panic("unexpected invocation of MockGitserverServiceClient.ContributorCounts") @@ -475,6 +488,9 @@ func NewMockGitserverServiceClientFrom(i v1.GitserverServiceClient) *MockGitserv CheckPerforceCredentialsFunc: &GitserverServiceClientCheckPerforceCredentialsFunc{ defaultHook: i.CheckPerforceCredentials, }, + CommitLogFunc: &GitserverServiceClientCommitLogFunc{ + defaultHook: i.CommitLog, + }, ContributorCountsFunc: &GitserverServiceClientContributorCountsFunc{ defaultHook: i.ContributorCounts, }, @@ -1160,6 +1176,127 @@ func (c GitserverServiceClientCheckPerforceCredentialsFuncCall) Results() []inte return []interface{}{c.Result0, c.Result1} } +// GitserverServiceClientCommitLogFunc describes the behavior when the +// CommitLog method of the parent MockGitserverServiceClient instance is +// invoked. +type GitserverServiceClientCommitLogFunc struct { + defaultHook func(context.Context, *v1.CommitLogRequest, ...grpc.CallOption) (v1.GitserverService_CommitLogClient, error) + hooks []func(context.Context, *v1.CommitLogRequest, ...grpc.CallOption) (v1.GitserverService_CommitLogClient, error) + history []GitserverServiceClientCommitLogFuncCall + mutex sync.Mutex +} + +// CommitLog delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockGitserverServiceClient) CommitLog(v0 context.Context, v1 *v1.CommitLogRequest, v2 ...grpc.CallOption) (v1.GitserverService_CommitLogClient, error) { + r0, r1 := m.CommitLogFunc.nextHook()(v0, v1, v2...) + m.CommitLogFunc.appendCall(GitserverServiceClientCommitLogFuncCall{v0, v1, v2, r0, r1}) + return r0, r1 +} + +// SetDefaultHook sets function that is called when the CommitLog method of +// the parent MockGitserverServiceClient instance is invoked and the hook +// queue is empty. +func (f *GitserverServiceClientCommitLogFunc) SetDefaultHook(hook func(context.Context, *v1.CommitLogRequest, ...grpc.CallOption) (v1.GitserverService_CommitLogClient, error)) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// CommitLog 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 *GitserverServiceClientCommitLogFunc) PushHook(hook func(context.Context, *v1.CommitLogRequest, ...grpc.CallOption) (v1.GitserverService_CommitLogClient, 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 *GitserverServiceClientCommitLogFunc) SetDefaultReturn(r0 v1.GitserverService_CommitLogClient, r1 error) { + f.SetDefaultHook(func(context.Context, *v1.CommitLogRequest, ...grpc.CallOption) (v1.GitserverService_CommitLogClient, error) { + return r0, r1 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *GitserverServiceClientCommitLogFunc) PushReturn(r0 v1.GitserverService_CommitLogClient, r1 error) { + f.PushHook(func(context.Context, *v1.CommitLogRequest, ...grpc.CallOption) (v1.GitserverService_CommitLogClient, error) { + return r0, r1 + }) +} + +func (f *GitserverServiceClientCommitLogFunc) nextHook() func(context.Context, *v1.CommitLogRequest, ...grpc.CallOption) (v1.GitserverService_CommitLogClient, 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 *GitserverServiceClientCommitLogFunc) appendCall(r0 GitserverServiceClientCommitLogFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of GitserverServiceClientCommitLogFuncCall +// objects describing the invocations of this function. +func (f *GitserverServiceClientCommitLogFunc) History() []GitserverServiceClientCommitLogFuncCall { + f.mutex.Lock() + history := make([]GitserverServiceClientCommitLogFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// GitserverServiceClientCommitLogFuncCall is an object that describes an +// invocation of method CommitLog on an instance of +// MockGitserverServiceClient. +type GitserverServiceClientCommitLogFuncCall 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.CommitLogRequest + // 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_CommitLogClient + // 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 GitserverServiceClientCommitLogFuncCall) 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 GitserverServiceClientCommitLogFuncCall) Results() []interface{} { + return []interface{}{c.Result0, c.Result1} +} + // GitserverServiceClientContributorCountsFunc describes the behavior when // the ContributorCounts method of the parent MockGitserverServiceClient // instance is invoked. diff --git a/internal/gitserver/retry.go b/internal/gitserver/retry.go index d3703897a4f4..1da08dc80a60 100644 --- a/internal/gitserver/retry.go +++ b/internal/gitserver/retry.go @@ -190,4 +190,9 @@ func (r *automaticRetryClient) ReadDir(ctx context.Context, in *proto.ReadDirReq return r.base.ReadDir(ctx, in, opts...) } +func (r *automaticRetryClient) CommitLog(ctx context.Context, in *proto.CommitLogRequest, opts ...grpc.CallOption) (proto.GitserverService_CommitLogClient, error) { + opts = append(defaults.RetryPolicy, opts...) + return r.base.CommitLog(ctx, in, opts...) +} + var _ proto.GitserverServiceClient = &automaticRetryClient{} diff --git a/internal/gitserver/v1/gitserver.pb.go b/internal/gitserver/v1/gitserver.pb.go index ae2da93fca5b..e11e86661b48 100644 --- a/internal/gitserver/v1/gitserver.pb.go +++ b/internal/gitserver/v1/gitserver.pb.go @@ -122,6 +122,63 @@ func (ArchiveFormat) EnumDescriptor() ([]byte, []int) { return file_gitserver_proto_rawDescGZIP(), []int{1} } +type CommitLogRequest_CommitLogOrder int32 + +const ( + // Uses the default ordering of git log: in reverse chronological order. + // See https://git-scm.com/docs/git-log#_commit_ordering for more details. + CommitLogRequest_COMMIT_LOG_ORDER_UNSPECIFIED CommitLogRequest_CommitLogOrder = 0 + // Show no parents before all of its children are shown, but otherwise show commits + // in the commit timestamp order. + // See https://git-scm.com/docs/git-log#_commit_ordering for more details. + CommitLogRequest_COMMIT_LOG_ORDER_COMMIT_DATE CommitLogRequest_CommitLogOrder = 1 + // Show no parents before all of its children are shown, and avoid showing commits + // on multiple lines of history intermixed. + // See https://git-scm.com/docs/git-log#_commit_ordering for more details. + CommitLogRequest_COMMIT_LOG_ORDER_TOPO_DATE CommitLogRequest_CommitLogOrder = 2 +) + +// Enum value maps for CommitLogRequest_CommitLogOrder. +var ( + CommitLogRequest_CommitLogOrder_name = map[int32]string{ + 0: "COMMIT_LOG_ORDER_UNSPECIFIED", + 1: "COMMIT_LOG_ORDER_COMMIT_DATE", + 2: "COMMIT_LOG_ORDER_TOPO_DATE", + } + CommitLogRequest_CommitLogOrder_value = map[string]int32{ + "COMMIT_LOG_ORDER_UNSPECIFIED": 0, + "COMMIT_LOG_ORDER_COMMIT_DATE": 1, + "COMMIT_LOG_ORDER_TOPO_DATE": 2, + } +) + +func (x CommitLogRequest_CommitLogOrder) Enum() *CommitLogRequest_CommitLogOrder { + p := new(CommitLogRequest_CommitLogOrder) + *p = x + return p +} + +func (x CommitLogRequest_CommitLogOrder) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (CommitLogRequest_CommitLogOrder) Descriptor() protoreflect.EnumDescriptor { + return file_gitserver_proto_enumTypes[2].Descriptor() +} + +func (CommitLogRequest_CommitLogOrder) Type() protoreflect.EnumType { + return &file_gitserver_proto_enumTypes[2] +} + +func (x CommitLogRequest_CommitLogOrder) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use CommitLogRequest_CommitLogOrder.Descriptor instead. +func (CommitLogRequest_CommitLogOrder) EnumDescriptor() ([]byte, []int) { + return file_gitserver_proto_rawDescGZIP(), []int{6, 0} +} + type RawDiffRequest_ComparisonType int32 const ( @@ -159,11 +216,11 @@ func (x RawDiffRequest_ComparisonType) String() string { } func (RawDiffRequest_ComparisonType) Descriptor() protoreflect.EnumDescriptor { - return file_gitserver_proto_enumTypes[2].Descriptor() + return file_gitserver_proto_enumTypes[3].Descriptor() } func (RawDiffRequest_ComparisonType) Type() protoreflect.EnumType { - return &file_gitserver_proto_enumTypes[2] + return &file_gitserver_proto_enumTypes[3] } func (x RawDiffRequest_ComparisonType) Number() protoreflect.EnumNumber { @@ -172,7 +229,7 @@ func (x RawDiffRequest_ComparisonType) Number() protoreflect.EnumNumber { // Deprecated: Use RawDiffRequest_ComparisonType.Descriptor instead. func (RawDiffRequest_ComparisonType) EnumDescriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{9, 0} + return file_gitserver_proto_rawDescGZIP(), []int{11, 0} } type GitRef_RefType int32 @@ -208,11 +265,11 @@ func (x GitRef_RefType) String() string { } func (GitRef_RefType) Descriptor() protoreflect.EnumDescriptor { - return file_gitserver_proto_enumTypes[3].Descriptor() + return file_gitserver_proto_enumTypes[4].Descriptor() } func (GitRef_RefType) Type() protoreflect.EnumType { - return &file_gitserver_proto_enumTypes[3] + return &file_gitserver_proto_enumTypes[4] } func (x GitRef_RefType) Number() protoreflect.EnumNumber { @@ -221,7 +278,7 @@ func (x GitRef_RefType) Number() protoreflect.EnumNumber { // Deprecated: Use GitRef_RefType.Descriptor instead. func (GitRef_RefType) EnumDescriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{13, 0} + return file_gitserver_proto_rawDescGZIP(), []int{15, 0} } type GitObject_ObjectType int32 @@ -263,11 +320,11 @@ func (x GitObject_ObjectType) String() string { } func (GitObject_ObjectType) Descriptor() protoreflect.EnumDescriptor { - return file_gitserver_proto_enumTypes[4].Descriptor() + return file_gitserver_proto_enumTypes[5].Descriptor() } func (GitObject_ObjectType) Type() protoreflect.EnumType { - return &file_gitserver_proto_enumTypes[4] + return &file_gitserver_proto_enumTypes[5] } func (x GitObject_ObjectType) Number() protoreflect.EnumNumber { @@ -276,7 +333,7 @@ func (x GitObject_ObjectType) Number() protoreflect.EnumNumber { // Deprecated: Use GitObject_ObjectType.Descriptor instead. func (GitObject_ObjectType) EnumDescriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{76, 0} + return file_gitserver_proto_rawDescGZIP(), []int{78, 0} } // PerforceChangelistState is the valid state values of a Perforce changelist. @@ -321,11 +378,11 @@ func (x PerforceChangelist_PerforceChangelistState) String() string { } func (PerforceChangelist_PerforceChangelistState) Descriptor() protoreflect.EnumDescriptor { - return file_gitserver_proto_enumTypes[5].Descriptor() + return file_gitserver_proto_enumTypes[6].Descriptor() } func (PerforceChangelist_PerforceChangelistState) Type() protoreflect.EnumType { - return &file_gitserver_proto_enumTypes[5] + return &file_gitserver_proto_enumTypes[6] } func (x PerforceChangelist_PerforceChangelistState) Number() protoreflect.EnumNumber { @@ -334,7 +391,7 @@ func (x PerforceChangelist_PerforceChangelistState) Number() protoreflect.EnumNu // Deprecated: Use PerforceChangelist_PerforceChangelistState.Descriptor instead. func (PerforceChangelist_PerforceChangelistState) EnumDescriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{84, 0} + return file_gitserver_proto_rawDescGZIP(), []int{86, 0} } // status is the status of the path. @@ -377,11 +434,11 @@ func (x ChangedFile_Status) String() string { } func (ChangedFile_Status) Descriptor() protoreflect.EnumDescriptor { - return file_gitserver_proto_enumTypes[6].Descriptor() + return file_gitserver_proto_enumTypes[7].Descriptor() } func (ChangedFile_Status) Type() protoreflect.EnumType { - return &file_gitserver_proto_enumTypes[6] + return &file_gitserver_proto_enumTypes[7] } func (x ChangedFile_Status) Number() protoreflect.EnumNumber { @@ -390,7 +447,7 @@ func (x ChangedFile_Status) Number() protoreflect.EnumNumber { // Deprecated: Use ChangedFile_Status.Descriptor instead. func (ChangedFile_Status) EnumDescriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{105, 0} + return file_gitserver_proto_rawDescGZIP(), []int{107, 0} } type ListRepositoriesRequest struct { @@ -703,6 +760,231 @@ func (x *FetchRepositoryResponse) GetLastChanged() *timestamppb.Timestamp { return nil } +type CommitLogRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // repo_name is the name of the repo to run the blame operation in. + // 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"` + // Ranges to include in the git log (revspec, "A..B", "A...B", etc.). + // At least one range, or all_refs must be specified. + Ranges [][]byte `protobuf:"bytes,3,rep,name=ranges,proto3" json:"ranges,omitempty"` + // If true, all refs are searched for commits. + // Must not be true when ranges are given. + AllRefs bool `protobuf:"varint,4,opt,name=all_refs,json=allRefs,proto3" json:"all_refs,omitempty"` + // After is an optional parameter to specify the earliest commit to consider + After *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=after,proto3" json:"after,omitempty"` + // Before is an optional parameter to specify the latest commit to consider + Before *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=before,proto3" json:"before,omitempty"` + // MaxCommits is an optional parameter to specify the maximum number of commits + // to return. If max_commits is 0, all commits that match the criteria will be + // returned. + MaxCommits uint32 `protobuf:"varint,7,opt,name=max_commits,json=maxCommits,proto3" json:"max_commits,omitempty"` + // Skip is an optional parameter to specify the number of commits to skip. + // This can be used to implement a poor mans pagination. + // TODO: We want to switch to more proper gRPC pagination here later. + Skip uint32 `protobuf:"varint,8,opt,name=skip,proto3" json:"skip,omitempty"` + // When finding commits to include, follow only the first parent commit upon + // seeing a merge commit. This option can give a better overview when viewing + // the evolution of a particular topic branch, because merges into a topic + // branch tend to be only about adjusting to updated upstream from time to time, + // and this option allows you to ignore the individual commits brought in to + // your history by such a merge. + FollowOnlyFirstParent bool `protobuf:"varint,9,opt,name=follow_only_first_parent,json=followOnlyFirstParent,proto3" json:"follow_only_first_parent,omitempty"` + // If true, the modified_files field in the GetCommitResponse will be + // populated. + IncludeModifiedFiles bool `protobuf:"varint,10,opt,name=include_modified_files,json=includeModifiedFiles,proto3" json:"include_modified_files,omitempty"` + Order CommitLogRequest_CommitLogOrder `protobuf:"varint,11,opt,name=order,proto3,enum=gitserver.v1.CommitLogRequest_CommitLogOrder" json:"order,omitempty"` + // Include only commits whose commit message contains this substring. + MessageQuery []byte `protobuf:"bytes,12,opt,name=message_query,json=messageQuery,proto3" json:"message_query,omitempty"` + // include only commits whose author matches this. + AuthorQuery []byte `protobuf:"bytes,13,opt,name=author_query,json=authorQuery,proto3" json:"author_query,omitempty"` + // include only commits that touch this file path. + Path []byte `protobuf:"bytes,14,opt,name=path,proto3" json:"path,omitempty"` + // Follow the history of the path beyond renames, only effective when used with + // `path`. + FollowPathRenames bool `protobuf:"varint,15,opt,name=follow_path_renames,json=followPathRenames,proto3" json:"follow_path_renames,omitempty"` +} + +func (x *CommitLogRequest) Reset() { + *x = CommitLogRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_gitserver_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CommitLogRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CommitLogRequest) ProtoMessage() {} + +func (x *CommitLogRequest) ProtoReflect() protoreflect.Message { + mi := &file_gitserver_proto_msgTypes[6] + 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 CommitLogRequest.ProtoReflect.Descriptor instead. +func (*CommitLogRequest) Descriptor() ([]byte, []int) { + return file_gitserver_proto_rawDescGZIP(), []int{6} +} + +func (x *CommitLogRequest) GetRepoName() string { + if x != nil { + return x.RepoName + } + return "" +} + +func (x *CommitLogRequest) GetRanges() [][]byte { + if x != nil { + return x.Ranges + } + return nil +} + +func (x *CommitLogRequest) GetAllRefs() bool { + if x != nil { + return x.AllRefs + } + return false +} + +func (x *CommitLogRequest) GetAfter() *timestamppb.Timestamp { + if x != nil { + return x.After + } + return nil +} + +func (x *CommitLogRequest) GetBefore() *timestamppb.Timestamp { + if x != nil { + return x.Before + } + return nil +} + +func (x *CommitLogRequest) GetMaxCommits() uint32 { + if x != nil { + return x.MaxCommits + } + return 0 +} + +func (x *CommitLogRequest) GetSkip() uint32 { + if x != nil { + return x.Skip + } + return 0 +} + +func (x *CommitLogRequest) GetFollowOnlyFirstParent() bool { + if x != nil { + return x.FollowOnlyFirstParent + } + return false +} + +func (x *CommitLogRequest) GetIncludeModifiedFiles() bool { + if x != nil { + return x.IncludeModifiedFiles + } + return false +} + +func (x *CommitLogRequest) GetOrder() CommitLogRequest_CommitLogOrder { + if x != nil { + return x.Order + } + return CommitLogRequest_COMMIT_LOG_ORDER_UNSPECIFIED +} + +func (x *CommitLogRequest) GetMessageQuery() []byte { + if x != nil { + return x.MessageQuery + } + return nil +} + +func (x *CommitLogRequest) GetAuthorQuery() []byte { + if x != nil { + return x.AuthorQuery + } + return nil +} + +func (x *CommitLogRequest) GetPath() []byte { + if x != nil { + return x.Path + } + return nil +} + +func (x *CommitLogRequest) GetFollowPathRenames() bool { + if x != nil { + return x.FollowPathRenames + } + return false +} + +type CommitLogResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Commits []*GetCommitResponse `protobuf:"bytes,1,rep,name=commits,proto3" json:"commits,omitempty"` +} + +func (x *CommitLogResponse) Reset() { + *x = CommitLogResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_gitserver_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CommitLogResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CommitLogResponse) ProtoMessage() {} + +func (x *CommitLogResponse) ProtoReflect() protoreflect.Message { + mi := &file_gitserver_proto_msgTypes[7] + 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 CommitLogResponse.ProtoReflect.Descriptor instead. +func (*CommitLogResponse) Descriptor() ([]byte, []int) { + return file_gitserver_proto_rawDescGZIP(), []int{7} +} + +func (x *CommitLogResponse) GetCommits() []*GetCommitResponse { + if x != nil { + return x.Commits + } + return nil +} + type ContributorCountsRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -728,7 +1010,7 @@ type ContributorCountsRequest struct { func (x *ContributorCountsRequest) Reset() { *x = ContributorCountsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[6] + mi := &file_gitserver_proto_msgTypes[8] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -741,7 +1023,7 @@ func (x *ContributorCountsRequest) String() string { func (*ContributorCountsRequest) ProtoMessage() {} func (x *ContributorCountsRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[6] + mi := &file_gitserver_proto_msgTypes[8] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -754,7 +1036,7 @@ func (x *ContributorCountsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ContributorCountsRequest.ProtoReflect.Descriptor instead. func (*ContributorCountsRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{6} + return file_gitserver_proto_rawDescGZIP(), []int{8} } func (x *ContributorCountsRequest) GetRepoName() string { @@ -797,7 +1079,7 @@ type ContributorCount struct { func (x *ContributorCount) Reset() { *x = ContributorCount{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[7] + mi := &file_gitserver_proto_msgTypes[9] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -810,7 +1092,7 @@ func (x *ContributorCount) String() string { func (*ContributorCount) ProtoMessage() {} func (x *ContributorCount) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[7] + mi := &file_gitserver_proto_msgTypes[9] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -823,7 +1105,7 @@ func (x *ContributorCount) ProtoReflect() protoreflect.Message { // Deprecated: Use ContributorCount.ProtoReflect.Descriptor instead. func (*ContributorCount) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{7} + return file_gitserver_proto_rawDescGZIP(), []int{9} } func (x *ContributorCount) GetAuthor() *GitSignature { @@ -851,7 +1133,7 @@ type ContributorCountsResponse struct { func (x *ContributorCountsResponse) Reset() { *x = ContributorCountsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[8] + mi := &file_gitserver_proto_msgTypes[10] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -864,7 +1146,7 @@ func (x *ContributorCountsResponse) String() string { func (*ContributorCountsResponse) ProtoMessage() {} func (x *ContributorCountsResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[8] + mi := &file_gitserver_proto_msgTypes[10] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -877,7 +1159,7 @@ func (x *ContributorCountsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ContributorCountsResponse.ProtoReflect.Descriptor instead. func (*ContributorCountsResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{8} + return file_gitserver_proto_rawDescGZIP(), []int{10} } func (x *ContributorCountsResponse) GetCounts() []*ContributorCount { @@ -912,7 +1194,7 @@ type RawDiffRequest struct { func (x *RawDiffRequest) Reset() { *x = RawDiffRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[9] + mi := &file_gitserver_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -925,7 +1207,7 @@ func (x *RawDiffRequest) String() string { func (*RawDiffRequest) ProtoMessage() {} func (x *RawDiffRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[9] + mi := &file_gitserver_proto_msgTypes[11] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -938,7 +1220,7 @@ func (x *RawDiffRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RawDiffRequest.ProtoReflect.Descriptor instead. func (*RawDiffRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{9} + return file_gitserver_proto_rawDescGZIP(), []int{11} } func (x *RawDiffRequest) GetRepoName() string { @@ -988,7 +1270,7 @@ type RawDiffResponse struct { func (x *RawDiffResponse) Reset() { *x = RawDiffResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[10] + mi := &file_gitserver_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1001,7 +1283,7 @@ func (x *RawDiffResponse) String() string { func (*RawDiffResponse) ProtoMessage() {} func (x *RawDiffResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[10] + mi := &file_gitserver_proto_msgTypes[12] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1014,7 +1296,7 @@ func (x *RawDiffResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RawDiffResponse.ProtoReflect.Descriptor instead. func (*RawDiffResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{10} + return file_gitserver_proto_rawDescGZIP(), []int{12} } func (x *RawDiffResponse) GetChunk() []byte { @@ -1046,7 +1328,7 @@ type ListRefsRequest struct { func (x *ListRefsRequest) Reset() { *x = ListRefsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[11] + mi := &file_gitserver_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1059,7 +1341,7 @@ func (x *ListRefsRequest) String() string { func (*ListRefsRequest) ProtoMessage() {} func (x *ListRefsRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[11] + mi := &file_gitserver_proto_msgTypes[13] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1072,7 +1354,7 @@ func (x *ListRefsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListRefsRequest.ProtoReflect.Descriptor instead. func (*ListRefsRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{11} + return file_gitserver_proto_rawDescGZIP(), []int{13} } func (x *ListRefsRequest) GetRepoName() string { @@ -1121,7 +1403,7 @@ type ListRefsResponse struct { func (x *ListRefsResponse) Reset() { *x = ListRefsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[12] + mi := &file_gitserver_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1134,7 +1416,7 @@ func (x *ListRefsResponse) String() string { func (*ListRefsResponse) ProtoMessage() {} func (x *ListRefsResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[12] + mi := &file_gitserver_proto_msgTypes[14] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1147,7 +1429,7 @@ func (x *ListRefsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListRefsResponse.ProtoReflect.Descriptor instead. func (*ListRefsResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{12} + return file_gitserver_proto_rawDescGZIP(), []int{14} } func (x *ListRefsResponse) GetRefs() []*GitRef { @@ -1188,7 +1470,7 @@ type GitRef struct { func (x *GitRef) Reset() { *x = GitRef{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[13] + mi := &file_gitserver_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1201,7 +1483,7 @@ func (x *GitRef) String() string { func (*GitRef) ProtoMessage() {} func (x *GitRef) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[13] + mi := &file_gitserver_proto_msgTypes[15] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1214,7 +1496,7 @@ func (x *GitRef) ProtoReflect() protoreflect.Message { // Deprecated: Use GitRef.ProtoReflect.Descriptor instead. func (*GitRef) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{13} + return file_gitserver_proto_rawDescGZIP(), []int{15} } func (x *GitRef) GetRefName() []byte { @@ -1283,7 +1565,7 @@ type StatRequest struct { func (x *StatRequest) Reset() { *x = StatRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[14] + mi := &file_gitserver_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1296,7 +1578,7 @@ func (x *StatRequest) String() string { func (*StatRequest) ProtoMessage() {} func (x *StatRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[14] + mi := &file_gitserver_proto_msgTypes[16] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1309,7 +1591,7 @@ func (x *StatRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use StatRequest.ProtoReflect.Descriptor instead. func (*StatRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{14} + return file_gitserver_proto_rawDescGZIP(), []int{16} } func (x *StatRequest) GetRepoName() string { @@ -1344,7 +1626,7 @@ type StatResponse struct { func (x *StatResponse) Reset() { *x = StatResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[15] + mi := &file_gitserver_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1357,7 +1639,7 @@ func (x *StatResponse) String() string { func (*StatResponse) ProtoMessage() {} func (x *StatResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[15] + mi := &file_gitserver_proto_msgTypes[17] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1370,7 +1652,7 @@ func (x *StatResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use StatResponse.ProtoReflect.Descriptor instead. func (*StatResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{15} + return file_gitserver_proto_rawDescGZIP(), []int{17} } func (x *StatResponse) GetFileInfo() *FileInfo { @@ -1399,7 +1681,7 @@ type ReadDirRequest struct { func (x *ReadDirRequest) Reset() { *x = ReadDirRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[16] + mi := &file_gitserver_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1412,7 +1694,7 @@ func (x *ReadDirRequest) String() string { func (*ReadDirRequest) ProtoMessage() {} func (x *ReadDirRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[16] + mi := &file_gitserver_proto_msgTypes[18] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1425,7 +1707,7 @@ func (x *ReadDirRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReadDirRequest.ProtoReflect.Descriptor instead. func (*ReadDirRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{16} + return file_gitserver_proto_rawDescGZIP(), []int{18} } func (x *ReadDirRequest) GetRepoName() string { @@ -1467,7 +1749,7 @@ type ReadDirResponse struct { func (x *ReadDirResponse) Reset() { *x = ReadDirResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[17] + mi := &file_gitserver_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1480,7 +1762,7 @@ func (x *ReadDirResponse) String() string { func (*ReadDirResponse) ProtoMessage() {} func (x *ReadDirResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[17] + mi := &file_gitserver_proto_msgTypes[19] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1493,7 +1775,7 @@ func (x *ReadDirResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReadDirResponse.ProtoReflect.Descriptor instead. func (*ReadDirResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{17} + return file_gitserver_proto_rawDescGZIP(), []int{19} } func (x *ReadDirResponse) GetFileInfo() []*FileInfo { @@ -1520,7 +1802,7 @@ type GitSubmodule struct { func (x *GitSubmodule) Reset() { *x = GitSubmodule{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[18] + mi := &file_gitserver_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1533,7 +1815,7 @@ func (x *GitSubmodule) String() string { func (*GitSubmodule) ProtoMessage() {} func (x *GitSubmodule) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[18] + mi := &file_gitserver_proto_msgTypes[20] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1546,7 +1828,7 @@ func (x *GitSubmodule) ProtoReflect() protoreflect.Message { // Deprecated: Use GitSubmodule.ProtoReflect.Descriptor instead. func (*GitSubmodule) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{18} + return file_gitserver_proto_rawDescGZIP(), []int{20} } func (x *GitSubmodule) GetUrl() string { @@ -1590,7 +1872,7 @@ type FileInfo struct { func (x *FileInfo) Reset() { *x = FileInfo{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[19] + mi := &file_gitserver_proto_msgTypes[21] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1603,7 +1885,7 @@ func (x *FileInfo) String() string { func (*FileInfo) ProtoMessage() {} func (x *FileInfo) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[19] + mi := &file_gitserver_proto_msgTypes[21] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1616,7 +1898,7 @@ func (x *FileInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use FileInfo.ProtoReflect.Descriptor instead. func (*FileInfo) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{19} + return file_gitserver_proto_rawDescGZIP(), []int{21} } func (x *FileInfo) GetName() []byte { @@ -1676,7 +1958,7 @@ type ResolveRevisionRequest struct { func (x *ResolveRevisionRequest) Reset() { *x = ResolveRevisionRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[20] + mi := &file_gitserver_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1689,7 +1971,7 @@ func (x *ResolveRevisionRequest) String() string { func (*ResolveRevisionRequest) ProtoMessage() {} func (x *ResolveRevisionRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[20] + mi := &file_gitserver_proto_msgTypes[22] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1702,7 +1984,7 @@ func (x *ResolveRevisionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveRevisionRequest.ProtoReflect.Descriptor instead. func (*ResolveRevisionRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{20} + return file_gitserver_proto_rawDescGZIP(), []int{22} } func (x *ResolveRevisionRequest) GetRepoName() string { @@ -1738,7 +2020,7 @@ type ResolveRevisionResponse struct { func (x *ResolveRevisionResponse) Reset() { *x = ResolveRevisionResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[21] + mi := &file_gitserver_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1751,7 +2033,7 @@ func (x *ResolveRevisionResponse) String() string { func (*ResolveRevisionResponse) ProtoMessage() {} func (x *ResolveRevisionResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[21] + mi := &file_gitserver_proto_msgTypes[23] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1764,7 +2046,7 @@ func (x *ResolveRevisionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ResolveRevisionResponse.ProtoReflect.Descriptor instead. func (*ResolveRevisionResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{21} + return file_gitserver_proto_rawDescGZIP(), []int{23} } func (x *ResolveRevisionResponse) GetCommitSha() string { @@ -1795,7 +2077,7 @@ type RevAtTimeRequest struct { func (x *RevAtTimeRequest) Reset() { *x = RevAtTimeRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[22] + mi := &file_gitserver_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1808,7 +2090,7 @@ func (x *RevAtTimeRequest) String() string { func (*RevAtTimeRequest) ProtoMessage() {} func (x *RevAtTimeRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[22] + mi := &file_gitserver_proto_msgTypes[24] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1821,7 +2103,7 @@ func (x *RevAtTimeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RevAtTimeRequest.ProtoReflect.Descriptor instead. func (*RevAtTimeRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{22} + return file_gitserver_proto_rawDescGZIP(), []int{24} } func (x *RevAtTimeRequest) GetRepoName() string { @@ -1857,7 +2139,7 @@ type RevAtTimeResponse struct { func (x *RevAtTimeResponse) Reset() { *x = RevAtTimeResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[23] + mi := &file_gitserver_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1870,7 +2152,7 @@ func (x *RevAtTimeResponse) String() string { func (*RevAtTimeResponse) ProtoMessage() {} func (x *RevAtTimeResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[23] + mi := &file_gitserver_proto_msgTypes[25] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1883,7 +2165,7 @@ func (x *RevAtTimeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RevAtTimeResponse.ProtoReflect.Descriptor instead. func (*RevAtTimeResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{23} + return file_gitserver_proto_rawDescGZIP(), []int{25} } func (x *RevAtTimeResponse) GetCommitSha() string { @@ -1910,7 +2192,7 @@ type GetCommitRequest struct { func (x *GetCommitRequest) Reset() { *x = GetCommitRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[24] + mi := &file_gitserver_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1923,7 +2205,7 @@ func (x *GetCommitRequest) String() string { func (*GetCommitRequest) ProtoMessage() {} func (x *GetCommitRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[24] + mi := &file_gitserver_proto_msgTypes[26] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1936,7 +2218,7 @@ func (x *GetCommitRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetCommitRequest.ProtoReflect.Descriptor instead. func (*GetCommitRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{24} + return file_gitserver_proto_rawDescGZIP(), []int{26} } func (x *GetCommitRequest) GetRepoName() string { @@ -1975,7 +2257,7 @@ type GetCommitResponse struct { func (x *GetCommitResponse) Reset() { *x = GetCommitResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[25] + mi := &file_gitserver_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1988,7 +2270,7 @@ func (x *GetCommitResponse) String() string { func (*GetCommitResponse) ProtoMessage() {} func (x *GetCommitResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[25] + mi := &file_gitserver_proto_msgTypes[27] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2001,7 +2283,7 @@ func (x *GetCommitResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetCommitResponse.ProtoReflect.Descriptor instead. func (*GetCommitResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{25} + return file_gitserver_proto_rawDescGZIP(), []int{27} } func (x *GetCommitResponse) GetCommit() *GitCommit { @@ -2033,7 +2315,7 @@ type GitCommit struct { func (x *GitCommit) Reset() { *x = GitCommit{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[26] + mi := &file_gitserver_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2046,7 +2328,7 @@ func (x *GitCommit) String() string { func (*GitCommit) ProtoMessage() {} func (x *GitCommit) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[26] + mi := &file_gitserver_proto_msgTypes[28] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2059,7 +2341,7 @@ func (x *GitCommit) ProtoReflect() protoreflect.Message { // Deprecated: Use GitCommit.ProtoReflect.Descriptor instead. func (*GitCommit) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{26} + return file_gitserver_proto_rawDescGZIP(), []int{28} } func (x *GitCommit) GetOid() string { @@ -2110,7 +2392,7 @@ type GitSignature struct { func (x *GitSignature) Reset() { *x = GitSignature{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[27] + mi := &file_gitserver_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2123,7 +2405,7 @@ func (x *GitSignature) String() string { func (*GitSignature) ProtoMessage() {} func (x *GitSignature) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[27] + mi := &file_gitserver_proto_msgTypes[29] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2136,7 +2418,7 @@ func (x *GitSignature) ProtoReflect() protoreflect.Message { // Deprecated: Use GitSignature.ProtoReflect.Descriptor instead. func (*GitSignature) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{27} + return file_gitserver_proto_rawDescGZIP(), []int{29} } func (x *GitSignature) GetName() []byte { @@ -2178,7 +2460,7 @@ type BlameRequest struct { func (x *BlameRequest) Reset() { *x = BlameRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[28] + mi := &file_gitserver_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2191,7 +2473,7 @@ func (x *BlameRequest) String() string { func (*BlameRequest) ProtoMessage() {} func (x *BlameRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[28] + mi := &file_gitserver_proto_msgTypes[30] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2204,7 +2486,7 @@ func (x *BlameRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use BlameRequest.ProtoReflect.Descriptor instead. func (*BlameRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{28} + return file_gitserver_proto_rawDescGZIP(), []int{30} } func (x *BlameRequest) GetRepoName() string { @@ -2254,7 +2536,7 @@ type BlameRange struct { func (x *BlameRange) Reset() { *x = BlameRange{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[29] + mi := &file_gitserver_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2267,7 +2549,7 @@ func (x *BlameRange) String() string { func (*BlameRange) ProtoMessage() {} func (x *BlameRange) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[29] + mi := &file_gitserver_proto_msgTypes[31] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2280,7 +2562,7 @@ func (x *BlameRange) ProtoReflect() protoreflect.Message { // Deprecated: Use BlameRange.ProtoReflect.Descriptor instead. func (*BlameRange) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{29} + return file_gitserver_proto_rawDescGZIP(), []int{31} } func (x *BlameRange) GetStartLine() uint32 { @@ -2308,7 +2590,7 @@ type BlameResponse struct { func (x *BlameResponse) Reset() { *x = BlameResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[30] + mi := &file_gitserver_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2321,7 +2603,7 @@ func (x *BlameResponse) String() string { func (*BlameResponse) ProtoMessage() {} func (x *BlameResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[30] + mi := &file_gitserver_proto_msgTypes[32] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2334,7 +2616,7 @@ func (x *BlameResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use BlameResponse.ProtoReflect.Descriptor instead. func (*BlameResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{30} + return file_gitserver_proto_rawDescGZIP(), []int{32} } func (x *BlameResponse) GetHunk() *BlameHunk { @@ -2363,7 +2645,7 @@ type BlameHunk struct { func (x *BlameHunk) Reset() { *x = BlameHunk{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[31] + mi := &file_gitserver_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2376,7 +2658,7 @@ func (x *BlameHunk) String() string { func (*BlameHunk) ProtoMessage() {} func (x *BlameHunk) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[31] + mi := &file_gitserver_proto_msgTypes[33] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2389,7 +2671,7 @@ func (x *BlameHunk) ProtoReflect() protoreflect.Message { // Deprecated: Use BlameHunk.ProtoReflect.Descriptor instead. func (*BlameHunk) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{31} + return file_gitserver_proto_rawDescGZIP(), []int{33} } func (x *BlameHunk) GetStartLine() uint32 { @@ -2468,7 +2750,7 @@ type BlameAuthor struct { func (x *BlameAuthor) Reset() { *x = BlameAuthor{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[32] + mi := &file_gitserver_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2481,7 +2763,7 @@ func (x *BlameAuthor) String() string { func (*BlameAuthor) ProtoMessage() {} func (x *BlameAuthor) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[32] + mi := &file_gitserver_proto_msgTypes[34] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2494,7 +2776,7 @@ func (x *BlameAuthor) ProtoReflect() protoreflect.Message { // Deprecated: Use BlameAuthor.ProtoReflect.Descriptor instead. func (*BlameAuthor) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{32} + return file_gitserver_proto_rawDescGZIP(), []int{34} } func (x *BlameAuthor) GetName() string { @@ -2530,7 +2812,7 @@ type PreviousCommit struct { func (x *PreviousCommit) Reset() { *x = PreviousCommit{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[33] + mi := &file_gitserver_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2543,7 +2825,7 @@ func (x *PreviousCommit) String() string { func (*PreviousCommit) ProtoMessage() {} func (x *PreviousCommit) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[33] + mi := &file_gitserver_proto_msgTypes[35] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2556,7 +2838,7 @@ func (x *PreviousCommit) ProtoReflect() protoreflect.Message { // Deprecated: Use PreviousCommit.ProtoReflect.Descriptor instead. func (*PreviousCommit) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{33} + return file_gitserver_proto_rawDescGZIP(), []int{35} } func (x *PreviousCommit) GetCommit() string { @@ -2587,7 +2869,7 @@ type DefaultBranchRequest struct { func (x *DefaultBranchRequest) Reset() { *x = DefaultBranchRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[34] + mi := &file_gitserver_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2600,7 +2882,7 @@ func (x *DefaultBranchRequest) String() string { func (*DefaultBranchRequest) ProtoMessage() {} func (x *DefaultBranchRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[34] + mi := &file_gitserver_proto_msgTypes[36] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2613,7 +2895,7 @@ func (x *DefaultBranchRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DefaultBranchRequest.ProtoReflect.Descriptor instead. func (*DefaultBranchRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{34} + return file_gitserver_proto_rawDescGZIP(), []int{36} } func (x *DefaultBranchRequest) GetRepoName() string { @@ -2642,7 +2924,7 @@ type DefaultBranchResponse struct { func (x *DefaultBranchResponse) Reset() { *x = DefaultBranchResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[35] + mi := &file_gitserver_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2655,7 +2937,7 @@ func (x *DefaultBranchResponse) String() string { func (*DefaultBranchResponse) ProtoMessage() {} func (x *DefaultBranchResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[35] + mi := &file_gitserver_proto_msgTypes[37] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2668,7 +2950,7 @@ func (x *DefaultBranchResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DefaultBranchResponse.ProtoReflect.Descriptor instead. func (*DefaultBranchResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{35} + return file_gitserver_proto_rawDescGZIP(), []int{37} } func (x *DefaultBranchResponse) GetRefName() string { @@ -2700,7 +2982,7 @@ type ReadFileRequest struct { func (x *ReadFileRequest) Reset() { *x = ReadFileRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[36] + mi := &file_gitserver_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2713,7 +2995,7 @@ func (x *ReadFileRequest) String() string { func (*ReadFileRequest) ProtoMessage() {} func (x *ReadFileRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[36] + mi := &file_gitserver_proto_msgTypes[38] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2726,7 +3008,7 @@ func (x *ReadFileRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReadFileRequest.ProtoReflect.Descriptor instead. func (*ReadFileRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{36} + return file_gitserver_proto_rawDescGZIP(), []int{38} } func (x *ReadFileRequest) GetRepoName() string { @@ -2761,7 +3043,7 @@ type ReadFileResponse struct { func (x *ReadFileResponse) Reset() { *x = ReadFileResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[37] + mi := &file_gitserver_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2774,7 +3056,7 @@ func (x *ReadFileResponse) String() string { func (*ReadFileResponse) ProtoMessage() {} func (x *ReadFileResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[37] + mi := &file_gitserver_proto_msgTypes[39] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2787,7 +3069,7 @@ func (x *ReadFileResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReadFileResponse.ProtoReflect.Descriptor instead. func (*ReadFileResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{37} + return file_gitserver_proto_rawDescGZIP(), []int{39} } func (x *ReadFileResponse) GetData() []byte { @@ -2807,7 +3089,7 @@ type DiskInfoRequest struct { func (x *DiskInfoRequest) Reset() { *x = DiskInfoRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[38] + mi := &file_gitserver_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2820,7 +3102,7 @@ func (x *DiskInfoRequest) String() string { func (*DiskInfoRequest) ProtoMessage() {} func (x *DiskInfoRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[38] + mi := &file_gitserver_proto_msgTypes[40] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2833,7 +3115,7 @@ func (x *DiskInfoRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DiskInfoRequest.ProtoReflect.Descriptor instead. func (*DiskInfoRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{38} + return file_gitserver_proto_rawDescGZIP(), []int{40} } // DiskInfoResponse contains the results of the DiskInfo RPC request. @@ -2853,7 +3135,7 @@ type DiskInfoResponse struct { func (x *DiskInfoResponse) Reset() { *x = DiskInfoResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[39] + mi := &file_gitserver_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2866,7 +3148,7 @@ func (x *DiskInfoResponse) String() string { func (*DiskInfoResponse) ProtoMessage() {} func (x *DiskInfoResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[39] + mi := &file_gitserver_proto_msgTypes[41] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2879,7 +3161,7 @@ func (x *DiskInfoResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DiskInfoResponse.ProtoReflect.Descriptor instead. func (*DiskInfoResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{39} + return file_gitserver_proto_rawDescGZIP(), []int{41} } func (x *DiskInfoResponse) GetFreeSpace() uint64 { @@ -2925,7 +3207,7 @@ type PatchCommitInfo struct { func (x *PatchCommitInfo) Reset() { *x = PatchCommitInfo{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[40] + mi := &file_gitserver_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2938,7 +3220,7 @@ func (x *PatchCommitInfo) String() string { func (*PatchCommitInfo) ProtoMessage() {} func (x *PatchCommitInfo) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[40] + mi := &file_gitserver_proto_msgTypes[42] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2951,7 +3233,7 @@ func (x *PatchCommitInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use PatchCommitInfo.ProtoReflect.Descriptor instead. func (*PatchCommitInfo) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{40} + return file_gitserver_proto_rawDescGZIP(), []int{42} } func (x *PatchCommitInfo) GetMessages() []string { @@ -3017,7 +3299,7 @@ type PushConfig struct { func (x *PushConfig) Reset() { *x = PushConfig{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[41] + mi := &file_gitserver_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3030,7 +3312,7 @@ func (x *PushConfig) String() string { func (*PushConfig) ProtoMessage() {} func (x *PushConfig) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[41] + mi := &file_gitserver_proto_msgTypes[43] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3043,7 +3325,7 @@ func (x *PushConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use PushConfig.ProtoReflect.Descriptor instead. func (*PushConfig) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{41} + return file_gitserver_proto_rawDescGZIP(), []int{43} } func (x *PushConfig) GetRemoteUrl() string { @@ -3084,7 +3366,7 @@ type CreateCommitFromPatchBinaryRequest struct { func (x *CreateCommitFromPatchBinaryRequest) Reset() { *x = CreateCommitFromPatchBinaryRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[42] + mi := &file_gitserver_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3097,7 +3379,7 @@ func (x *CreateCommitFromPatchBinaryRequest) String() string { func (*CreateCommitFromPatchBinaryRequest) ProtoMessage() {} func (x *CreateCommitFromPatchBinaryRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[42] + mi := &file_gitserver_proto_msgTypes[44] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3110,7 +3392,7 @@ func (x *CreateCommitFromPatchBinaryRequest) ProtoReflect() protoreflect.Message // Deprecated: Use CreateCommitFromPatchBinaryRequest.ProtoReflect.Descriptor instead. func (*CreateCommitFromPatchBinaryRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{42} + return file_gitserver_proto_rawDescGZIP(), []int{44} } func (m *CreateCommitFromPatchBinaryRequest) GetPayload() isCreateCommitFromPatchBinaryRequest_Payload { @@ -3168,7 +3450,7 @@ type CreateCommitFromPatchError struct { func (x *CreateCommitFromPatchError) Reset() { *x = CreateCommitFromPatchError{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[43] + mi := &file_gitserver_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3181,7 +3463,7 @@ func (x *CreateCommitFromPatchError) String() string { func (*CreateCommitFromPatchError) ProtoMessage() {} func (x *CreateCommitFromPatchError) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[43] + mi := &file_gitserver_proto_msgTypes[45] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3194,7 +3476,7 @@ func (x *CreateCommitFromPatchError) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateCommitFromPatchError.ProtoReflect.Descriptor instead. func (*CreateCommitFromPatchError) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{43} + return file_gitserver_proto_rawDescGZIP(), []int{45} } func (x *CreateCommitFromPatchError) GetRepositoryName() string { @@ -3241,7 +3523,7 @@ type CreateCommitFromPatchBinaryResponse struct { func (x *CreateCommitFromPatchBinaryResponse) Reset() { *x = CreateCommitFromPatchBinaryResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[44] + mi := &file_gitserver_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3254,7 +3536,7 @@ func (x *CreateCommitFromPatchBinaryResponse) String() string { func (*CreateCommitFromPatchBinaryResponse) ProtoMessage() {} func (x *CreateCommitFromPatchBinaryResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[44] + mi := &file_gitserver_proto_msgTypes[46] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3267,7 +3549,7 @@ func (x *CreateCommitFromPatchBinaryResponse) ProtoReflect() protoreflect.Messag // Deprecated: Use CreateCommitFromPatchBinaryResponse.ProtoReflect.Descriptor instead. func (*CreateCommitFromPatchBinaryResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{44} + return file_gitserver_proto_rawDescGZIP(), []int{46} } func (x *CreateCommitFromPatchBinaryResponse) GetRev() string { @@ -3301,7 +3583,7 @@ type ExecRequest struct { func (x *ExecRequest) Reset() { *x = ExecRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[45] + mi := &file_gitserver_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3314,7 +3596,7 @@ func (x *ExecRequest) String() string { func (*ExecRequest) ProtoMessage() {} func (x *ExecRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[45] + mi := &file_gitserver_proto_msgTypes[47] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3327,7 +3609,7 @@ func (x *ExecRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecRequest.ProtoReflect.Descriptor instead. func (*ExecRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{45} + return file_gitserver_proto_rawDescGZIP(), []int{47} } func (x *ExecRequest) GetRepo() string { @@ -3378,7 +3660,7 @@ type ExecResponse struct { func (x *ExecResponse) Reset() { *x = ExecResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[46] + mi := &file_gitserver_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3391,7 +3673,7 @@ func (x *ExecResponse) String() string { func (*ExecResponse) ProtoMessage() {} func (x *ExecResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[46] + mi := &file_gitserver_proto_msgTypes[48] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3404,7 +3686,7 @@ func (x *ExecResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecResponse.ProtoReflect.Descriptor instead. func (*ExecResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{46} + return file_gitserver_proto_rawDescGZIP(), []int{48} } func (x *ExecResponse) GetData() []byte { @@ -3427,7 +3709,7 @@ type RepoNotFoundPayload struct { func (x *RepoNotFoundPayload) Reset() { *x = RepoNotFoundPayload{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[47] + mi := &file_gitserver_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3440,7 +3722,7 @@ func (x *RepoNotFoundPayload) String() string { func (*RepoNotFoundPayload) ProtoMessage() {} func (x *RepoNotFoundPayload) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[47] + mi := &file_gitserver_proto_msgTypes[49] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3453,7 +3735,7 @@ func (x *RepoNotFoundPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use RepoNotFoundPayload.ProtoReflect.Descriptor instead. func (*RepoNotFoundPayload) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{47} + return file_gitserver_proto_rawDescGZIP(), []int{49} } func (x *RepoNotFoundPayload) GetRepo() string { @@ -3489,7 +3771,7 @@ type RevisionNotFoundPayload struct { func (x *RevisionNotFoundPayload) Reset() { *x = RevisionNotFoundPayload{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[48] + mi := &file_gitserver_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3502,7 +3784,7 @@ func (x *RevisionNotFoundPayload) String() string { func (*RevisionNotFoundPayload) ProtoMessage() {} func (x *RevisionNotFoundPayload) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[48] + mi := &file_gitserver_proto_msgTypes[50] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3515,7 +3797,7 @@ func (x *RevisionNotFoundPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use RevisionNotFoundPayload.ProtoReflect.Descriptor instead. func (*RevisionNotFoundPayload) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{48} + return file_gitserver_proto_rawDescGZIP(), []int{50} } func (x *RevisionNotFoundPayload) GetRepo() string { @@ -3545,7 +3827,7 @@ type FileNotFoundPayload struct { func (x *FileNotFoundPayload) Reset() { *x = FileNotFoundPayload{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[49] + mi := &file_gitserver_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3558,7 +3840,7 @@ func (x *FileNotFoundPayload) String() string { func (*FileNotFoundPayload) ProtoMessage() {} func (x *FileNotFoundPayload) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[49] + mi := &file_gitserver_proto_msgTypes[51] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3571,7 +3853,7 @@ func (x *FileNotFoundPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use FileNotFoundPayload.ProtoReflect.Descriptor instead. func (*FileNotFoundPayload) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{49} + return file_gitserver_proto_rawDescGZIP(), []int{51} } func (x *FileNotFoundPayload) GetRepo() string { @@ -3607,7 +3889,7 @@ type ExecStatusPayload struct { func (x *ExecStatusPayload) Reset() { *x = ExecStatusPayload{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[50] + mi := &file_gitserver_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3620,7 +3902,7 @@ func (x *ExecStatusPayload) String() string { func (*ExecStatusPayload) ProtoMessage() {} func (x *ExecStatusPayload) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[50] + mi := &file_gitserver_proto_msgTypes[52] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3633,7 +3915,7 @@ func (x *ExecStatusPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecStatusPayload.ProtoReflect.Descriptor instead. func (*ExecStatusPayload) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{50} + return file_gitserver_proto_rawDescGZIP(), []int{52} } func (x *ExecStatusPayload) GetStatusCode() int32 { @@ -3677,7 +3959,7 @@ type SearchRequest struct { func (x *SearchRequest) Reset() { *x = SearchRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[51] + mi := &file_gitserver_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3690,7 +3972,7 @@ func (x *SearchRequest) String() string { func (*SearchRequest) ProtoMessage() {} func (x *SearchRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[51] + mi := &file_gitserver_proto_msgTypes[53] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3703,7 +3985,7 @@ func (x *SearchRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SearchRequest.ProtoReflect.Descriptor instead. func (*SearchRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{51} + return file_gitserver_proto_rawDescGZIP(), []int{53} } func (x *SearchRequest) GetRepo() string { @@ -3761,7 +4043,7 @@ type RevisionSpecifier struct { func (x *RevisionSpecifier) Reset() { *x = RevisionSpecifier{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[52] + mi := &file_gitserver_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3774,7 +4056,7 @@ func (x *RevisionSpecifier) String() string { func (*RevisionSpecifier) ProtoMessage() {} func (x *RevisionSpecifier) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[52] + mi := &file_gitserver_proto_msgTypes[54] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3787,7 +4069,7 @@ func (x *RevisionSpecifier) ProtoReflect() protoreflect.Message { // Deprecated: Use RevisionSpecifier.ProtoReflect.Descriptor instead. func (*RevisionSpecifier) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{52} + return file_gitserver_proto_rawDescGZIP(), []int{54} } func (x *RevisionSpecifier) GetRevSpec() string { @@ -3811,7 +4093,7 @@ type AuthorMatchesNode struct { func (x *AuthorMatchesNode) Reset() { *x = AuthorMatchesNode{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[53] + mi := &file_gitserver_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3824,7 +4106,7 @@ func (x *AuthorMatchesNode) String() string { func (*AuthorMatchesNode) ProtoMessage() {} func (x *AuthorMatchesNode) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[53] + mi := &file_gitserver_proto_msgTypes[55] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3837,7 +4119,7 @@ func (x *AuthorMatchesNode) ProtoReflect() protoreflect.Message { // Deprecated: Use AuthorMatchesNode.ProtoReflect.Descriptor instead. func (*AuthorMatchesNode) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{53} + return file_gitserver_proto_rawDescGZIP(), []int{55} } func (x *AuthorMatchesNode) GetExpr() string { @@ -3868,7 +4150,7 @@ type CommitterMatchesNode struct { func (x *CommitterMatchesNode) Reset() { *x = CommitterMatchesNode{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[54] + mi := &file_gitserver_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3881,7 +4163,7 @@ func (x *CommitterMatchesNode) String() string { func (*CommitterMatchesNode) ProtoMessage() {} func (x *CommitterMatchesNode) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[54] + mi := &file_gitserver_proto_msgTypes[56] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3894,7 +4176,7 @@ func (x *CommitterMatchesNode) ProtoReflect() protoreflect.Message { // Deprecated: Use CommitterMatchesNode.ProtoReflect.Descriptor instead. func (*CommitterMatchesNode) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{54} + return file_gitserver_proto_rawDescGZIP(), []int{56} } func (x *CommitterMatchesNode) GetExpr() string { @@ -3924,7 +4206,7 @@ type CommitBeforeNode struct { func (x *CommitBeforeNode) Reset() { *x = CommitBeforeNode{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[55] + mi := &file_gitserver_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3937,7 +4219,7 @@ func (x *CommitBeforeNode) String() string { func (*CommitBeforeNode) ProtoMessage() {} func (x *CommitBeforeNode) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[55] + mi := &file_gitserver_proto_msgTypes[57] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3950,7 +4232,7 @@ func (x *CommitBeforeNode) ProtoReflect() protoreflect.Message { // Deprecated: Use CommitBeforeNode.ProtoReflect.Descriptor instead. func (*CommitBeforeNode) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{55} + return file_gitserver_proto_rawDescGZIP(), []int{57} } func (x *CommitBeforeNode) GetTimestamp() *timestamppb.Timestamp { @@ -3973,7 +4255,7 @@ type CommitAfterNode struct { func (x *CommitAfterNode) Reset() { *x = CommitAfterNode{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[56] + mi := &file_gitserver_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3986,7 +4268,7 @@ func (x *CommitAfterNode) String() string { func (*CommitAfterNode) ProtoMessage() {} func (x *CommitAfterNode) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[56] + mi := &file_gitserver_proto_msgTypes[58] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3999,7 +4281,7 @@ func (x *CommitAfterNode) ProtoReflect() protoreflect.Message { // Deprecated: Use CommitAfterNode.ProtoReflect.Descriptor instead. func (*CommitAfterNode) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{56} + return file_gitserver_proto_rawDescGZIP(), []int{58} } func (x *CommitAfterNode) GetTimestamp() *timestamppb.Timestamp { @@ -4023,7 +4305,7 @@ type MessageMatchesNode struct { func (x *MessageMatchesNode) Reset() { *x = MessageMatchesNode{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[57] + mi := &file_gitserver_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4036,7 +4318,7 @@ func (x *MessageMatchesNode) String() string { func (*MessageMatchesNode) ProtoMessage() {} func (x *MessageMatchesNode) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[57] + mi := &file_gitserver_proto_msgTypes[59] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4049,7 +4331,7 @@ func (x *MessageMatchesNode) ProtoReflect() protoreflect.Message { // Deprecated: Use MessageMatchesNode.ProtoReflect.Descriptor instead. func (*MessageMatchesNode) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{57} + return file_gitserver_proto_rawDescGZIP(), []int{59} } func (x *MessageMatchesNode) GetExpr() string { @@ -4080,7 +4362,7 @@ type DiffMatchesNode struct { func (x *DiffMatchesNode) Reset() { *x = DiffMatchesNode{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[58] + mi := &file_gitserver_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4093,7 +4375,7 @@ func (x *DiffMatchesNode) String() string { func (*DiffMatchesNode) ProtoMessage() {} func (x *DiffMatchesNode) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[58] + mi := &file_gitserver_proto_msgTypes[60] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4106,7 +4388,7 @@ func (x *DiffMatchesNode) ProtoReflect() protoreflect.Message { // Deprecated: Use DiffMatchesNode.ProtoReflect.Descriptor instead. func (*DiffMatchesNode) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{58} + return file_gitserver_proto_rawDescGZIP(), []int{60} } func (x *DiffMatchesNode) GetExpr() string { @@ -4137,7 +4419,7 @@ type DiffModifiesFileNode struct { func (x *DiffModifiesFileNode) Reset() { *x = DiffModifiesFileNode{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[59] + mi := &file_gitserver_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4150,7 +4432,7 @@ func (x *DiffModifiesFileNode) String() string { func (*DiffModifiesFileNode) ProtoMessage() {} func (x *DiffModifiesFileNode) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[59] + mi := &file_gitserver_proto_msgTypes[61] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4163,7 +4445,7 @@ func (x *DiffModifiesFileNode) ProtoReflect() protoreflect.Message { // Deprecated: Use DiffModifiesFileNode.ProtoReflect.Descriptor instead. func (*DiffModifiesFileNode) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{59} + return file_gitserver_proto_rawDescGZIP(), []int{61} } func (x *DiffModifiesFileNode) GetExpr() string { @@ -4192,7 +4474,7 @@ type BooleanNode struct { func (x *BooleanNode) Reset() { *x = BooleanNode{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[60] + mi := &file_gitserver_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4205,7 +4487,7 @@ func (x *BooleanNode) String() string { func (*BooleanNode) ProtoMessage() {} func (x *BooleanNode) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[60] + mi := &file_gitserver_proto_msgTypes[62] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4218,7 +4500,7 @@ func (x *BooleanNode) ProtoReflect() protoreflect.Message { // Deprecated: Use BooleanNode.ProtoReflect.Descriptor instead. func (*BooleanNode) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{60} + return file_gitserver_proto_rawDescGZIP(), []int{62} } func (x *BooleanNode) GetValue() bool { @@ -4240,7 +4522,7 @@ type OperatorNode struct { func (x *OperatorNode) Reset() { *x = OperatorNode{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[61] + mi := &file_gitserver_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4253,7 +4535,7 @@ func (x *OperatorNode) String() string { func (*OperatorNode) ProtoMessage() {} func (x *OperatorNode) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[61] + mi := &file_gitserver_proto_msgTypes[63] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4266,7 +4548,7 @@ func (x *OperatorNode) ProtoReflect() protoreflect.Message { // Deprecated: Use OperatorNode.ProtoReflect.Descriptor instead. func (*OperatorNode) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{61} + return file_gitserver_proto_rawDescGZIP(), []int{63} } func (x *OperatorNode) GetKind() OperatorKind { @@ -4305,7 +4587,7 @@ type QueryNode struct { func (x *QueryNode) Reset() { *x = QueryNode{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[62] + mi := &file_gitserver_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4318,7 +4600,7 @@ func (x *QueryNode) String() string { func (*QueryNode) ProtoMessage() {} func (x *QueryNode) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[62] + mi := &file_gitserver_proto_msgTypes[64] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4331,7 +4613,7 @@ func (x *QueryNode) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryNode.ProtoReflect.Descriptor instead. func (*QueryNode) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{62} + return file_gitserver_proto_rawDescGZIP(), []int{64} } func (m *QueryNode) GetValue() isQueryNode_Value { @@ -4477,7 +4759,7 @@ type SearchResponse struct { func (x *SearchResponse) Reset() { *x = SearchResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[63] + mi := &file_gitserver_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4490,7 +4772,7 @@ func (x *SearchResponse) String() string { func (*SearchResponse) ProtoMessage() {} func (x *SearchResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[63] + mi := &file_gitserver_proto_msgTypes[65] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4503,7 +4785,7 @@ func (x *SearchResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SearchResponse.ProtoReflect.Descriptor instead. func (*SearchResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{63} + return file_gitserver_proto_rawDescGZIP(), []int{65} } func (m *SearchResponse) GetMessage() isSearchResponse_Message { @@ -4571,7 +4853,7 @@ type CommitMatch struct { func (x *CommitMatch) Reset() { *x = CommitMatch{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[64] + mi := &file_gitserver_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4584,7 +4866,7 @@ func (x *CommitMatch) String() string { func (*CommitMatch) ProtoMessage() {} func (x *CommitMatch) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[64] + mi := &file_gitserver_proto_msgTypes[66] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4597,7 +4879,7 @@ func (x *CommitMatch) ProtoReflect() protoreflect.Message { // Deprecated: Use CommitMatch.ProtoReflect.Descriptor instead. func (*CommitMatch) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{64} + return file_gitserver_proto_rawDescGZIP(), []int{66} } func (x *CommitMatch) GetOid() string { @@ -4683,7 +4965,7 @@ type ArchiveRequest struct { func (x *ArchiveRequest) Reset() { *x = ArchiveRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[65] + mi := &file_gitserver_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4696,7 +4978,7 @@ func (x *ArchiveRequest) String() string { func (*ArchiveRequest) ProtoMessage() {} func (x *ArchiveRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[65] + mi := &file_gitserver_proto_msgTypes[67] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4709,7 +4991,7 @@ func (x *ArchiveRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ArchiveRequest.ProtoReflect.Descriptor instead. func (*ArchiveRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{65} + return file_gitserver_proto_rawDescGZIP(), []int{67} } func (x *ArchiveRequest) GetRepo() string { @@ -4753,7 +5035,7 @@ type ArchiveResponse struct { func (x *ArchiveResponse) Reset() { *x = ArchiveResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[66] + mi := &file_gitserver_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4766,7 +5048,7 @@ func (x *ArchiveResponse) String() string { func (*ArchiveResponse) ProtoMessage() {} func (x *ArchiveResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[66] + mi := &file_gitserver_proto_msgTypes[68] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4779,7 +5061,7 @@ func (x *ArchiveResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ArchiveResponse.ProtoReflect.Descriptor instead. func (*ArchiveResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{66} + return file_gitserver_proto_rawDescGZIP(), []int{68} } func (x *ArchiveResponse) GetData() []byte { @@ -4802,7 +5084,7 @@ type IsRepoCloneableRequest struct { func (x *IsRepoCloneableRequest) Reset() { *x = IsRepoCloneableRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[67] + mi := &file_gitserver_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4815,7 +5097,7 @@ func (x *IsRepoCloneableRequest) String() string { func (*IsRepoCloneableRequest) ProtoMessage() {} func (x *IsRepoCloneableRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[67] + mi := &file_gitserver_proto_msgTypes[69] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4828,7 +5110,7 @@ func (x *IsRepoCloneableRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use IsRepoCloneableRequest.ProtoReflect.Descriptor instead. func (*IsRepoCloneableRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{67} + return file_gitserver_proto_rawDescGZIP(), []int{69} } func (x *IsRepoCloneableRequest) GetRepo() string { @@ -4855,7 +5137,7 @@ type IsRepoCloneableResponse struct { func (x *IsRepoCloneableResponse) Reset() { *x = IsRepoCloneableResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[68] + mi := &file_gitserver_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4868,7 +5150,7 @@ func (x *IsRepoCloneableResponse) String() string { func (*IsRepoCloneableResponse) ProtoMessage() {} func (x *IsRepoCloneableResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[68] + mi := &file_gitserver_proto_msgTypes[70] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4881,7 +5163,7 @@ func (x *IsRepoCloneableResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use IsRepoCloneableResponse.ProtoReflect.Descriptor instead. func (*IsRepoCloneableResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{68} + return file_gitserver_proto_rawDescGZIP(), []int{70} } func (x *IsRepoCloneableResponse) GetCloneable() bool { @@ -4919,7 +5201,7 @@ type RepoCloneProgressRequest struct { func (x *RepoCloneProgressRequest) Reset() { *x = RepoCloneProgressRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[69] + mi := &file_gitserver_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4932,7 +5214,7 @@ func (x *RepoCloneProgressRequest) String() string { func (*RepoCloneProgressRequest) ProtoMessage() {} func (x *RepoCloneProgressRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[69] + mi := &file_gitserver_proto_msgTypes[71] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4945,7 +5227,7 @@ func (x *RepoCloneProgressRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RepoCloneProgressRequest.ProtoReflect.Descriptor instead. func (*RepoCloneProgressRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{69} + return file_gitserver_proto_rawDescGZIP(), []int{71} } func (x *RepoCloneProgressRequest) GetRepoName() string { @@ -4973,7 +5255,7 @@ type RepoCloneProgressResponse struct { func (x *RepoCloneProgressResponse) Reset() { *x = RepoCloneProgressResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[70] + mi := &file_gitserver_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4986,7 +5268,7 @@ func (x *RepoCloneProgressResponse) String() string { func (*RepoCloneProgressResponse) ProtoMessage() {} func (x *RepoCloneProgressResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[70] + mi := &file_gitserver_proto_msgTypes[72] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4999,7 +5281,7 @@ func (x *RepoCloneProgressResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RepoCloneProgressResponse.ProtoReflect.Descriptor instead. func (*RepoCloneProgressResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{70} + return file_gitserver_proto_rawDescGZIP(), []int{72} } func (x *RepoCloneProgressResponse) GetCloneInProgress() bool { @@ -5036,7 +5318,7 @@ type ListGitoliteRequest struct { func (x *ListGitoliteRequest) Reset() { *x = ListGitoliteRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[71] + mi := &file_gitserver_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5049,7 +5331,7 @@ func (x *ListGitoliteRequest) String() string { func (*ListGitoliteRequest) ProtoMessage() {} func (x *ListGitoliteRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[71] + mi := &file_gitserver_proto_msgTypes[73] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5062,7 +5344,7 @@ func (x *ListGitoliteRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListGitoliteRequest.ProtoReflect.Descriptor instead. func (*ListGitoliteRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{71} + return file_gitserver_proto_rawDescGZIP(), []int{73} } func (x *ListGitoliteRequest) GetGitoliteHost() string { @@ -5087,7 +5369,7 @@ type GitoliteRepo struct { func (x *GitoliteRepo) Reset() { *x = GitoliteRepo{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[72] + mi := &file_gitserver_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5100,7 +5382,7 @@ func (x *GitoliteRepo) String() string { func (*GitoliteRepo) ProtoMessage() {} func (x *GitoliteRepo) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[72] + mi := &file_gitserver_proto_msgTypes[74] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5113,7 +5395,7 @@ func (x *GitoliteRepo) ProtoReflect() protoreflect.Message { // Deprecated: Use GitoliteRepo.ProtoReflect.Descriptor instead. func (*GitoliteRepo) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{72} + return file_gitserver_proto_rawDescGZIP(), []int{74} } func (x *GitoliteRepo) GetName() string { @@ -5143,7 +5425,7 @@ type ListGitoliteResponse struct { func (x *ListGitoliteResponse) Reset() { *x = ListGitoliteResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[73] + mi := &file_gitserver_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5156,7 +5438,7 @@ func (x *ListGitoliteResponse) String() string { func (*ListGitoliteResponse) ProtoMessage() {} func (x *ListGitoliteResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[73] + mi := &file_gitserver_proto_msgTypes[75] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5169,7 +5451,7 @@ func (x *ListGitoliteResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListGitoliteResponse.ProtoReflect.Descriptor instead. func (*ListGitoliteResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{73} + return file_gitserver_proto_rawDescGZIP(), []int{75} } func (x *ListGitoliteResponse) GetRepos() []*GitoliteRepo { @@ -5194,7 +5476,7 @@ type GetObjectRequest struct { func (x *GetObjectRequest) Reset() { *x = GetObjectRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[74] + mi := &file_gitserver_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5207,7 +5489,7 @@ func (x *GetObjectRequest) String() string { func (*GetObjectRequest) ProtoMessage() {} func (x *GetObjectRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[74] + mi := &file_gitserver_proto_msgTypes[76] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5220,7 +5502,7 @@ func (x *GetObjectRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetObjectRequest.ProtoReflect.Descriptor instead. func (*GetObjectRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{74} + return file_gitserver_proto_rawDescGZIP(), []int{76} } func (x *GetObjectRequest) GetRepo() string { @@ -5250,7 +5532,7 @@ type GetObjectResponse struct { func (x *GetObjectResponse) Reset() { *x = GetObjectResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[75] + mi := &file_gitserver_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5263,7 +5545,7 @@ func (x *GetObjectResponse) String() string { func (*GetObjectResponse) ProtoMessage() {} func (x *GetObjectResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[75] + mi := &file_gitserver_proto_msgTypes[77] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5276,7 +5558,7 @@ func (x *GetObjectResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetObjectResponse.ProtoReflect.Descriptor instead. func (*GetObjectResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{75} + return file_gitserver_proto_rawDescGZIP(), []int{77} } func (x *GetObjectResponse) GetObject() *GitObject { @@ -5301,7 +5583,7 @@ type GitObject struct { func (x *GitObject) Reset() { *x = GitObject{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[76] + mi := &file_gitserver_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5314,7 +5596,7 @@ func (x *GitObject) String() string { func (*GitObject) ProtoMessage() {} func (x *GitObject) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[76] + mi := &file_gitserver_proto_msgTypes[78] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5327,7 +5609,7 @@ func (x *GitObject) ProtoReflect() protoreflect.Message { // Deprecated: Use GitObject.ProtoReflect.Descriptor instead. func (*GitObject) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{76} + return file_gitserver_proto_rawDescGZIP(), []int{78} } func (x *GitObject) GetId() []byte { @@ -5358,7 +5640,7 @@ type IsPerforcePathCloneableRequest struct { func (x *IsPerforcePathCloneableRequest) Reset() { *x = IsPerforcePathCloneableRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[77] + mi := &file_gitserver_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5371,7 +5653,7 @@ func (x *IsPerforcePathCloneableRequest) String() string { func (*IsPerforcePathCloneableRequest) ProtoMessage() {} func (x *IsPerforcePathCloneableRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[77] + mi := &file_gitserver_proto_msgTypes[79] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5384,7 +5666,7 @@ func (x *IsPerforcePathCloneableRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use IsPerforcePathCloneableRequest.ProtoReflect.Descriptor instead. func (*IsPerforcePathCloneableRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{77} + return file_gitserver_proto_rawDescGZIP(), []int{79} } func (x *IsPerforcePathCloneableRequest) GetConnectionDetails() *PerforceConnectionDetails { @@ -5412,7 +5694,7 @@ type IsPerforcePathCloneableResponse struct { func (x *IsPerforcePathCloneableResponse) Reset() { *x = IsPerforcePathCloneableResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[78] + mi := &file_gitserver_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5425,7 +5707,7 @@ func (x *IsPerforcePathCloneableResponse) String() string { func (*IsPerforcePathCloneableResponse) ProtoMessage() {} func (x *IsPerforcePathCloneableResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[78] + mi := &file_gitserver_proto_msgTypes[80] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5438,7 +5720,7 @@ func (x *IsPerforcePathCloneableResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use IsPerforcePathCloneableResponse.ProtoReflect.Descriptor instead. func (*IsPerforcePathCloneableResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{78} + return file_gitserver_proto_rawDescGZIP(), []int{80} } // CheckPerforceCredentialsRequest is the request to check if given Perforce @@ -5454,7 +5736,7 @@ type CheckPerforceCredentialsRequest struct { func (x *CheckPerforceCredentialsRequest) Reset() { *x = CheckPerforceCredentialsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[79] + mi := &file_gitserver_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5467,7 +5749,7 @@ func (x *CheckPerforceCredentialsRequest) String() string { func (*CheckPerforceCredentialsRequest) ProtoMessage() {} func (x *CheckPerforceCredentialsRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[79] + mi := &file_gitserver_proto_msgTypes[81] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5480,7 +5762,7 @@ func (x *CheckPerforceCredentialsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CheckPerforceCredentialsRequest.ProtoReflect.Descriptor instead. func (*CheckPerforceCredentialsRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{79} + return file_gitserver_proto_rawDescGZIP(), []int{81} } func (x *CheckPerforceCredentialsRequest) GetConnectionDetails() *PerforceConnectionDetails { @@ -5501,7 +5783,7 @@ type CheckPerforceCredentialsResponse struct { func (x *CheckPerforceCredentialsResponse) Reset() { *x = CheckPerforceCredentialsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[80] + mi := &file_gitserver_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5514,7 +5796,7 @@ func (x *CheckPerforceCredentialsResponse) String() string { func (*CheckPerforceCredentialsResponse) ProtoMessage() {} func (x *CheckPerforceCredentialsResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[80] + mi := &file_gitserver_proto_msgTypes[82] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5527,7 +5809,7 @@ func (x *CheckPerforceCredentialsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CheckPerforceCredentialsResponse.ProtoReflect.Descriptor instead. func (*CheckPerforceCredentialsResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{80} + return file_gitserver_proto_rawDescGZIP(), []int{82} } // PerforceConnectionDetails holds all the details required to talk to a @@ -5545,7 +5827,7 @@ type PerforceConnectionDetails struct { func (x *PerforceConnectionDetails) Reset() { *x = PerforceConnectionDetails{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[81] + mi := &file_gitserver_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5558,7 +5840,7 @@ func (x *PerforceConnectionDetails) String() string { func (*PerforceConnectionDetails) ProtoMessage() {} func (x *PerforceConnectionDetails) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[81] + mi := &file_gitserver_proto_msgTypes[83] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5571,7 +5853,7 @@ func (x *PerforceConnectionDetails) ProtoReflect() protoreflect.Message { // Deprecated: Use PerforceConnectionDetails.ProtoReflect.Descriptor instead. func (*PerforceConnectionDetails) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{81} + return file_gitserver_proto_rawDescGZIP(), []int{83} } func (x *PerforceConnectionDetails) GetP4Port() string { @@ -5609,7 +5891,7 @@ type PerforceGetChangelistRequest struct { func (x *PerforceGetChangelistRequest) Reset() { *x = PerforceGetChangelistRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[82] + mi := &file_gitserver_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5622,7 +5904,7 @@ func (x *PerforceGetChangelistRequest) String() string { func (*PerforceGetChangelistRequest) ProtoMessage() {} func (x *PerforceGetChangelistRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[82] + mi := &file_gitserver_proto_msgTypes[84] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5635,7 +5917,7 @@ func (x *PerforceGetChangelistRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PerforceGetChangelistRequest.ProtoReflect.Descriptor instead. func (*PerforceGetChangelistRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{82} + return file_gitserver_proto_rawDescGZIP(), []int{84} } func (x *PerforceGetChangelistRequest) GetConnectionDetails() *PerforceConnectionDetails { @@ -5665,7 +5947,7 @@ type PerforceGetChangelistResponse struct { func (x *PerforceGetChangelistResponse) Reset() { *x = PerforceGetChangelistResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[83] + mi := &file_gitserver_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5678,7 +5960,7 @@ func (x *PerforceGetChangelistResponse) String() string { func (*PerforceGetChangelistResponse) ProtoMessage() {} func (x *PerforceGetChangelistResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[83] + mi := &file_gitserver_proto_msgTypes[85] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5691,7 +5973,7 @@ func (x *PerforceGetChangelistResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PerforceGetChangelistResponse.ProtoReflect.Descriptor instead. func (*PerforceGetChangelistResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{83} + return file_gitserver_proto_rawDescGZIP(), []int{85} } func (x *PerforceGetChangelistResponse) GetChangelist() *PerforceChangelist { @@ -5718,7 +6000,7 @@ type PerforceChangelist struct { func (x *PerforceChangelist) Reset() { *x = PerforceChangelist{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[84] + mi := &file_gitserver_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5731,7 +6013,7 @@ func (x *PerforceChangelist) String() string { func (*PerforceChangelist) ProtoMessage() {} func (x *PerforceChangelist) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[84] + mi := &file_gitserver_proto_msgTypes[86] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5744,7 +6026,7 @@ func (x *PerforceChangelist) ProtoReflect() protoreflect.Message { // Deprecated: Use PerforceChangelist.ProtoReflect.Descriptor instead. func (*PerforceChangelist) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{84} + return file_gitserver_proto_rawDescGZIP(), []int{86} } func (x *PerforceChangelist) GetId() string { @@ -5802,7 +6084,7 @@ type IsPerforceSuperUserRequest struct { func (x *IsPerforceSuperUserRequest) Reset() { *x = IsPerforceSuperUserRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[85] + mi := &file_gitserver_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5815,7 +6097,7 @@ func (x *IsPerforceSuperUserRequest) String() string { func (*IsPerforceSuperUserRequest) ProtoMessage() {} func (x *IsPerforceSuperUserRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[85] + mi := &file_gitserver_proto_msgTypes[87] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5828,7 +6110,7 @@ func (x *IsPerforceSuperUserRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use IsPerforceSuperUserRequest.ProtoReflect.Descriptor instead. func (*IsPerforceSuperUserRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{85} + return file_gitserver_proto_rawDescGZIP(), []int{87} } func (x *IsPerforceSuperUserRequest) GetConnectionDetails() *PerforceConnectionDetails { @@ -5850,7 +6132,7 @@ type IsPerforceSuperUserResponse struct { func (x *IsPerforceSuperUserResponse) Reset() { *x = IsPerforceSuperUserResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[86] + mi := &file_gitserver_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5863,7 +6145,7 @@ func (x *IsPerforceSuperUserResponse) String() string { func (*IsPerforceSuperUserResponse) ProtoMessage() {} func (x *IsPerforceSuperUserResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[86] + mi := &file_gitserver_proto_msgTypes[88] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5876,7 +6158,7 @@ func (x *IsPerforceSuperUserResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use IsPerforceSuperUserResponse.ProtoReflect.Descriptor instead. func (*IsPerforceSuperUserResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{86} + return file_gitserver_proto_rawDescGZIP(), []int{88} } // PerforceProtectsForDepotRequest requests all the protections that apply to @@ -5893,7 +6175,7 @@ type PerforceProtectsForDepotRequest struct { func (x *PerforceProtectsForDepotRequest) Reset() { *x = PerforceProtectsForDepotRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[87] + mi := &file_gitserver_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5906,7 +6188,7 @@ func (x *PerforceProtectsForDepotRequest) String() string { func (*PerforceProtectsForDepotRequest) ProtoMessage() {} func (x *PerforceProtectsForDepotRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[87] + mi := &file_gitserver_proto_msgTypes[89] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5919,7 +6201,7 @@ func (x *PerforceProtectsForDepotRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PerforceProtectsForDepotRequest.ProtoReflect.Descriptor instead. func (*PerforceProtectsForDepotRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{87} + return file_gitserver_proto_rawDescGZIP(), []int{89} } func (x *PerforceProtectsForDepotRequest) GetConnectionDetails() *PerforceConnectionDetails { @@ -5949,7 +6231,7 @@ type PerforceProtectsForDepotResponse struct { func (x *PerforceProtectsForDepotResponse) Reset() { *x = PerforceProtectsForDepotResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[88] + mi := &file_gitserver_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5962,7 +6244,7 @@ func (x *PerforceProtectsForDepotResponse) String() string { func (*PerforceProtectsForDepotResponse) ProtoMessage() {} func (x *PerforceProtectsForDepotResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[88] + mi := &file_gitserver_proto_msgTypes[90] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5975,7 +6257,7 @@ func (x *PerforceProtectsForDepotResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PerforceProtectsForDepotResponse.ProtoReflect.Descriptor instead. func (*PerforceProtectsForDepotResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{88} + return file_gitserver_proto_rawDescGZIP(), []int{90} } func (x *PerforceProtectsForDepotResponse) GetProtects() []*PerforceProtect { @@ -5999,7 +6281,7 @@ type PerforceProtectsForUserRequest struct { func (x *PerforceProtectsForUserRequest) Reset() { *x = PerforceProtectsForUserRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[89] + mi := &file_gitserver_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6012,7 +6294,7 @@ func (x *PerforceProtectsForUserRequest) String() string { func (*PerforceProtectsForUserRequest) ProtoMessage() {} func (x *PerforceProtectsForUserRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[89] + mi := &file_gitserver_proto_msgTypes[91] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6025,7 +6307,7 @@ func (x *PerforceProtectsForUserRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PerforceProtectsForUserRequest.ProtoReflect.Descriptor instead. func (*PerforceProtectsForUserRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{89} + return file_gitserver_proto_rawDescGZIP(), []int{91} } func (x *PerforceProtectsForUserRequest) GetConnectionDetails() *PerforceConnectionDetails { @@ -6055,7 +6337,7 @@ type PerforceProtectsForUserResponse struct { func (x *PerforceProtectsForUserResponse) Reset() { *x = PerforceProtectsForUserResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[90] + mi := &file_gitserver_proto_msgTypes[92] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6068,7 +6350,7 @@ func (x *PerforceProtectsForUserResponse) String() string { func (*PerforceProtectsForUserResponse) ProtoMessage() {} func (x *PerforceProtectsForUserResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[90] + mi := &file_gitserver_proto_msgTypes[92] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6081,7 +6363,7 @@ func (x *PerforceProtectsForUserResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PerforceProtectsForUserResponse.ProtoReflect.Descriptor instead. func (*PerforceProtectsForUserResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{90} + return file_gitserver_proto_rawDescGZIP(), []int{92} } func (x *PerforceProtectsForUserResponse) GetProtects() []*PerforceProtect { @@ -6108,7 +6390,7 @@ type PerforceProtect struct { func (x *PerforceProtect) Reset() { *x = PerforceProtect{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[91] + mi := &file_gitserver_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6121,7 +6403,7 @@ func (x *PerforceProtect) String() string { func (*PerforceProtect) ProtoMessage() {} func (x *PerforceProtect) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[91] + mi := &file_gitserver_proto_msgTypes[93] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6134,7 +6416,7 @@ func (x *PerforceProtect) ProtoReflect() protoreflect.Message { // Deprecated: Use PerforceProtect.ProtoReflect.Descriptor instead. func (*PerforceProtect) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{91} + return file_gitserver_proto_rawDescGZIP(), []int{93} } func (x *PerforceProtect) GetLevel() string { @@ -6192,7 +6474,7 @@ type PerforceGroupMembersRequest struct { func (x *PerforceGroupMembersRequest) Reset() { *x = PerforceGroupMembersRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[92] + mi := &file_gitserver_proto_msgTypes[94] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6205,7 +6487,7 @@ func (x *PerforceGroupMembersRequest) String() string { func (*PerforceGroupMembersRequest) ProtoMessage() {} func (x *PerforceGroupMembersRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[92] + mi := &file_gitserver_proto_msgTypes[94] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6218,7 +6500,7 @@ func (x *PerforceGroupMembersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PerforceGroupMembersRequest.ProtoReflect.Descriptor instead. func (*PerforceGroupMembersRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{92} + return file_gitserver_proto_rawDescGZIP(), []int{94} } func (x *PerforceGroupMembersRequest) GetConnectionDetails() *PerforceConnectionDetails { @@ -6248,7 +6530,7 @@ type PerforceGroupMembersResponse struct { func (x *PerforceGroupMembersResponse) Reset() { *x = PerforceGroupMembersResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[93] + mi := &file_gitserver_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6261,7 +6543,7 @@ func (x *PerforceGroupMembersResponse) String() string { func (*PerforceGroupMembersResponse) ProtoMessage() {} func (x *PerforceGroupMembersResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[93] + mi := &file_gitserver_proto_msgTypes[95] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6274,7 +6556,7 @@ func (x *PerforceGroupMembersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PerforceGroupMembersResponse.ProtoReflect.Descriptor instead. func (*PerforceGroupMembersResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{93} + return file_gitserver_proto_rawDescGZIP(), []int{95} } func (x *PerforceGroupMembersResponse) GetUsernames() []string { @@ -6296,7 +6578,7 @@ type PerforceUsersRequest struct { func (x *PerforceUsersRequest) Reset() { *x = PerforceUsersRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[94] + mi := &file_gitserver_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6309,7 +6591,7 @@ func (x *PerforceUsersRequest) String() string { func (*PerforceUsersRequest) ProtoMessage() {} func (x *PerforceUsersRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[94] + mi := &file_gitserver_proto_msgTypes[96] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6322,7 +6604,7 @@ func (x *PerforceUsersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PerforceUsersRequest.ProtoReflect.Descriptor instead. func (*PerforceUsersRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{94} + return file_gitserver_proto_rawDescGZIP(), []int{96} } func (x *PerforceUsersRequest) GetConnectionDetails() *PerforceConnectionDetails { @@ -6344,7 +6626,7 @@ type PerforceUsersResponse struct { func (x *PerforceUsersResponse) Reset() { *x = PerforceUsersResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[95] + mi := &file_gitserver_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6357,7 +6639,7 @@ func (x *PerforceUsersResponse) String() string { func (*PerforceUsersResponse) ProtoMessage() {} func (x *PerforceUsersResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[95] + mi := &file_gitserver_proto_msgTypes[97] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6370,7 +6652,7 @@ func (x *PerforceUsersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PerforceUsersResponse.ProtoReflect.Descriptor instead. func (*PerforceUsersResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{95} + return file_gitserver_proto_rawDescGZIP(), []int{97} } func (x *PerforceUsersResponse) GetUsers() []*PerforceUser { @@ -6393,7 +6675,7 @@ type PerforceUser struct { func (x *PerforceUser) Reset() { *x = PerforceUser{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[96] + mi := &file_gitserver_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6406,7 +6688,7 @@ func (x *PerforceUser) String() string { func (*PerforceUser) ProtoMessage() {} func (x *PerforceUser) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[96] + mi := &file_gitserver_proto_msgTypes[98] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6419,7 +6701,7 @@ func (x *PerforceUser) ProtoReflect() protoreflect.Message { // Deprecated: Use PerforceUser.ProtoReflect.Descriptor instead. func (*PerforceUser) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{96} + return file_gitserver_proto_rawDescGZIP(), []int{98} } func (x *PerforceUser) GetUsername() string { @@ -6454,7 +6736,7 @@ type MergeBaseRequest struct { func (x *MergeBaseRequest) Reset() { *x = MergeBaseRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[97] + mi := &file_gitserver_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6467,7 +6749,7 @@ func (x *MergeBaseRequest) String() string { func (*MergeBaseRequest) ProtoMessage() {} func (x *MergeBaseRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[97] + mi := &file_gitserver_proto_msgTypes[99] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6480,7 +6762,7 @@ func (x *MergeBaseRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MergeBaseRequest.ProtoReflect.Descriptor instead. func (*MergeBaseRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{97} + return file_gitserver_proto_rawDescGZIP(), []int{99} } func (x *MergeBaseRequest) GetRepoName() string { @@ -6517,7 +6799,7 @@ type MergeBaseResponse struct { func (x *MergeBaseResponse) Reset() { *x = MergeBaseResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[98] + mi := &file_gitserver_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6530,7 +6812,7 @@ func (x *MergeBaseResponse) String() string { func (*MergeBaseResponse) ProtoMessage() {} func (x *MergeBaseResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[98] + mi := &file_gitserver_proto_msgTypes[100] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6543,7 +6825,7 @@ func (x *MergeBaseResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MergeBaseResponse.ProtoReflect.Descriptor instead. func (*MergeBaseResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{98} + return file_gitserver_proto_rawDescGZIP(), []int{100} } func (x *MergeBaseResponse) GetMergeBaseCommitSha() string { @@ -6567,7 +6849,7 @@ type FirstEverCommitRequest struct { func (x *FirstEverCommitRequest) Reset() { *x = FirstEverCommitRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[99] + mi := &file_gitserver_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6580,7 +6862,7 @@ func (x *FirstEverCommitRequest) String() string { func (*FirstEverCommitRequest) ProtoMessage() {} func (x *FirstEverCommitRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[99] + mi := &file_gitserver_proto_msgTypes[101] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6593,7 +6875,7 @@ func (x *FirstEverCommitRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use FirstEverCommitRequest.ProtoReflect.Descriptor instead. func (*FirstEverCommitRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{99} + return file_gitserver_proto_rawDescGZIP(), []int{101} } func (x *FirstEverCommitRequest) GetRepoName() string { @@ -6616,7 +6898,7 @@ type FirstEverCommitResponse struct { func (x *FirstEverCommitResponse) Reset() { *x = FirstEverCommitResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[100] + mi := &file_gitserver_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6629,7 +6911,7 @@ func (x *FirstEverCommitResponse) String() string { func (*FirstEverCommitResponse) ProtoMessage() {} func (x *FirstEverCommitResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[100] + mi := &file_gitserver_proto_msgTypes[102] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6642,7 +6924,7 @@ func (x *FirstEverCommitResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use FirstEverCommitResponse.ProtoReflect.Descriptor instead. func (*FirstEverCommitResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{100} + return file_gitserver_proto_rawDescGZIP(), []int{102} } func (x *FirstEverCommitResponse) GetCommit() *GitCommit { @@ -6671,7 +6953,7 @@ type BehindAheadRequest struct { func (x *BehindAheadRequest) Reset() { *x = BehindAheadRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[101] + mi := &file_gitserver_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6684,7 +6966,7 @@ func (x *BehindAheadRequest) String() string { func (*BehindAheadRequest) ProtoMessage() {} func (x *BehindAheadRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[101] + mi := &file_gitserver_proto_msgTypes[103] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6697,7 +6979,7 @@ func (x *BehindAheadRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use BehindAheadRequest.ProtoReflect.Descriptor instead. func (*BehindAheadRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{101} + return file_gitserver_proto_rawDescGZIP(), []int{103} } func (x *BehindAheadRequest) GetRepoName() string { @@ -6737,7 +7019,7 @@ type BehindAheadResponse struct { func (x *BehindAheadResponse) Reset() { *x = BehindAheadResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[102] + mi := &file_gitserver_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6750,7 +7032,7 @@ func (x *BehindAheadResponse) String() string { func (*BehindAheadResponse) ProtoMessage() {} func (x *BehindAheadResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[102] + mi := &file_gitserver_proto_msgTypes[104] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6763,7 +7045,7 @@ func (x *BehindAheadResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use BehindAheadResponse.ProtoReflect.Descriptor instead. func (*BehindAheadResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{102} + return file_gitserver_proto_rawDescGZIP(), []int{104} } func (x *BehindAheadResponse) GetBehind() uint32 { @@ -6799,7 +7081,7 @@ type ChangedFilesRequest struct { func (x *ChangedFilesRequest) Reset() { *x = ChangedFilesRequest{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[103] + mi := &file_gitserver_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6812,7 +7094,7 @@ func (x *ChangedFilesRequest) String() string { func (*ChangedFilesRequest) ProtoMessage() {} func (x *ChangedFilesRequest) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[103] + mi := &file_gitserver_proto_msgTypes[105] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6825,7 +7107,7 @@ func (x *ChangedFilesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ChangedFilesRequest.ProtoReflect.Descriptor instead. func (*ChangedFilesRequest) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{103} + return file_gitserver_proto_rawDescGZIP(), []int{105} } func (x *ChangedFilesRequest) GetRepoName() string { @@ -6860,7 +7142,7 @@ type ChangedFilesResponse struct { func (x *ChangedFilesResponse) Reset() { *x = ChangedFilesResponse{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[104] + mi := &file_gitserver_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6873,7 +7155,7 @@ func (x *ChangedFilesResponse) String() string { func (*ChangedFilesResponse) ProtoMessage() {} func (x *ChangedFilesResponse) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[104] + mi := &file_gitserver_proto_msgTypes[106] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6886,7 +7168,7 @@ func (x *ChangedFilesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ChangedFilesResponse.ProtoReflect.Descriptor instead. func (*ChangedFilesResponse) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{104} + return file_gitserver_proto_rawDescGZIP(), []int{106} } func (x *ChangedFilesResponse) GetFiles() []*ChangedFile { @@ -6909,7 +7191,7 @@ type ChangedFile struct { func (x *ChangedFile) Reset() { *x = ChangedFile{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[105] + mi := &file_gitserver_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6922,7 +7204,7 @@ func (x *ChangedFile) String() string { func (*ChangedFile) ProtoMessage() {} func (x *ChangedFile) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[105] + mi := &file_gitserver_proto_msgTypes[107] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6935,7 +7217,7 @@ func (x *ChangedFile) ProtoReflect() protoreflect.Message { // Deprecated: Use ChangedFile.ProtoReflect.Descriptor instead. func (*ChangedFile) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{105} + return file_gitserver_proto_rawDescGZIP(), []int{107} } func (x *ChangedFile) GetPath() []byte { @@ -6970,7 +7252,7 @@ type ListRepositoriesResponse_GitRepository struct { func (x *ListRepositoriesResponse_GitRepository) Reset() { *x = ListRepositoriesResponse_GitRepository{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[106] + mi := &file_gitserver_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6983,7 +7265,7 @@ func (x *ListRepositoriesResponse_GitRepository) String() string { func (*ListRepositoriesResponse_GitRepository) ProtoMessage() {} func (x *ListRepositoriesResponse_GitRepository) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[106] + mi := &file_gitserver_proto_msgTypes[108] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7041,7 +7323,7 @@ type CreateCommitFromPatchBinaryRequest_Metadata struct { func (x *CreateCommitFromPatchBinaryRequest_Metadata) Reset() { *x = CreateCommitFromPatchBinaryRequest_Metadata{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[107] + mi := &file_gitserver_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7054,7 +7336,7 @@ func (x *CreateCommitFromPatchBinaryRequest_Metadata) String() string { func (*CreateCommitFromPatchBinaryRequest_Metadata) ProtoMessage() {} func (x *CreateCommitFromPatchBinaryRequest_Metadata) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[107] + mi := &file_gitserver_proto_msgTypes[109] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7067,7 +7349,7 @@ func (x *CreateCommitFromPatchBinaryRequest_Metadata) ProtoReflect() protoreflec // Deprecated: Use CreateCommitFromPatchBinaryRequest_Metadata.ProtoReflect.Descriptor instead. func (*CreateCommitFromPatchBinaryRequest_Metadata) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{42, 0} + return file_gitserver_proto_rawDescGZIP(), []int{44, 0} } func (x *CreateCommitFromPatchBinaryRequest_Metadata) GetRepo() string { @@ -7138,7 +7420,7 @@ type CreateCommitFromPatchBinaryRequest_Patch struct { func (x *CreateCommitFromPatchBinaryRequest_Patch) Reset() { *x = CreateCommitFromPatchBinaryRequest_Patch{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[108] + mi := &file_gitserver_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7151,7 +7433,7 @@ func (x *CreateCommitFromPatchBinaryRequest_Patch) String() string { func (*CreateCommitFromPatchBinaryRequest_Patch) ProtoMessage() {} func (x *CreateCommitFromPatchBinaryRequest_Patch) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[108] + mi := &file_gitserver_proto_msgTypes[110] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7164,7 +7446,7 @@ func (x *CreateCommitFromPatchBinaryRequest_Patch) ProtoReflect() protoreflect.M // Deprecated: Use CreateCommitFromPatchBinaryRequest_Patch.ProtoReflect.Descriptor instead. func (*CreateCommitFromPatchBinaryRequest_Patch) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{42, 1} + return file_gitserver_proto_rawDescGZIP(), []int{44, 1} } func (x *CreateCommitFromPatchBinaryRequest_Patch) GetData() []byte { @@ -7187,7 +7469,7 @@ type CommitMatch_Signature struct { func (x *CommitMatch_Signature) Reset() { *x = CommitMatch_Signature{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[109] + mi := &file_gitserver_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7200,7 +7482,7 @@ func (x *CommitMatch_Signature) String() string { func (*CommitMatch_Signature) ProtoMessage() {} func (x *CommitMatch_Signature) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[109] + mi := &file_gitserver_proto_msgTypes[111] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7213,7 +7495,7 @@ func (x *CommitMatch_Signature) ProtoReflect() protoreflect.Message { // Deprecated: Use CommitMatch_Signature.ProtoReflect.Descriptor instead. func (*CommitMatch_Signature) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{64, 0} + return file_gitserver_proto_rawDescGZIP(), []int{66, 0} } func (x *CommitMatch_Signature) GetName() string { @@ -7249,7 +7531,7 @@ type CommitMatch_MatchedString struct { func (x *CommitMatch_MatchedString) Reset() { *x = CommitMatch_MatchedString{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[110] + mi := &file_gitserver_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7262,7 +7544,7 @@ func (x *CommitMatch_MatchedString) String() string { func (*CommitMatch_MatchedString) ProtoMessage() {} func (x *CommitMatch_MatchedString) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[110] + mi := &file_gitserver_proto_msgTypes[112] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7275,7 +7557,7 @@ func (x *CommitMatch_MatchedString) ProtoReflect() protoreflect.Message { // Deprecated: Use CommitMatch_MatchedString.ProtoReflect.Descriptor instead. func (*CommitMatch_MatchedString) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{64, 1} + return file_gitserver_proto_rawDescGZIP(), []int{66, 1} } func (x *CommitMatch_MatchedString) GetContent() string { @@ -7305,7 +7587,7 @@ type CommitMatch_Range struct { func (x *CommitMatch_Range) Reset() { *x = CommitMatch_Range{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[111] + mi := &file_gitserver_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7318,7 +7600,7 @@ func (x *CommitMatch_Range) String() string { func (*CommitMatch_Range) ProtoMessage() {} func (x *CommitMatch_Range) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[111] + mi := &file_gitserver_proto_msgTypes[113] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7331,7 +7613,7 @@ func (x *CommitMatch_Range) ProtoReflect() protoreflect.Message { // Deprecated: Use CommitMatch_Range.ProtoReflect.Descriptor instead. func (*CommitMatch_Range) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{64, 2} + return file_gitserver_proto_rawDescGZIP(), []int{66, 2} } func (x *CommitMatch_Range) GetStart() *CommitMatch_Location { @@ -7361,7 +7643,7 @@ type CommitMatch_Location struct { func (x *CommitMatch_Location) Reset() { *x = CommitMatch_Location{} if protoimpl.UnsafeEnabled { - mi := &file_gitserver_proto_msgTypes[112] + mi := &file_gitserver_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7374,7 +7656,7 @@ func (x *CommitMatch_Location) String() string { func (*CommitMatch_Location) ProtoMessage() {} func (x *CommitMatch_Location) ProtoReflect() protoreflect.Message { - mi := &file_gitserver_proto_msgTypes[112] + mi := &file_gitserver_proto_msgTypes[114] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7387,7 +7669,7 @@ func (x *CommitMatch_Location) ProtoReflect() protoreflect.Message { // Deprecated: Use CommitMatch_Location.ProtoReflect.Descriptor instead. func (*CommitMatch_Location) Descriptor() ([]byte, []int) { - return file_gitserver_proto_rawDescGZIP(), []int{64, 3} + return file_gitserver_proto_rawDescGZIP(), []int{66, 3} } func (x *CommitMatch_Location) GetOffset() uint32 { @@ -7455,1049 +7737,1103 @@ var file_gitserver_proto_rawDesc = []byte{ 0x61, 0x6e, 0x67, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0b, 0x6c, 0x61, 0x73, 0x74, 0x43, 0x68, 0x61, - 0x6e, 0x67, 0x65, 0x64, 0x22, 0x93, 0x01, 0x0a, 0x18, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, - 0x75, 0x74, 0x6f, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 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, 0x14, - 0x0a, 0x05, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x72, - 0x61, 0x6e, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x05, 0x61, 0x66, 0x74, 0x65, 0x72, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, - 0x05, 0x61, 0x66, 0x74, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x22, 0x5c, 0x0a, 0x10, 0x43, 0x6f, - 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x6f, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x32, - 0x0a, 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, - 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x69, - 0x74, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x06, 0x61, 0x75, 0x74, 0x68, - 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x05, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x53, 0x0a, 0x19, 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, 0x12, 0x36, 0x0a, 0x06, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, - 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 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, 0x52, 0x06, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x22, 0xd8, 0x02, - 0x0a, 0x0e, 0x52, 0x61, 0x77, 0x44, 0x69, 0x66, 0x66, 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, 0x22, 0x0a, - 0x0d, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x72, 0x65, 0x76, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x62, 0x61, 0x73, 0x65, 0x52, 0x65, 0x76, 0x53, 0x70, 0x65, - 0x63, 0x12, 0x22, 0x0a, 0x0d, 0x68, 0x65, 0x61, 0x64, 0x5f, 0x72, 0x65, 0x76, 0x5f, 0x73, 0x70, - 0x65, 0x63, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x68, 0x65, 0x61, 0x64, 0x52, 0x65, - 0x76, 0x53, 0x70, 0x65, 0x63, 0x12, 0x54, 0x0a, 0x0f, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x69, - 0x73, 0x6f, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, - 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, 0x2e, 0x43, 0x6f, 0x6d, - 0x70, 0x61, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0e, 0x63, 0x6f, 0x6d, - 0x70, 0x61, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x70, - 0x61, 0x74, 0x68, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x05, 0x70, 0x61, 0x74, 0x68, - 0x73, 0x22, 0x75, 0x0a, 0x0e, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x54, - 0x79, 0x70, 0x65, 0x12, 0x1f, 0x0a, 0x1b, 0x43, 0x4f, 0x4d, 0x50, 0x41, 0x52, 0x49, 0x53, 0x4f, - 0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, - 0x45, 0x44, 0x10, 0x00, 0x12, 0x20, 0x0a, 0x1c, 0x43, 0x4f, 0x4d, 0x50, 0x41, 0x52, 0x49, 0x53, - 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4f, 0x4e, 0x4c, 0x59, 0x5f, 0x49, 0x4e, 0x5f, - 0x48, 0x45, 0x41, 0x44, 0x10, 0x01, 0x12, 0x20, 0x0a, 0x1c, 0x43, 0x4f, 0x4d, 0x50, 0x41, 0x52, - 0x49, 0x53, 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x53, - 0x45, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x02, 0x22, 0x27, 0x0a, 0x0f, 0x52, 0x61, 0x77, 0x44, - 0x69, 0x66, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, - 0x68, 0x75, 0x6e, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x63, 0x68, 0x75, 0x6e, - 0x6b, 0x22, 0xcd, 0x01, 0x0a, 0x0f, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x66, 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, 0x1d, 0x0a, 0x0a, 0x68, 0x65, 0x61, 0x64, 0x73, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x68, 0x65, 0x61, 0x64, 0x73, 0x4f, 0x6e, 0x6c, - 0x79, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x61, 0x67, 0x73, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x74, 0x61, 0x67, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x28, - 0x0a, 0x10, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x5f, 0x61, 0x74, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, - 0x69, 0x74, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, - 0x41, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x26, 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x74, - 0x61, 0x69, 0x6e, 0x73, 0x5f, 0x73, 0x68, 0x61, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, - 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x53, 0x68, 0x61, 0x88, 0x01, 0x01, - 0x42, 0x0f, 0x0a, 0x0d, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x5f, 0x73, 0x68, - 0x61, 0x22, 0x3c, 0x0a, 0x10, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x66, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x72, 0x65, 0x66, 0x73, 0x18, 0x01, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x47, 0x69, 0x74, 0x52, 0x65, 0x66, 0x52, 0x04, 0x72, 0x65, 0x66, 0x73, 0x22, - 0xe0, 0x02, 0x0a, 0x06, 0x47, 0x69, 0x74, 0x52, 0x65, 0x66, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x65, - 0x66, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x72, 0x65, - 0x66, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x72, - 0x65, 0x66, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x73, - 0x68, 0x6f, 0x72, 0x74, 0x52, 0x65, 0x66, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x74, - 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, - 0x12, 0x17, 0x0a, 0x07, 0x72, 0x65, 0x66, 0x5f, 0x6f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x06, 0x72, 0x65, 0x66, 0x4f, 0x69, 0x64, 0x12, 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, - 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, - 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, - 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, - 0x65, 0x64, 0x41, 0x74, 0x12, 0x37, 0x0a, 0x08, 0x72, 0x65, 0x66, 0x5f, 0x74, 0x79, 0x70, 0x65, - 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x69, 0x74, 0x52, 0x65, 0x66, 0x2e, 0x52, 0x65, 0x66, - 0x54, 0x79, 0x70, 0x65, 0x52, 0x07, 0x72, 0x65, 0x66, 0x54, 0x79, 0x70, 0x65, 0x12, 0x17, 0x0a, - 0x07, 0x69, 0x73, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, - 0x69, 0x73, 0x48, 0x65, 0x61, 0x64, 0x22, 0x4a, 0x0a, 0x07, 0x52, 0x65, 0x66, 0x54, 0x79, 0x70, - 0x65, 0x12, 0x18, 0x0a, 0x14, 0x52, 0x45, 0x46, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, - 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x52, - 0x45, 0x46, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x42, 0x52, 0x41, 0x4e, 0x43, 0x48, 0x10, 0x01, - 0x12, 0x10, 0x0a, 0x0c, 0x52, 0x45, 0x46, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x54, 0x41, 0x47, - 0x10, 0x02, 0x22, 0x5d, 0x0a, 0x0b, 0x53, 0x74, 0x61, 0x74, 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, 0x1d, - 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x09, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x53, 0x68, 0x61, 0x12, 0x12, 0x0a, - 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x70, 0x61, 0x74, - 0x68, 0x22, 0x43, 0x0a, 0x0c, 0x53, 0x74, 0x61, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x33, 0x0a, 0x09, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x66, 0x69, - 0x6c, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x8c, 0x01, 0x0a, 0x0e, 0x52, 0x65, 0x61, 0x64, 0x44, - 0x69, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x65, 0x70, + 0x6e, 0x67, 0x65, 0x64, 0x22, 0xb3, 0x05, 0x0a, 0x10, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4c, + 0x6f, 0x67, 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, 0x1d, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, - 0x5f, 0x73, 0x68, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6f, 0x6d, 0x6d, - 0x69, 0x74, 0x53, 0x68, 0x61, 0x12, 0x17, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x88, 0x01, 0x01, 0x12, 0x1c, - 0x0a, 0x09, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x09, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x42, 0x07, 0x0a, 0x05, - 0x5f, 0x70, 0x61, 0x74, 0x68, 0x22, 0x46, 0x0a, 0x0f, 0x52, 0x65, 0x61, 0x64, 0x44, 0x69, 0x72, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x09, 0x66, 0x69, 0x6c, 0x65, - 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x69, - 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x49, - 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x53, 0x0a, - 0x0c, 0x47, 0x69, 0x74, 0x53, 0x75, 0x62, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x12, 0x10, 0x0a, - 0x03, 0x75, 0x72, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x6c, 0x12, - 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x70, - 0x61, 0x74, 0x68, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x73, 0x68, - 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x53, - 0x68, 0x61, 0x22, 0xae, 0x01, 0x0a, 0x08, 0x46, 0x69, 0x6c, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, - 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x6e, - 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6d, 0x6f, 0x64, 0x65, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x6d, 0x6f, 0x64, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x62, - 0x6c, 0x6f, 0x62, 0x5f, 0x6f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x62, - 0x6c, 0x6f, 0x62, 0x4f, 0x69, 0x64, 0x12, 0x3d, 0x0a, 0x09, 0x73, 0x75, 0x62, 0x6d, 0x6f, 0x64, - 0x75, 0x6c, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x69, 0x74, 0x73, - 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x69, 0x74, 0x53, 0x75, 0x62, 0x6d, - 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x48, 0x00, 0x52, 0x09, 0x73, 0x75, 0x62, 0x6d, 0x6f, 0x64, 0x75, - 0x6c, 0x65, 0x88, 0x01, 0x01, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, 0x73, 0x75, 0x62, 0x6d, 0x6f, 0x64, - 0x75, 0x6c, 0x65, 0x22, 0x92, 0x01, 0x0a, 0x16, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x52, - 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 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, 0x19, 0x0a, 0x08, 0x72, - 0x65, 0x76, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x72, - 0x65, 0x76, 0x53, 0x70, 0x65, 0x63, 0x12, 0x2c, 0x0a, 0x0f, 0x65, 0x6e, 0x73, 0x75, 0x72, 0x65, - 0x5f, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x48, - 0x00, 0x52, 0x0e, 0x65, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, - 0x6e, 0x88, 0x01, 0x01, 0x42, 0x12, 0x0a, 0x10, 0x5f, 0x65, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x5f, - 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x38, 0x0a, 0x17, 0x52, 0x65, 0x73, 0x6f, - 0x6c, 0x76, 0x65, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x73, 0x68, - 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x53, - 0x68, 0x61, 0x22, 0x7a, 0x0a, 0x10, 0x52, 0x65, 0x76, 0x41, 0x74, 0x54, 0x69, 0x6d, 0x65, 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, 0x19, 0x0a, 0x08, 0x72, 0x65, 0x76, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x72, 0x65, 0x76, 0x53, 0x70, 0x65, 0x63, 0x12, 0x2e, - 0x0a, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, - 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, - 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x22, 0x32, - 0x0a, 0x11, 0x52, 0x65, 0x76, 0x41, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x73, 0x68, - 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x53, - 0x68, 0x61, 0x22, 0x7d, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, + 0x70, 0x6f, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, + 0x18, 0x03, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x06, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x12, 0x19, + 0x0a, 0x08, 0x61, 0x6c, 0x6c, 0x5f, 0x72, 0x65, 0x66, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x07, 0x61, 0x6c, 0x6c, 0x52, 0x65, 0x66, 0x73, 0x12, 0x30, 0x0a, 0x05, 0x61, 0x66, 0x74, + 0x65, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x52, 0x05, 0x61, 0x66, 0x74, 0x65, 0x72, 0x12, 0x32, 0x0a, 0x06, 0x62, + 0x65, 0x66, 0x6f, 0x72, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x06, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x12, + 0x1f, 0x0a, 0x0b, 0x6d, 0x61, 0x78, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x73, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x6d, 0x61, 0x78, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x73, + 0x12, 0x12, 0x0a, 0x04, 0x73, 0x6b, 0x69, 0x70, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, + 0x73, 0x6b, 0x69, 0x70, 0x12, 0x37, 0x0a, 0x18, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x6f, + 0x6e, 0x6c, 0x79, 0x5f, 0x66, 0x69, 0x72, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, + 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x15, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x4f, 0x6e, + 0x6c, 0x79, 0x46, 0x69, 0x72, 0x73, 0x74, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x12, 0x34, 0x0a, + 0x16, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, + 0x64, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x14, 0x69, + 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x46, 0x69, + 0x6c, 0x65, 0x73, 0x12, 0x43, 0x0a, 0x05, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x18, 0x0b, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x2d, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4c, 0x6f, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4c, 0x6f, 0x67, 0x4f, 0x72, 0x64, 0x65, + 0x72, 0x52, 0x05, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x23, 0x0a, 0x0d, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x5f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x21, 0x0a, + 0x0c, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x5f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x0d, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x51, 0x75, 0x65, 0x72, 0x79, + 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, + 0x70, 0x61, 0x74, 0x68, 0x12, 0x2e, 0x0a, 0x13, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x70, + 0x61, 0x74, 0x68, 0x5f, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x11, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x50, 0x61, 0x74, 0x68, 0x52, 0x65, 0x6e, + 0x61, 0x6d, 0x65, 0x73, 0x22, 0x74, 0x0a, 0x0e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4c, 0x6f, + 0x67, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x12, 0x20, 0x0a, 0x1c, 0x43, 0x4f, 0x4d, 0x4d, 0x49, 0x54, + 0x5f, 0x4c, 0x4f, 0x47, 0x5f, 0x4f, 0x52, 0x44, 0x45, 0x52, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, + 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x20, 0x0a, 0x1c, 0x43, 0x4f, 0x4d, 0x4d, + 0x49, 0x54, 0x5f, 0x4c, 0x4f, 0x47, 0x5f, 0x4f, 0x52, 0x44, 0x45, 0x52, 0x5f, 0x43, 0x4f, 0x4d, + 0x4d, 0x49, 0x54, 0x5f, 0x44, 0x41, 0x54, 0x45, 0x10, 0x01, 0x12, 0x1e, 0x0a, 0x1a, 0x43, 0x4f, + 0x4d, 0x4d, 0x49, 0x54, 0x5f, 0x4c, 0x4f, 0x47, 0x5f, 0x4f, 0x52, 0x44, 0x45, 0x52, 0x5f, 0x54, + 0x4f, 0x50, 0x4f, 0x5f, 0x44, 0x41, 0x54, 0x45, 0x10, 0x02, 0x22, 0x4e, 0x0a, 0x11, 0x43, 0x6f, + 0x6d, 0x6d, 0x69, 0x74, 0x4c, 0x6f, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x39, 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 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, 0x52, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x73, 0x22, 0x93, 0x01, 0x0a, 0x18, 0x43, + 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x6f, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 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, 0x14, 0x0a, 0x05, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x05, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x05, 0x61, 0x66, + 0x74, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x05, 0x61, 0x66, 0x74, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, + 0x70, 0x61, 0x74, 0x68, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, + 0x22, 0x5c, 0x0a, 0x10, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x6f, 0x72, 0x43, + 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x32, 0x0a, 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x69, 0x74, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, + 0x52, 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, + 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x53, + 0x0a, 0x19, 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, 0x12, 0x36, 0x0a, 0x06, 0x63, + 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 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, 0x52, 0x06, 0x63, 0x6f, 0x75, + 0x6e, 0x74, 0x73, 0x22, 0xd8, 0x02, 0x0a, 0x0e, 0x52, 0x61, 0x77, 0x44, 0x69, 0x66, 0x66, 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, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x34, 0x0a, 0x16, 0x69, - 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, - 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x14, 0x69, 0x6e, 0x63, - 0x6c, 0x75, 0x64, 0x65, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x46, 0x69, 0x6c, 0x65, - 0x73, 0x22, 0x6b, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x69, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, - 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x25, 0x0a, 0x0e, 0x6d, 0x6f, 0x64, 0x69, 0x66, - 0x69, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0c, 0x52, - 0x0d, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x46, 0x69, 0x6c, 0x65, 0x73, 0x22, 0xbf, - 0x01, 0x0a, 0x09, 0x47, 0x69, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x10, 0x0a, 0x03, - 0x6f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6f, 0x69, 0x64, 0x12, 0x32, - 0x0a, 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, - 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x69, - 0x74, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x06, 0x61, 0x75, 0x74, 0x68, - 0x6f, 0x72, 0x12, 0x38, 0x0a, 0x09, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x69, 0x74, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, - 0x65, 0x52, 0x09, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x12, 0x18, 0x0a, 0x07, - 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x6d, - 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, - 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x73, - 0x22, 0x68, 0x0a, 0x0c, 0x47, 0x69, 0x74, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, - 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, - 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0c, 0x52, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x12, 0x2e, 0x0a, 0x04, 0x64, 0x61, - 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, - 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, - 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, 0x64, 0x61, 0x74, 0x65, 0x22, 0xe5, 0x01, 0x0a, 0x0c, 0x42, - 0x6c, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x72, + 0x61, 0x6d, 0x65, 0x12, 0x22, 0x0a, 0x0d, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x72, 0x65, 0x76, 0x5f, + 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x62, 0x61, 0x73, 0x65, + 0x52, 0x65, 0x76, 0x53, 0x70, 0x65, 0x63, 0x12, 0x22, 0x0a, 0x0d, 0x68, 0x65, 0x61, 0x64, 0x5f, + 0x72, 0x65, 0x76, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, + 0x68, 0x65, 0x61, 0x64, 0x52, 0x65, 0x76, 0x53, 0x70, 0x65, 0x63, 0x12, 0x54, 0x0a, 0x0f, 0x63, + 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, 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, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x54, 0x79, 0x70, + 0x65, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x54, 0x79, 0x70, + 0x65, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0c, + 0x52, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x22, 0x75, 0x0a, 0x0e, 0x43, 0x6f, 0x6d, 0x70, 0x61, + 0x72, 0x69, 0x73, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1f, 0x0a, 0x1b, 0x43, 0x4f, 0x4d, + 0x50, 0x41, 0x52, 0x49, 0x53, 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, + 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x20, 0x0a, 0x1c, 0x43, 0x4f, + 0x4d, 0x50, 0x41, 0x52, 0x49, 0x53, 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4f, 0x4e, + 0x4c, 0x59, 0x5f, 0x49, 0x4e, 0x5f, 0x48, 0x45, 0x41, 0x44, 0x10, 0x01, 0x12, 0x20, 0x0a, 0x1c, + 0x43, 0x4f, 0x4d, 0x50, 0x41, 0x52, 0x49, 0x53, 0x4f, 0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, + 0x49, 0x4e, 0x54, 0x45, 0x52, 0x53, 0x45, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x02, 0x22, 0x27, + 0x0a, 0x0f, 0x52, 0x61, 0x77, 0x44, 0x69, 0x66, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x68, 0x75, 0x6e, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x05, 0x63, 0x68, 0x75, 0x6e, 0x6b, 0x22, 0xcd, 0x01, 0x0a, 0x0f, 0x4c, 0x69, 0x73, 0x74, + 0x52, 0x65, 0x66, 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, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, - 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, - 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, - 0x70, 0x61, 0x74, 0x68, 0x12, 0x2b, 0x0a, 0x11, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x77, - 0x68, 0x69, 0x74, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x10, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x57, 0x68, 0x69, 0x74, 0x65, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x12, 0x33, 0x0a, 0x05, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x18, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x42, 0x6c, 0x61, 0x6d, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x48, 0x00, 0x52, 0x05, 0x72, 0x61, - 0x6e, 0x67, 0x65, 0x88, 0x01, 0x01, 0x42, 0x08, 0x0a, 0x06, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, - 0x4a, 0x04, 0x08, 0x06, 0x10, 0x07, 0x4a, 0x04, 0x08, 0x07, 0x10, 0x08, 0x52, 0x0a, 0x73, 0x74, - 0x61, 0x72, 0x74, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x52, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x6c, 0x69, - 0x6e, 0x65, 0x22, 0x46, 0x0a, 0x0a, 0x42, 0x6c, 0x61, 0x6d, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65, - 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x4c, 0x69, 0x6e, 0x65, 0x12, - 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x0d, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x4c, 0x69, 0x6e, 0x65, 0x22, 0x3c, 0x0a, 0x0d, 0x42, 0x6c, - 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2b, 0x0a, 0x04, 0x68, - 0x75, 0x6e, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x69, 0x74, 0x73, - 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x61, 0x6d, 0x65, 0x48, 0x75, - 0x6e, 0x6b, 0x52, 0x04, 0x68, 0x75, 0x6e, 0x6b, 0x22, 0xe0, 0x02, 0x0a, 0x09, 0x42, 0x6c, 0x61, - 0x6d, 0x65, 0x48, 0x75, 0x6e, 0x6b, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, + 0x72, 0x65, 0x70, 0x6f, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x68, 0x65, 0x61, 0x64, + 0x73, 0x5f, 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x68, 0x65, + 0x61, 0x64, 0x73, 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x1b, 0x0a, 0x09, 0x74, 0x61, 0x67, 0x73, 0x5f, + 0x6f, 0x6e, 0x6c, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x74, 0x61, 0x67, 0x73, + 0x4f, 0x6e, 0x6c, 0x79, 0x12, 0x28, 0x0a, 0x10, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x5f, 0x61, + 0x74, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, + 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x41, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x26, + 0x0a, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, 0x5f, 0x73, 0x68, 0x61, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x73, + 0x53, 0x68, 0x61, 0x88, 0x01, 0x01, 0x42, 0x0f, 0x0a, 0x0d, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x61, + 0x69, 0x6e, 0x73, 0x5f, 0x73, 0x68, 0x61, 0x22, 0x3c, 0x0a, 0x10, 0x4c, 0x69, 0x73, 0x74, 0x52, + 0x65, 0x66, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x28, 0x0a, 0x04, 0x72, + 0x65, 0x66, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x69, 0x74, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x69, 0x74, 0x52, 0x65, 0x66, 0x52, + 0x04, 0x72, 0x65, 0x66, 0x73, 0x22, 0xe0, 0x02, 0x0a, 0x06, 0x47, 0x69, 0x74, 0x52, 0x65, 0x66, + 0x12, 0x19, 0x0a, 0x08, 0x72, 0x65, 0x66, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x07, 0x72, 0x65, 0x66, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x73, + 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x72, 0x65, 0x66, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x52, 0x65, 0x66, 0x4e, 0x61, 0x6d, + 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, + 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x72, 0x65, 0x66, 0x5f, 0x6f, 0x69, + 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x66, 0x4f, 0x69, 0x64, 0x12, + 0x39, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x74, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, + 0x09, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x41, 0x74, 0x12, 0x37, 0x0a, 0x08, 0x72, 0x65, + 0x66, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x67, + 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x69, 0x74, 0x52, + 0x65, 0x66, 0x2e, 0x52, 0x65, 0x66, 0x54, 0x79, 0x70, 0x65, 0x52, 0x07, 0x72, 0x65, 0x66, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x73, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x69, 0x73, 0x48, 0x65, 0x61, 0x64, 0x22, 0x4a, 0x0a, 0x07, + 0x52, 0x65, 0x66, 0x54, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x14, 0x52, 0x45, 0x46, 0x5f, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, + 0x00, 0x12, 0x13, 0x0a, 0x0f, 0x52, 0x45, 0x46, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x42, 0x52, + 0x41, 0x4e, 0x43, 0x48, 0x10, 0x01, 0x12, 0x10, 0x0a, 0x0c, 0x52, 0x45, 0x46, 0x5f, 0x54, 0x59, + 0x50, 0x45, 0x5f, 0x54, 0x41, 0x47, 0x10, 0x02, 0x22, 0x5d, 0x0a, 0x0b, 0x53, 0x74, 0x61, 0x74, + 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, 0x1d, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x73, + 0x68, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, + 0x53, 0x68, 0x61, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x22, 0x43, 0x0a, 0x0c, 0x53, 0x74, 0x61, 0x74, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x09, 0x66, 0x69, 0x6c, 0x65, 0x5f, + 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x69, 0x74, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x8c, 0x01, 0x0a, + 0x0e, 0x52, 0x65, 0x61, 0x64, 0x44, 0x69, 0x72, 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, 0x1d, 0x0a, 0x0a, + 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x53, 0x68, 0x61, 0x12, 0x17, 0x0a, 0x04, 0x70, + 0x61, 0x74, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x04, 0x70, 0x61, 0x74, + 0x68, 0x88, 0x01, 0x01, 0x12, 0x1c, 0x0a, 0x09, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, + 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, + 0x76, 0x65, 0x42, 0x07, 0x0a, 0x05, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x22, 0x46, 0x0a, 0x0f, 0x52, + 0x65, 0x61, 0x64, 0x44, 0x69, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, + 0x0a, 0x09, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x49, + 0x6e, 0x66, 0x6f, 0x22, 0x53, 0x0a, 0x0c, 0x47, 0x69, 0x74, 0x53, 0x75, 0x62, 0x6d, 0x6f, 0x64, + 0x75, 0x6c, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x75, 0x72, 0x6c, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, + 0x6d, 0x69, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, + 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x53, 0x68, 0x61, 0x22, 0xae, 0x01, 0x0a, 0x08, 0x46, 0x69, 0x6c, + 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x7a, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x12, 0x12, 0x0a, + 0x04, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x6d, 0x6f, 0x64, + 0x65, 0x12, 0x19, 0x0a, 0x08, 0x62, 0x6c, 0x6f, 0x62, 0x5f, 0x6f, 0x69, 0x64, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x62, 0x6c, 0x6f, 0x62, 0x4f, 0x69, 0x64, 0x12, 0x3d, 0x0a, 0x09, + 0x73, 0x75, 0x62, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1a, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, + 0x69, 0x74, 0x53, 0x75, 0x62, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x48, 0x00, 0x52, 0x09, 0x73, + 0x75, 0x62, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x88, 0x01, 0x01, 0x42, 0x0c, 0x0a, 0x0a, 0x5f, + 0x73, 0x75, 0x62, 0x6d, 0x6f, 0x64, 0x75, 0x6c, 0x65, 0x22, 0x92, 0x01, 0x0a, 0x16, 0x52, 0x65, + 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 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, 0x19, 0x0a, 0x08, 0x72, 0x65, 0x76, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x07, 0x72, 0x65, 0x76, 0x53, 0x70, 0x65, 0x63, 0x12, 0x2c, 0x0a, 0x0f, + 0x65, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x5f, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x0e, 0x65, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x52, + 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x88, 0x01, 0x01, 0x42, 0x12, 0x0a, 0x10, 0x5f, 0x65, + 0x6e, 0x73, 0x75, 0x72, 0x65, 0x5f, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x38, + 0x0a, 0x17, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x76, 0x65, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, + 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, + 0x6d, 0x69, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, + 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x53, 0x68, 0x61, 0x22, 0x7a, 0x0a, 0x10, 0x52, 0x65, 0x76, 0x41, + 0x74, 0x54, 0x69, 0x6d, 0x65, 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, 0x19, 0x0a, 0x08, 0x72, 0x65, 0x76, + 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x72, 0x65, 0x76, + 0x53, 0x70, 0x65, 0x63, 0x12, 0x2e, 0x0a, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, + 0x74, 0x69, 0x6d, 0x65, 0x22, 0x32, 0x0a, 0x11, 0x52, 0x65, 0x76, 0x41, 0x74, 0x54, 0x69, 0x6d, + 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, + 0x6d, 0x69, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, + 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x53, 0x68, 0x61, 0x22, 0x7d, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x43, + 0x6f, 0x6d, 0x6d, 0x69, 0x74, 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, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6d, + 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, + 0x74, 0x12, 0x34, 0x0a, 0x16, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x6d, 0x6f, 0x64, + 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x14, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x69, + 0x65, 0x64, 0x46, 0x69, 0x6c, 0x65, 0x73, 0x22, 0x6b, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x43, 0x6f, + 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x06, + 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, + 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x69, 0x74, 0x43, + 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x25, 0x0a, + 0x0e, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0d, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x46, + 0x69, 0x6c, 0x65, 0x73, 0x22, 0xbf, 0x01, 0x0a, 0x09, 0x47, 0x69, 0x74, 0x43, 0x6f, 0x6d, 0x6d, + 0x69, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x03, 0x6f, 0x69, 0x64, 0x12, 0x32, 0x0a, 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x69, 0x74, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, + 0x52, 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x12, 0x38, 0x0a, 0x09, 0x63, 0x6f, 0x6d, 0x6d, + 0x69, 0x74, 0x74, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x69, + 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x69, 0x74, 0x53, 0x69, + 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x09, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, + 0x65, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x18, 0x0a, 0x07, + 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x70, + 0x61, 0x72, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x68, 0x0a, 0x0c, 0x47, 0x69, 0x74, 0x53, 0x69, 0x67, + 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x6d, + 0x61, 0x69, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, + 0x12, 0x2e, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, 0x64, 0x61, 0x74, 0x65, + 0x22, 0xe5, 0x01, 0x0a, 0x0c, 0x42, 0x6c, 0x61, 0x6d, 0x65, 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, 0x16, + 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x12, 0x2b, 0x0a, 0x11, 0x69, 0x67, + 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x77, 0x68, 0x69, 0x74, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x57, 0x68, 0x69, + 0x74, 0x65, 0x73, 0x70, 0x61, 0x63, 0x65, 0x12, 0x33, 0x0a, 0x05, 0x72, 0x61, 0x6e, 0x67, 0x65, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x61, 0x6d, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65, + 0x48, 0x00, 0x52, 0x05, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x88, 0x01, 0x01, 0x42, 0x08, 0x0a, 0x06, + 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x4a, 0x04, 0x08, 0x06, 0x10, 0x07, 0x4a, 0x04, 0x08, 0x07, + 0x10, 0x08, 0x52, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x52, 0x08, + 0x65, 0x6e, 0x64, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x22, 0x46, 0x0a, 0x0a, 0x42, 0x6c, 0x61, 0x6d, + 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x4c, 0x69, 0x6e, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x4c, 0x69, 0x6e, 0x65, - 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x42, 0x79, 0x74, 0x65, 0x12, - 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x0d, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x42, 0x79, 0x74, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, - 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, - 0x69, 0x74, 0x12, 0x31, 0x0a, 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x18, 0x06, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x42, 0x6c, 0x61, 0x6d, 0x65, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x52, 0x06, 0x61, - 0x75, 0x74, 0x68, 0x6f, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, - 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, - 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x4a, 0x0a, 0x0f, 0x70, - 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x09, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x43, 0x6f, 0x6d, 0x6d, - 0x69, 0x74, 0x48, 0x00, 0x52, 0x0e, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x43, 0x6f, - 0x6d, 0x6d, 0x69, 0x74, 0x88, 0x01, 0x01, 0x42, 0x12, 0x0a, 0x10, 0x5f, 0x70, 0x72, 0x65, 0x76, - 0x69, 0x6f, 0x75, 0x73, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x22, 0x67, 0x0a, 0x0b, 0x42, - 0x6c, 0x61, 0x6d, 0x65, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, - 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, - 0x0a, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, - 0x6d, 0x61, 0x69, 0x6c, 0x12, 0x2e, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, - 0x64, 0x61, 0x74, 0x65, 0x22, 0x44, 0x0a, 0x0e, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, - 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x1a, - 0x0a, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x50, 0x0a, 0x14, 0x44, 0x65, - 0x66, 0x61, 0x75, 0x6c, 0x74, 0x42, 0x72, 0x61, 0x6e, 0x63, 0x68, 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, - 0x1b, 0x0a, 0x09, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x08, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x52, 0x65, 0x66, 0x22, 0x4a, 0x0a, 0x15, - 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x42, 0x72, 0x61, 0x6e, 0x63, 0x68, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x65, 0x66, 0x5f, 0x6e, 0x61, 0x6d, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x72, 0x65, 0x66, 0x4e, 0x61, 0x6d, 0x65, - 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x22, 0x5a, 0x0a, 0x0f, 0x52, 0x65, 0x61, 0x64, - 0x46, 0x69, 0x6c, 0x65, 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, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, - 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, - 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, - 0x70, 0x61, 0x74, 0x68, 0x22, 0x26, 0x0a, 0x10, 0x52, 0x65, 0x61, 0x64, 0x46, 0x69, 0x6c, 0x65, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0x11, 0x0a, 0x0f, - 0x44, 0x69, 0x73, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, - 0x75, 0x0a, 0x10, 0x44, 0x69, 0x73, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x66, 0x72, 0x65, 0x65, 0x5f, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x66, 0x72, 0x65, 0x65, 0x53, 0x70, 0x61, - 0x63, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x73, 0x70, 0x61, 0x63, - 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x70, - 0x61, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x5f, 0x75, - 0x73, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x0b, 0x70, 0x65, 0x72, 0x63, 0x65, - 0x6e, 0x74, 0x55, 0x73, 0x65, 0x64, 0x22, 0xf1, 0x01, 0x0a, 0x0f, 0x50, 0x61, 0x74, 0x63, 0x68, - 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x65, - 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x6d, 0x65, - 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, - 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x61, 0x75, 0x74, - 0x68, 0x6f, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x61, 0x75, 0x74, 0x68, 0x6f, - 0x72, 0x5f, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61, - 0x75, 0x74, 0x68, 0x6f, 0x72, 0x45, 0x6d, 0x61, 0x69, 0x6c, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, - 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, - 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x5f, 0x65, - 0x6d, 0x61, 0x69, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x6d, - 0x69, 0x74, 0x74, 0x65, 0x72, 0x45, 0x6d, 0x61, 0x69, 0x6c, 0x12, 0x2e, 0x0a, 0x04, 0x64, 0x61, - 0x74, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x22, 0x3c, 0x0a, 0x0d, 0x42, 0x6c, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x2b, 0x0a, 0x04, 0x68, 0x75, 0x6e, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x17, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x42, + 0x6c, 0x61, 0x6d, 0x65, 0x48, 0x75, 0x6e, 0x6b, 0x52, 0x04, 0x68, 0x75, 0x6e, 0x6b, 0x22, 0xe0, + 0x02, 0x0a, 0x09, 0x42, 0x6c, 0x61, 0x6d, 0x65, 0x48, 0x75, 0x6e, 0x6b, 0x12, 0x1d, 0x0a, 0x0a, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, + 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x4c, 0x69, 0x6e, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, + 0x6e, 0x64, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x65, + 0x6e, 0x64, 0x4c, 0x69, 0x6e, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, + 0x62, 0x79, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x42, 0x79, 0x74, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x62, 0x79, 0x74, + 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x42, 0x79, 0x74, 0x65, + 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x31, 0x0a, 0x06, 0x61, 0x75, 0x74, 0x68, + 0x6f, 0x72, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, + 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6c, 0x61, 0x6d, 0x65, 0x41, 0x75, 0x74, + 0x68, 0x6f, 0x72, 0x52, 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, + 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, + 0x65, 0x12, 0x4a, 0x0a, 0x0f, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x5f, 0x63, 0x6f, + 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x69, 0x74, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, + 0x75, 0x73, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x48, 0x00, 0x52, 0x0e, 0x70, 0x72, 0x65, 0x76, + 0x69, 0x6f, 0x75, 0x73, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x88, 0x01, 0x01, 0x42, 0x12, 0x0a, + 0x10, 0x5f, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, + 0x74, 0x22, 0x67, 0x0a, 0x0b, 0x42, 0x6c, 0x61, 0x6d, 0x65, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, + 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x12, 0x2e, 0x0a, 0x04, 0x64, 0x61, + 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, - 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, 0x64, 0x61, 0x74, 0x65, 0x22, 0x6c, 0x0a, 0x0a, 0x50, 0x75, - 0x73, 0x68, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x65, 0x6d, 0x6f, - 0x74, 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x72, 0x65, - 0x6d, 0x6f, 0x74, 0x65, 0x55, 0x72, 0x6c, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, 0x69, 0x76, 0x61, - 0x74, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x72, - 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x1e, 0x0a, 0x0a, 0x70, 0x61, 0x73, 0x73, - 0x70, 0x68, 0x72, 0x61, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x70, 0x61, - 0x73, 0x73, 0x70, 0x68, 0x72, 0x61, 0x73, 0x65, 0x22, 0xb6, 0x04, 0x0a, 0x22, 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, 0x12, - 0x57, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x39, 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, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, 0x08, - 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x4e, 0x0a, 0x05, 0x70, 0x61, 0x74, 0x63, - 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, + 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, 0x64, 0x61, 0x74, 0x65, 0x22, 0x44, 0x0a, 0x0e, 0x50, 0x72, + 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x16, 0x0a, 0x06, + 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, + 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, + 0x22, 0x50, 0x0a, 0x14, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x42, 0x72, 0x61, 0x6e, 0x63, + 0x68, 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, 0x1b, 0x0a, 0x09, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x5f, 0x72, + 0x65, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x52, + 0x65, 0x66, 0x22, 0x4a, 0x0a, 0x15, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x42, 0x72, 0x61, + 0x6e, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x72, + 0x65, 0x66, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x72, + 0x65, 0x66, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x22, 0x5a, + 0x0a, 0x0f, 0x52, 0x65, 0x61, 0x64, 0x46, 0x69, 0x6c, 0x65, 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, 0x16, + 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, + 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x22, 0x26, 0x0a, 0x10, 0x52, 0x65, + 0x61, 0x64, 0x46, 0x69, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, + 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, + 0x74, 0x61, 0x22, 0x11, 0x0a, 0x0f, 0x44, 0x69, 0x73, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x75, 0x0a, 0x10, 0x44, 0x69, 0x73, 0x6b, 0x49, 0x6e, 0x66, + 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x66, 0x72, 0x65, + 0x65, 0x5f, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x66, + 0x72, 0x65, 0x65, 0x53, 0x70, 0x61, 0x63, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x74, 0x6f, 0x74, 0x61, + 0x6c, 0x5f, 0x73, 0x70, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x74, + 0x6f, 0x74, 0x61, 0x6c, 0x53, 0x70, 0x61, 0x63, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x65, 0x72, + 0x63, 0x65, 0x6e, 0x74, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x02, 0x52, + 0x0b, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x55, 0x73, 0x65, 0x64, 0x22, 0xf1, 0x01, 0x0a, + 0x0f, 0x50, 0x61, 0x74, 0x63, 0x68, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x49, 0x6e, 0x66, 0x6f, + 0x12, 0x1a, 0x0a, 0x08, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x08, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b, + 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0a, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x21, 0x0a, + 0x0c, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x5f, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0b, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x45, 0x6d, 0x61, 0x69, 0x6c, + 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x5f, 0x6e, 0x61, + 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, + 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, + 0x74, 0x74, 0x65, 0x72, 0x5f, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x45, 0x6d, 0x61, 0x69, 0x6c, + 0x12, 0x2e, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, 0x64, 0x61, 0x74, 0x65, + 0x22, 0x6c, 0x0a, 0x0a, 0x50, 0x75, 0x73, 0x68, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x1d, + 0x0a, 0x0a, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x09, 0x72, 0x65, 0x6d, 0x6f, 0x74, 0x65, 0x55, 0x72, 0x6c, 0x12, 0x1f, 0x0a, + 0x0b, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0a, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, 0x65, 0x4b, 0x65, 0x79, 0x12, 0x1e, + 0x0a, 0x0a, 0x70, 0x61, 0x73, 0x73, 0x70, 0x68, 0x72, 0x61, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0a, 0x70, 0x61, 0x73, 0x73, 0x70, 0x68, 0x72, 0x61, 0x73, 0x65, 0x22, 0xb6, + 0x04, 0x0a, 0x22, 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, 0x12, 0x57, 0x0a, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, + 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x39, 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, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x48, - 0x00, 0x52, 0x05, 0x70, 0x61, 0x74, 0x63, 0x68, 0x1a, 0xbe, 0x02, 0x0a, 0x08, 0x4d, 0x65, 0x74, - 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x12, 0x1f, 0x0a, 0x0b, 0x62, 0x61, 0x73, - 0x65, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, - 0x62, 0x61, 0x73, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x61, - 0x72, 0x67, 0x65, 0x74, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, - 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x66, 0x12, 0x1d, 0x0a, 0x0a, 0x75, 0x6e, 0x69, - 0x71, 0x75, 0x65, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x75, - 0x6e, 0x69, 0x71, 0x75, 0x65, 0x52, 0x65, 0x66, 0x12, 0x3e, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, - 0x69, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, - 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, - 0x63, 0x68, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0a, 0x63, 0x6f, - 0x6d, 0x6d, 0x69, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2c, 0x0a, 0x04, 0x70, 0x75, 0x73, 0x68, - 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x75, 0x73, 0x68, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, - 0x52, 0x04, 0x70, 0x75, 0x73, 0x68, 0x12, 0x24, 0x0a, 0x0e, 0x67, 0x69, 0x74, 0x5f, 0x61, 0x70, - 0x70, 0x6c, 0x79, 0x5f, 0x61, 0x72, 0x67, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, - 0x67, 0x69, 0x74, 0x41, 0x70, 0x70, 0x6c, 0x79, 0x41, 0x72, 0x67, 0x73, 0x12, 0x1e, 0x0a, 0x08, - 0x70, 0x75, 0x73, 0x68, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, - 0x52, 0x07, 0x70, 0x75, 0x73, 0x68, 0x52, 0x65, 0x66, 0x88, 0x01, 0x01, 0x42, 0x0b, 0x0a, 0x09, - 0x5f, 0x70, 0x75, 0x73, 0x68, 0x5f, 0x72, 0x65, 0x66, 0x1a, 0x1b, 0x0a, 0x05, 0x50, 0x61, 0x74, - 0x63, 0x68, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, - 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x42, 0x09, 0x0a, 0x07, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, - 0x64, 0x22, 0xaf, 0x01, 0x0a, 0x1a, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x6d, - 0x69, 0x74, 0x46, 0x72, 0x6f, 0x6d, 0x50, 0x61, 0x74, 0x63, 0x68, 0x45, 0x72, 0x72, 0x6f, 0x72, - 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x6e, - 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x72, 0x65, 0x70, 0x6f, 0x73, - 0x69, 0x74, 0x6f, 0x72, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x69, 0x6e, 0x74, - 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0d, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, - 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x6f, - 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x4f, 0x75, 0x74, - 0x70, 0x75, 0x74, 0x22, 0x69, 0x0a, 0x23, 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, 0x12, 0x10, 0x0a, 0x03, 0x72, 0x65, - 0x76, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x72, 0x65, 0x76, 0x12, 0x23, 0x0a, 0x0d, - 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x49, - 0x64, 0x4a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x22, 0x9b, - 0x01, 0x0a, 0x0b, 0x45, 0x78, 0x65, 0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, + 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x48, 0x00, 0x52, 0x08, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x4e, + 0x0a, 0x05, 0x70, 0x61, 0x74, 0x63, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x36, 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, 0x2e, + 0x50, 0x61, 0x74, 0x63, 0x68, 0x48, 0x00, 0x52, 0x05, 0x70, 0x61, 0x74, 0x63, 0x68, 0x1a, 0xbe, + 0x02, 0x0a, 0x08, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x12, 0x0a, 0x04, 0x72, + 0x65, 0x70, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x12, + 0x1f, 0x0a, 0x0b, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x62, 0x61, 0x73, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, + 0x12, 0x1d, 0x0a, 0x0a, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x66, 0x12, + 0x1d, 0x0a, 0x0a, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x09, 0x75, 0x6e, 0x69, 0x71, 0x75, 0x65, 0x52, 0x65, 0x66, 0x12, 0x3e, + 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x50, 0x61, 0x74, 0x63, 0x68, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2c, + 0x0a, 0x04, 0x70, 0x75, 0x73, 0x68, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x67, + 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x75, 0x73, 0x68, + 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x04, 0x70, 0x75, 0x73, 0x68, 0x12, 0x24, 0x0a, 0x0e, + 0x67, 0x69, 0x74, 0x5f, 0x61, 0x70, 0x70, 0x6c, 0x79, 0x5f, 0x61, 0x72, 0x67, 0x73, 0x18, 0x07, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x67, 0x69, 0x74, 0x41, 0x70, 0x70, 0x6c, 0x79, 0x41, 0x72, + 0x67, 0x73, 0x12, 0x1e, 0x0a, 0x08, 0x70, 0x75, 0x73, 0x68, 0x5f, 0x72, 0x65, 0x66, 0x18, 0x08, + 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x07, 0x70, 0x75, 0x73, 0x68, 0x52, 0x65, 0x66, 0x88, + 0x01, 0x01, 0x42, 0x0b, 0x0a, 0x09, 0x5f, 0x70, 0x75, 0x73, 0x68, 0x5f, 0x72, 0x65, 0x66, 0x1a, + 0x1b, 0x0a, 0x05, 0x50, 0x61, 0x74, 0x63, 0x68, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x42, 0x09, 0x0a, 0x07, + 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0xaf, 0x01, 0x0a, 0x1a, 0x43, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x46, 0x72, 0x6f, 0x6d, 0x50, 0x61, 0x74, 0x63, + 0x68, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, + 0x74, 0x6f, 0x72, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0e, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, + 0x25, 0x0a, 0x0e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x5f, 0x65, 0x72, 0x72, 0x6f, + 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, + 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, + 0x12, 0x27, 0x0a, 0x0f, 0x63, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x65, 0x64, 0x5f, 0x6f, 0x75, 0x74, + 0x70, 0x75, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x62, 0x69, + 0x6e, 0x65, 0x64, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x22, 0x69, 0x0a, 0x23, 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, + 0x12, 0x10, 0x0a, 0x03, 0x72, 0x65, 0x76, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x72, + 0x65, 0x76, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, + 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x67, + 0x65, 0x6c, 0x69, 0x73, 0x74, 0x49, 0x64, 0x4a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x52, 0x05, 0x65, + 0x72, 0x72, 0x6f, 0x72, 0x22, 0x9b, 0x01, 0x0a, 0x0b, 0x45, 0x78, 0x65, 0x63, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x12, 0x2b, 0x0a, 0x0f, 0x65, 0x6e, 0x73, 0x75, + 0x72, 0x65, 0x5f, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0c, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0e, 0x65, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x52, 0x65, 0x76, + 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x61, 0x72, 0x67, 0x73, 0x18, 0x03, 0x20, + 0x03, 0x28, 0x0c, 0x52, 0x04, 0x61, 0x72, 0x67, 0x73, 0x12, 0x18, 0x0a, 0x05, 0x73, 0x74, 0x64, + 0x69, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x02, 0x18, 0x01, 0x52, 0x05, 0x73, 0x74, + 0x64, 0x69, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x6e, 0x6f, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, + 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x6e, 0x6f, 0x54, 0x69, 0x6d, 0x65, 0x6f, + 0x75, 0x74, 0x22, 0x22, 0x0a, 0x0c, 0x45, 0x78, 0x65, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0x7c, 0x0a, 0x13, 0x52, 0x65, 0x70, 0x6f, 0x4e, 0x6f, + 0x74, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x12, 0x0a, + 0x04, 0x72, 0x65, 0x70, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x72, 0x65, 0x70, + 0x6f, 0x12, 0x2a, 0x0a, 0x11, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x5f, 0x69, 0x6e, 0x5f, 0x70, 0x72, + 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x63, 0x6c, + 0x6f, 0x6e, 0x65, 0x49, 0x6e, 0x50, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x12, 0x25, 0x0a, + 0x0e, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x50, 0x72, 0x6f, 0x67, + 0x72, 0x65, 0x73, 0x73, 0x22, 0x41, 0x0a, 0x17, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, + 0x4e, 0x6f, 0x74, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, + 0x12, 0x0a, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x72, + 0x65, 0x70, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x73, 0x70, 0x65, 0x63, 0x22, 0x55, 0x0a, 0x13, 0x46, 0x69, 0x6c, 0x65, 0x4e, + 0x6f, 0x74, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x72, 0x65, - 0x70, 0x6f, 0x12, 0x2b, 0x0a, 0x0f, 0x65, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x5f, 0x72, 0x65, 0x76, - 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x42, 0x02, 0x18, 0x01, 0x52, - 0x0e, 0x65, 0x6e, 0x73, 0x75, 0x72, 0x65, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x12, - 0x12, 0x0a, 0x04, 0x61, 0x72, 0x67, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x04, 0x61, - 0x72, 0x67, 0x73, 0x12, 0x18, 0x0a, 0x05, 0x73, 0x74, 0x64, 0x69, 0x6e, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x0c, 0x42, 0x02, 0x18, 0x01, 0x52, 0x05, 0x73, 0x74, 0x64, 0x69, 0x6e, 0x12, 0x1d, 0x0a, - 0x0a, 0x6e, 0x6f, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x09, 0x6e, 0x6f, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x22, 0x22, 0x0a, 0x0c, - 0x45, 0x78, 0x65, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, - 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, - 0x22, 0x7c, 0x0a, 0x13, 0x52, 0x65, 0x70, 0x6f, 0x4e, 0x6f, 0x74, 0x46, 0x6f, 0x75, 0x6e, 0x64, - 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x12, 0x2a, 0x0a, 0x11, 0x63, - 0x6c, 0x6f, 0x6e, 0x65, 0x5f, 0x69, 0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x49, 0x6e, 0x50, - 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6c, 0x6f, 0x6e, 0x65, - 0x5f, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x0d, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x50, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x22, 0x41, - 0x0a, 0x17, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x4e, 0x6f, 0x74, 0x46, 0x6f, 0x75, - 0x6e, 0x64, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x65, 0x70, - 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x12, 0x12, 0x0a, - 0x04, 0x73, 0x70, 0x65, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x73, 0x70, 0x65, - 0x63, 0x22, 0x55, 0x0a, 0x13, 0x46, 0x69, 0x6c, 0x65, 0x4e, 0x6f, 0x74, 0x46, 0x6f, 0x75, 0x6e, - 0x64, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x65, 0x70, 0x6f, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x12, 0x16, 0x0a, 0x06, - 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, - 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, 0x74, 0x68, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x22, 0x4c, 0x0a, 0x11, 0x45, 0x78, 0x65, 0x63, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x1f, 0x0a, - 0x0b, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x16, - 0x0a, 0x06, 0x73, 0x74, 0x64, 0x65, 0x72, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, - 0x73, 0x74, 0x64, 0x65, 0x72, 0x72, 0x22, 0x80, 0x02, 0x0a, 0x0d, 0x53, 0x65, 0x61, 0x72, 0x63, - 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x65, 0x70, 0x6f, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x12, 0x3d, 0x0a, 0x09, - 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x1f, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, - 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, - 0x52, 0x09, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x6c, - 0x69, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, - 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x64, 0x69, 0x66, - 0x66, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, - 0x44, 0x69, 0x66, 0x66, 0x12, 0x34, 0x0a, 0x16, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, - 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x14, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x4d, 0x6f, 0x64, - 0x69, 0x66, 0x69, 0x65, 0x64, 0x46, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x2d, 0x0a, 0x05, 0x71, 0x75, - 0x65, 0x72, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x69, 0x74, 0x73, - 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, - 0x64, 0x65, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x22, 0x3a, 0x0a, 0x11, 0x52, 0x65, 0x76, - 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x19, - 0x0a, 0x08, 0x72, 0x65, 0x76, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x07, 0x72, 0x65, 0x76, 0x53, 0x70, 0x65, 0x63, 0x4a, 0x04, 0x08, 0x02, 0x10, 0x03, 0x4a, - 0x04, 0x08, 0x03, 0x10, 0x04, 0x22, 0x48, 0x0a, 0x11, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x4d, - 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x65, 0x78, - 0x70, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x65, 0x78, 0x70, 0x72, 0x12, 0x1f, - 0x0a, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x63, 0x61, 0x73, 0x65, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x43, 0x61, 0x73, 0x65, 0x22, - 0x4b, 0x0a, 0x14, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x4d, 0x61, 0x74, 0x63, - 0x68, 0x65, 0x73, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x65, 0x78, 0x70, 0x72, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x65, 0x78, 0x70, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x69, - 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x63, 0x61, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x0a, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x43, 0x61, 0x73, 0x65, 0x22, 0x4c, 0x0a, 0x10, - 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, - 0x12, 0x38, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, - 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x4b, 0x0a, 0x0f, 0x43, 0x6f, - 0x6d, 0x6d, 0x69, 0x74, 0x41, 0x66, 0x74, 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x38, 0x0a, - 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, - 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x74, 0x69, - 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x49, 0x0a, 0x12, 0x4d, 0x65, 0x73, 0x73, 0x61, - 0x67, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x12, 0x0a, + 0x70, 0x6f, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x61, + 0x74, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x61, 0x74, 0x68, 0x22, 0x4c, + 0x0a, 0x11, 0x45, 0x78, 0x65, 0x63, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x50, 0x61, 0x79, 0x6c, + 0x6f, 0x61, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x63, 0x6f, + 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x43, 0x6f, 0x64, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x74, 0x64, 0x65, 0x72, 0x72, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x64, 0x65, 0x72, 0x72, 0x22, 0x80, 0x02, 0x0a, + 0x0d, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, + 0x0a, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x72, 0x65, + 0x70, 0x6f, 0x12, 0x3d, 0x0a, 0x09, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, + 0x63, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x09, 0x72, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, + 0x73, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x05, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x6e, 0x63, 0x6c, 0x75, + 0x64, 0x65, 0x5f, 0x64, 0x69, 0x66, 0x66, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, + 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x44, 0x69, 0x66, 0x66, 0x12, 0x34, 0x0a, 0x16, 0x69, 0x6e, + 0x63, 0x6c, 0x75, 0x64, 0x65, 0x5f, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x66, + 0x69, 0x6c, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x14, 0x69, 0x6e, 0x63, 0x6c, + 0x75, 0x64, 0x65, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x46, 0x69, 0x6c, 0x65, 0x73, + 0x12, 0x2d, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x17, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x22, + 0x3a, 0x0a, 0x11, 0x52, 0x65, 0x76, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x70, 0x65, 0x63, 0x69, + 0x66, 0x69, 0x65, 0x72, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x65, 0x76, 0x5f, 0x73, 0x70, 0x65, 0x63, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x72, 0x65, 0x76, 0x53, 0x70, 0x65, 0x63, 0x4a, + 0x04, 0x08, 0x02, 0x10, 0x03, 0x4a, 0x04, 0x08, 0x03, 0x10, 0x04, 0x22, 0x48, 0x0a, 0x11, 0x41, + 0x75, 0x74, 0x68, 0x6f, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x4e, 0x6f, 0x64, 0x65, + 0x12, 0x12, 0x0a, 0x04, 0x65, 0x78, 0x70, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x65, 0x78, 0x70, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x63, + 0x61, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x67, 0x6e, 0x6f, 0x72, + 0x65, 0x43, 0x61, 0x73, 0x65, 0x22, 0x4b, 0x0a, 0x14, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, + 0x65, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x65, 0x78, 0x70, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x65, 0x78, 0x70, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x63, 0x61, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x43, 0x61, - 0x73, 0x65, 0x22, 0x46, 0x0a, 0x0f, 0x44, 0x69, 0x66, 0x66, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, - 0x73, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x65, 0x78, 0x70, 0x72, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x04, 0x65, 0x78, 0x70, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x67, 0x6e, - 0x6f, 0x72, 0x65, 0x5f, 0x63, 0x61, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, - 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x43, 0x61, 0x73, 0x65, 0x22, 0x4b, 0x0a, 0x14, 0x44, 0x69, - 0x66, 0x66, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x73, 0x46, 0x69, 0x6c, 0x65, 0x4e, 0x6f, - 0x64, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x65, 0x78, 0x70, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x04, 0x65, 0x78, 0x70, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, - 0x5f, 0x63, 0x61, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x67, 0x6e, - 0x6f, 0x72, 0x65, 0x43, 0x61, 0x73, 0x65, 0x22, 0x23, 0x0a, 0x0b, 0x42, 0x6f, 0x6f, 0x6c, 0x65, - 0x61, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x73, 0x0a, 0x0c, - 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x2e, 0x0a, 0x04, - 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x67, 0x69, 0x74, - 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, - 0x6f, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x12, 0x33, 0x0a, 0x08, - 0x6f, 0x70, 0x65, 0x72, 0x61, 0x6e, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, - 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, - 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x6e, 0x64, - 0x73, 0x22, 0x92, 0x05, 0x0a, 0x09, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x12, - 0x48, 0x0a, 0x0e, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, - 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, - 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x4d, 0x61, 0x74, - 0x63, 0x68, 0x65, 0x73, 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, 0x52, 0x0d, 0x61, 0x75, 0x74, 0x68, - 0x6f, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x12, 0x51, 0x0a, 0x11, 0x63, 0x6f, 0x6d, - 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x4d, 0x61, 0x74, - 0x63, 0x68, 0x65, 0x73, 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, 0x52, 0x10, 0x63, 0x6f, 0x6d, 0x6d, - 0x69, 0x74, 0x74, 0x65, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x12, 0x45, 0x0a, 0x0d, - 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x4e, - 0x6f, 0x64, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x42, 0x65, 0x66, - 0x6f, 0x72, 0x65, 0x12, 0x42, 0x0a, 0x0c, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x61, 0x66, - 0x74, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x69, 0x74, 0x73, - 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x41, - 0x66, 0x74, 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, - 0x69, 0x74, 0x41, 0x66, 0x74, 0x65, 0x72, 0x12, 0x4b, 0x0a, 0x0f, 0x6d, 0x65, 0x73, 0x73, 0x61, - 0x67, 0x65, 0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x20, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x4e, 0x6f, - 0x64, 0x65, 0x48, 0x00, 0x52, 0x0e, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4d, 0x61, 0x74, - 0x63, 0x68, 0x65, 0x73, 0x12, 0x42, 0x0a, 0x0c, 0x64, 0x69, 0x66, 0x66, 0x5f, 0x6d, 0x61, 0x74, - 0x63, 0x68, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x69, 0x74, - 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x69, 0x66, 0x66, 0x4d, 0x61, - 0x74, 0x63, 0x68, 0x65, 0x73, 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, 0x52, 0x0b, 0x64, 0x69, 0x66, - 0x66, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x12, 0x52, 0x0a, 0x12, 0x64, 0x69, 0x66, 0x66, - 0x5f, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x73, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x07, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x69, 0x66, 0x66, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x73, - 0x46, 0x69, 0x6c, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, 0x52, 0x10, 0x64, 0x69, 0x66, 0x66, - 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x73, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x35, 0x0a, 0x07, - 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, - 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6f, 0x6f, - 0x6c, 0x65, 0x61, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, 0x52, 0x07, 0x62, 0x6f, 0x6f, 0x6c, - 0x65, 0x61, 0x6e, 0x12, 0x38, 0x0a, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, - 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x4e, 0x6f, 0x64, - 0x65, 0x48, 0x00, 0x52, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x42, 0x07, 0x0a, - 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x6d, 0x0a, 0x0e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x31, 0x0a, 0x05, 0x6d, 0x61, 0x74, 0x63, - 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, - 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4d, 0x61, 0x74, - 0x63, 0x68, 0x48, 0x00, 0x52, 0x05, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x12, 0x1d, 0x0a, 0x09, 0x6c, - 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x68, 0x69, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, - 0x52, 0x08, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x48, 0x69, 0x74, 0x42, 0x09, 0x0a, 0x07, 0x6d, 0x65, - 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0xa9, 0x06, 0x0a, 0x0b, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, - 0x4d, 0x61, 0x74, 0x63, 0x68, 0x12, 0x10, 0x0a, 0x03, 0x6f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x03, 0x6f, 0x69, 0x64, 0x12, 0x3b, 0x0a, 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, - 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, - 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4d, 0x61, 0x74, - 0x63, 0x68, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x06, 0x61, 0x75, - 0x74, 0x68, 0x6f, 0x72, 0x12, 0x41, 0x0a, 0x09, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, - 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, - 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4d, 0x61, 0x74, - 0x63, 0x68, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x52, 0x09, 0x63, 0x6f, - 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x72, 0x65, 0x6e, - 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, - 0x73, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x65, 0x66, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, - 0x04, 0x72, 0x65, 0x66, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, - 0x72, 0x65, 0x66, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x52, 0x65, 0x66, 0x73, 0x12, 0x41, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, - 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, - 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4d, 0x61, 0x74, - 0x63, 0x68, 0x2e, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, - 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x3b, 0x0a, 0x04, 0x64, 0x69, 0x66, - 0x66, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, - 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4d, 0x61, 0x74, - 0x63, 0x68, 0x2e, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, - 0x52, 0x04, 0x64, 0x69, 0x66, 0x66, 0x12, 0x25, 0x0a, 0x0e, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, - 0x65, 0x64, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, - 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x46, 0x69, 0x6c, 0x65, 0x73, 0x1a, 0x65, 0x0a, - 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, - 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, - 0x0a, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, - 0x6d, 0x61, 0x69, 0x6c, 0x12, 0x2e, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, - 0x64, 0x61, 0x74, 0x65, 0x1a, 0x62, 0x0a, 0x0d, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x64, 0x53, - 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, - 0x37, 0x0a, 0x06, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x1f, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, - 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x52, 0x61, 0x6e, 0x67, 0x65, - 0x52, 0x06, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x1a, 0x77, 0x0a, 0x05, 0x52, 0x61, 0x6e, 0x67, - 0x65, 0x12, 0x38, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x22, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, - 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x4c, 0x6f, 0x63, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x34, 0x0a, 0x03, 0x65, - 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, - 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4d, 0x61, - 0x74, 0x63, 0x68, 0x2e, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x03, 0x65, 0x6e, - 0x64, 0x1a, 0x4e, 0x0a, 0x08, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, - 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x6f, - 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6c, 0x69, 0x6e, 0x65, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0d, 0x52, 0x04, 0x6c, 0x69, 0x6e, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6c, - 0x75, 0x6d, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x63, 0x6f, 0x6c, 0x75, 0x6d, - 0x6e, 0x22, 0x89, 0x01, 0x0a, 0x0e, 0x41, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x52, 0x65, 0x71, + 0x73, 0x65, 0x22, 0x4c, 0x0a, 0x10, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x42, 0x65, 0x66, 0x6f, + 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x38, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, + 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x22, 0x4b, 0x0a, 0x0f, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x41, 0x66, 0x74, 0x65, 0x72, 0x4e, + 0x6f, 0x64, 0x65, 0x12, 0x38, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x49, 0x0a, + 0x12, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x4e, + 0x6f, 0x64, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x65, 0x78, 0x70, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x04, 0x65, 0x78, 0x70, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, + 0x65, 0x5f, 0x63, 0x61, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x67, + 0x6e, 0x6f, 0x72, 0x65, 0x43, 0x61, 0x73, 0x65, 0x22, 0x46, 0x0a, 0x0f, 0x44, 0x69, 0x66, 0x66, + 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x65, + 0x78, 0x70, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x65, 0x78, 0x70, 0x72, 0x12, + 0x1f, 0x0a, 0x0b, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x63, 0x61, 0x73, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x43, 0x61, 0x73, 0x65, + 0x22, 0x4b, 0x0a, 0x14, 0x44, 0x69, 0x66, 0x66, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x73, + 0x46, 0x69, 0x6c, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x65, 0x78, 0x70, 0x72, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x65, 0x78, 0x70, 0x72, 0x12, 0x1f, 0x0a, 0x0b, + 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x63, 0x61, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x0a, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x43, 0x61, 0x73, 0x65, 0x22, 0x23, 0x0a, + 0x0b, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x14, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x22, 0x73, 0x0a, 0x0c, 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x4e, 0x6f, + 0x64, 0x65, 0x12, 0x2e, 0x0a, 0x04, 0x6b, 0x69, 0x6e, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x1a, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x4f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x4b, 0x69, 0x6e, 0x64, 0x52, 0x04, 0x6b, 0x69, + 0x6e, 0x64, 0x12, 0x33, 0x0a, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x6e, 0x64, 0x73, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x08, 0x6f, + 0x70, 0x65, 0x72, 0x61, 0x6e, 0x64, 0x73, 0x22, 0x92, 0x05, 0x0a, 0x09, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x48, 0x0a, 0x0e, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x5f, + 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, + 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x75, 0x74, + 0x68, 0x6f, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, + 0x52, 0x0d, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x12, + 0x51, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x5f, 0x6d, 0x61, 0x74, + 0x63, 0x68, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x69, 0x74, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, + 0x74, 0x65, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, + 0x52, 0x10, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, + 0x65, 0x73, 0x12, 0x45, 0x0a, 0x0d, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x62, 0x65, 0x66, + 0x6f, 0x72, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x69, 0x74, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x42, + 0x65, 0x66, 0x6f, 0x72, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, 0x52, 0x0c, 0x63, 0x6f, 0x6d, + 0x6d, 0x69, 0x74, 0x42, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x12, 0x42, 0x0a, 0x0c, 0x63, 0x6f, 0x6d, + 0x6d, 0x69, 0x74, 0x5f, 0x61, 0x66, 0x74, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1d, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, + 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x41, 0x66, 0x74, 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, + 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x41, 0x66, 0x74, 0x65, 0x72, 0x12, 0x4b, 0x0a, + 0x0f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4d, 0x61, 0x74, + 0x63, 0x68, 0x65, 0x73, 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, 0x52, 0x0e, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x12, 0x42, 0x0a, 0x0c, 0x64, 0x69, + 0x66, 0x66, 0x5f, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1d, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x44, 0x69, 0x66, 0x66, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x4e, 0x6f, 0x64, 0x65, 0x48, + 0x00, 0x52, 0x0b, 0x64, 0x69, 0x66, 0x66, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x73, 0x12, 0x52, + 0x0a, 0x12, 0x64, 0x69, 0x66, 0x66, 0x5f, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x73, 0x5f, + 0x66, 0x69, 0x6c, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x69, 0x74, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x69, 0x66, 0x66, 0x4d, 0x6f, + 0x64, 0x69, 0x66, 0x69, 0x65, 0x73, 0x46, 0x69, 0x6c, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, + 0x52, 0x10, 0x64, 0x69, 0x66, 0x66, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x73, 0x46, 0x69, + 0x6c, 0x65, 0x12, 0x35, 0x0a, 0x07, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x18, 0x08, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, + 0x52, 0x07, 0x62, 0x6f, 0x6f, 0x6c, 0x65, 0x61, 0x6e, 0x12, 0x38, 0x0a, 0x08, 0x6f, 0x70, 0x65, + 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x69, + 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x6f, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, 0x52, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, + 0x74, 0x6f, 0x72, 0x42, 0x07, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x6d, 0x0a, 0x0e, + 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x31, + 0x0a, 0x05, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, + 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, + 0x6d, 0x69, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x48, 0x00, 0x52, 0x05, 0x6d, 0x61, 0x74, 0x63, + 0x68, 0x12, 0x1d, 0x0a, 0x09, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x68, 0x69, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x08, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x48, 0x69, 0x74, + 0x42, 0x09, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0xa9, 0x06, 0x0a, 0x0b, + 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x12, 0x10, 0x0a, 0x03, 0x6f, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6f, 0x69, 0x64, 0x12, 0x3b, 0x0a, + 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, + 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, + 0x6d, 0x69, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, + 0x72, 0x65, 0x52, 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x12, 0x41, 0x0a, 0x09, 0x63, 0x6f, + 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, + 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, + 0x6d, 0x69, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, + 0x72, 0x65, 0x52, 0x09, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x72, 0x12, 0x18, 0x0a, + 0x07, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x07, + 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x65, 0x66, 0x73, 0x18, + 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x04, 0x72, 0x65, 0x66, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x72, 0x65, 0x66, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x09, + 0x52, 0x0a, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x65, 0x66, 0x73, 0x12, 0x41, 0x0a, 0x07, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, + 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, + 0x6d, 0x69, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x64, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, + 0x3b, 0x0a, 0x04, 0x64, 0x69, 0x66, 0x66, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, + 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, + 0x6d, 0x69, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x65, 0x64, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x04, 0x64, 0x69, 0x66, 0x66, 0x12, 0x25, 0x0a, 0x0e, + 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x09, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x46, 0x69, + 0x6c, 0x65, 0x73, 0x1a, 0x65, 0x0a, 0x09, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, + 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x12, 0x2e, 0x0a, 0x04, 0x64, 0x61, + 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, 0x64, 0x61, 0x74, 0x65, 0x1a, 0x62, 0x0a, 0x0d, 0x4d, 0x61, + 0x74, 0x63, 0x68, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x18, 0x0a, 0x07, 0x63, + 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, + 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x12, 0x37, 0x0a, 0x06, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, + 0x2e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x06, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x1a, 0x77, + 0x0a, 0x05, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x38, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4d, 0x61, 0x74, 0x63, + 0x68, 0x2e, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x12, 0x34, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, + 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, + 0x6d, 0x6d, 0x69, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x2e, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x1a, 0x4e, 0x0a, 0x08, 0x4c, 0x6f, 0x63, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x0a, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x06, 0x6f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6c, + 0x69, 0x6e, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x04, 0x6c, 0x69, 0x6e, 0x65, 0x12, + 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, + 0x06, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x22, 0x89, 0x01, 0x0a, 0x0e, 0x41, 0x72, 0x63, 0x68, + 0x69, 0x76, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x65, + 0x70, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x12, 0x18, + 0x0a, 0x07, 0x74, 0x72, 0x65, 0x65, 0x69, 0x73, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x07, 0x74, 0x72, 0x65, 0x65, 0x69, 0x73, 0x68, 0x12, 0x33, 0x0a, 0x06, 0x66, 0x6f, 0x72, 0x6d, + 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, + 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x41, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x46, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x14, 0x0a, + 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x05, 0x70, 0x61, + 0x74, 0x68, 0x73, 0x22, 0x25, 0x0a, 0x0f, 0x41, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x0a, 0x16, 0x49, 0x73, + 0x52, 0x65, 0x70, 0x6f, 0x43, 0x6c, 0x6f, 0x6e, 0x65, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x12, 0x18, 0x0a, 0x07, 0x74, 0x72, 0x65, 0x65, - 0x69, 0x73, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x74, 0x72, 0x65, 0x65, 0x69, - 0x73, 0x68, 0x12, 0x33, 0x0a, 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, - 0x31, 0x2e, 0x41, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x52, - 0x06, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, - 0x18, 0x04, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x05, 0x70, 0x61, 0x74, 0x68, 0x73, 0x22, 0x25, 0x0a, - 0x0f, 0x41, 0x72, 0x63, 0x68, 0x69, 0x76, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, - 0x64, 0x61, 0x74, 0x61, 0x22, 0x2c, 0x0a, 0x16, 0x49, 0x73, 0x52, 0x65, 0x70, 0x6f, 0x43, 0x6c, - 0x6f, 0x6e, 0x65, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, - 0x0a, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x72, 0x65, - 0x70, 0x6f, 0x22, 0x67, 0x0a, 0x17, 0x49, 0x73, 0x52, 0x65, 0x70, 0x6f, 0x43, 0x6c, 0x6f, 0x6e, - 0x65, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1c, 0x0a, - 0x09, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x09, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x61, 0x62, 0x6c, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x63, - 0x6c, 0x6f, 0x6e, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x63, 0x6c, 0x6f, - 0x6e, 0x65, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x22, 0x44, 0x0a, 0x18, 0x52, - 0x65, 0x70, 0x6f, 0x43, 0x6c, 0x6f, 0x6e, 0x65, 0x50, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 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, 0x4a, 0x04, 0x08, 0x01, 0x10, 0x02, 0x52, 0x05, 0x72, 0x65, 0x70, 0x6f, - 0x73, 0x22, 0x86, 0x01, 0x0a, 0x19, 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, 0x12, - 0x2a, 0x0a, 0x11, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x5f, 0x69, 0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x67, - 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x63, 0x6c, 0x6f, 0x6e, - 0x65, 0x49, 0x6e, 0x50, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x63, - 0x6c, 0x6f, 0x6e, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x50, 0x72, 0x6f, 0x67, 0x72, 0x65, - 0x73, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x06, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x64, 0x22, 0x3a, 0x0a, 0x13, 0x4c, 0x69, - 0x73, 0x74, 0x47, 0x69, 0x74, 0x6f, 0x6c, 0x69, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x67, 0x69, 0x74, 0x6f, 0x6c, 0x69, 0x74, 0x65, 0x5f, 0x68, 0x6f, - 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x67, 0x69, 0x74, 0x6f, 0x6c, 0x69, - 0x74, 0x65, 0x48, 0x6f, 0x73, 0x74, 0x22, 0x34, 0x0a, 0x0c, 0x47, 0x69, 0x74, 0x6f, 0x6c, 0x69, - 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, - 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x6c, 0x22, 0x48, 0x0a, 0x14, - 0x4c, 0x69, 0x73, 0x74, 0x47, 0x69, 0x74, 0x6f, 0x6c, 0x69, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x30, 0x0a, 0x05, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x18, 0x01, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, - 0x76, 0x31, 0x2e, 0x47, 0x69, 0x74, 0x6f, 0x6c, 0x69, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x52, - 0x05, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x22, 0x47, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x4f, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x65, - 0x70, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x12, 0x1f, - 0x0a, 0x0b, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x22, - 0x44, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x06, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, - 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x69, 0x74, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x06, 0x6f, - 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0xd8, 0x01, 0x0a, 0x09, 0x47, 0x69, 0x74, 0x4f, 0x62, 0x6a, - 0x65, 0x63, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, - 0x02, 0x69, 0x64, 0x12, 0x36, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x0e, 0x32, 0x22, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x47, 0x69, 0x74, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, - 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x82, 0x01, 0x0a, 0x0a, - 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1b, 0x0a, 0x17, 0x4f, 0x42, - 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, - 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x16, 0x0a, 0x12, 0x4f, 0x42, 0x4a, 0x45, 0x43, - 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, 0x4f, 0x4d, 0x4d, 0x49, 0x54, 0x10, 0x01, 0x12, - 0x13, 0x0a, 0x0f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x54, - 0x41, 0x47, 0x10, 0x02, 0x12, 0x14, 0x0a, 0x10, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x54, - 0x59, 0x50, 0x45, 0x5f, 0x54, 0x52, 0x45, 0x45, 0x10, 0x03, 0x12, 0x14, 0x0a, 0x10, 0x4f, 0x42, - 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x42, 0x4c, 0x4f, 0x42, 0x10, 0x04, - 0x22, 0x97, 0x01, 0x0a, 0x1e, 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, 0x12, 0x56, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, - 0x6e, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x27, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, - 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, - 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, - 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x64, - 0x65, 0x70, 0x6f, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x09, 0x64, 0x65, 0x70, 0x6f, 0x74, 0x50, 0x61, 0x74, 0x68, 0x22, 0x21, 0x0a, 0x1f, 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, 0x79, 0x0a, - 0x1f, 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, - 0x12, 0x56, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, - 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, - 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, - 0x6f, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, - 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, - 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x22, 0x0a, 0x20, 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, 0x67, 0x0a, 0x19, - 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, - 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x34, 0x70, - 0x6f, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x34, 0x70, 0x6f, 0x72, - 0x74, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x34, 0x75, 0x73, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x06, 0x70, 0x34, 0x75, 0x73, 0x65, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x34, 0x70, - 0x61, 0x73, 0x73, 0x77, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x70, 0x34, 0x70, - 0x61, 0x73, 0x73, 0x77, 0x64, 0x22, 0x9b, 0x01, 0x0a, 0x1c, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, - 0x63, 0x65, 0x47, 0x65, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x52, + 0x28, 0x09, 0x52, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x22, 0x67, 0x0a, 0x17, 0x49, 0x73, 0x52, 0x65, + 0x70, 0x6f, 0x43, 0x6c, 0x6f, 0x6e, 0x65, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x61, 0x62, 0x6c, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x61, 0x62, 0x6c, + 0x65, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x06, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, + 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, + 0x6e, 0x22, 0x44, 0x0a, 0x18, 0x52, 0x65, 0x70, 0x6f, 0x43, 0x6c, 0x6f, 0x6e, 0x65, 0x50, 0x72, + 0x6f, 0x67, 0x72, 0x65, 0x73, 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, 0x4a, 0x04, 0x08, 0x01, 0x10, 0x02, + 0x52, 0x05, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x22, 0x86, 0x01, 0x0a, 0x19, 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, 0x12, 0x2a, 0x0a, 0x11, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x5f, 0x69, + 0x6e, 0x5f, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x0f, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x49, 0x6e, 0x50, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, + 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x67, 0x72, + 0x65, 0x73, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x6c, 0x6f, 0x6e, 0x65, + 0x50, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6c, 0x6f, 0x6e, + 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x63, 0x6c, 0x6f, 0x6e, 0x65, 0x64, + 0x22, 0x3a, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x47, 0x69, 0x74, 0x6f, 0x6c, 0x69, 0x74, 0x65, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x67, 0x69, 0x74, 0x6f, 0x6c, + 0x69, 0x74, 0x65, 0x5f, 0x68, 0x6f, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, + 0x67, 0x69, 0x74, 0x6f, 0x6c, 0x69, 0x74, 0x65, 0x48, 0x6f, 0x73, 0x74, 0x22, 0x34, 0x0a, 0x0c, + 0x47, 0x69, 0x74, 0x6f, 0x6c, 0x69, 0x74, 0x65, 0x52, 0x65, 0x70, 0x6f, 0x12, 0x12, 0x0a, 0x04, + 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, + 0x72, 0x6c, 0x22, 0x48, 0x0a, 0x14, 0x4c, 0x69, 0x73, 0x74, 0x47, 0x69, 0x74, 0x6f, 0x6c, 0x69, + 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x30, 0x0a, 0x05, 0x72, 0x65, + 0x70, 0x6f, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x69, 0x74, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x69, 0x74, 0x6f, 0x6c, 0x69, 0x74, + 0x65, 0x52, 0x65, 0x70, 0x6f, 0x52, 0x05, 0x72, 0x65, 0x70, 0x6f, 0x73, 0x22, 0x47, 0x0a, 0x10, + 0x47, 0x65, 0x74, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x12, 0x0a, 0x04, 0x72, 0x65, 0x70, 0x6f, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x72, 0x65, 0x70, 0x6f, 0x12, 0x1f, 0x0a, 0x0b, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x5f, 0x6e, + 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x6f, 0x62, 0x6a, 0x65, 0x63, + 0x74, 0x4e, 0x61, 0x6d, 0x65, 0x22, 0x44, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x4f, 0x62, 0x6a, 0x65, + 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x06, 0x6f, 0x62, + 0x6a, 0x65, 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x69, 0x74, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x69, 0x74, 0x4f, 0x62, 0x6a, + 0x65, 0x63, 0x74, 0x52, 0x06, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x22, 0xd8, 0x01, 0x0a, 0x09, + 0x47, 0x69, 0x74, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x69, 0x64, 0x12, 0x36, 0x0a, 0x04, 0x74, 0x79, 0x70, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x69, 0x74, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, + 0x65, 0x22, 0x82, 0x01, 0x0a, 0x0a, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x79, 0x70, 0x65, + 0x12, 0x1b, 0x0a, 0x17, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, + 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x16, 0x0a, + 0x12, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, 0x4f, 0x4d, + 0x4d, 0x49, 0x54, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, + 0x54, 0x59, 0x50, 0x45, 0x5f, 0x54, 0x41, 0x47, 0x10, 0x02, 0x12, 0x14, 0x0a, 0x10, 0x4f, 0x42, + 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x54, 0x52, 0x45, 0x45, 0x10, 0x03, + 0x12, 0x14, 0x0a, 0x10, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, + 0x42, 0x4c, 0x4f, 0x42, 0x10, 0x04, 0x22, 0x97, 0x01, 0x0a, 0x1e, 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, 0x12, 0x56, 0x0a, 0x12, 0x63, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x11, + 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x6f, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x65, 0x70, 0x6f, 0x74, 0x50, 0x61, 0x74, 0x68, + 0x22, 0x21, 0x0a, 0x1f, 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, 0x79, 0x0a, 0x1f, 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, 0x12, 0x56, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x11, 0x63, 0x6f, 0x6e, - 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x23, - 0x0a, 0x0d, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, - 0x74, 0x49, 0x64, 0x22, 0x61, 0x0a, 0x1d, 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, 0x12, 0x40, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, - 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, + 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x22, + 0x0a, 0x20, 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, 0x67, 0x0a, 0x19, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x6f, + 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, + 0x16, 0x0a, 0x06, 0x70, 0x34, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x06, 0x70, 0x34, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x34, 0x75, 0x73, 0x65, + 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x34, 0x75, 0x73, 0x65, 0x72, 0x12, + 0x1a, 0x0a, 0x08, 0x70, 0x34, 0x70, 0x61, 0x73, 0x73, 0x77, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x08, 0x70, 0x34, 0x70, 0x61, 0x73, 0x73, 0x77, 0x64, 0x22, 0x9b, 0x01, 0x0a, 0x1c, + 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, 0x12, 0x56, 0x0a, 0x12, + 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, + 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, - 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x52, 0x0a, 0x63, 0x68, 0x61, 0x6e, - 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x22, 0xe1, 0x03, 0x0a, 0x12, 0x50, 0x65, 0x72, 0x66, 0x6f, - 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x12, 0x0e, 0x0a, - 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3f, 0x0a, - 0x0d, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x61, 0x74, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, - 0x52, 0x0c, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x65, 0x12, 0x4e, - 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x38, 0x2e, + 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, + 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x49, 0x64, 0x22, 0x61, 0x0a, 0x1d, 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, 0x12, 0x40, 0x0a, 0x0a, 0x63, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, + 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, + 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, + 0x52, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x22, 0xe1, 0x03, 0x0a, + 0x12, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, + 0x69, 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x02, 0x69, 0x64, 0x12, 0x3f, 0x0a, 0x0d, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x64, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0c, 0x63, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x44, 0x61, 0x74, 0x65, 0x12, 0x4e, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x38, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x67, + 0x65, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x68, + 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, + 0x74, 0x61, 0x74, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, + 0x74, 0x69, 0x74, 0x6c, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x69, 0x74, + 0x6c, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0xe1, 0x01, 0x0a, + 0x17, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, + 0x69, 0x73, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x29, 0x0a, 0x25, 0x50, 0x45, 0x52, 0x46, + 0x4f, 0x52, 0x43, 0x45, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x47, 0x45, 0x4c, 0x49, 0x53, 0x54, 0x5f, + 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, + 0x44, 0x10, 0x00, 0x12, 0x27, 0x0a, 0x23, 0x50, 0x45, 0x52, 0x46, 0x4f, 0x52, 0x43, 0x45, 0x5f, + 0x43, 0x48, 0x41, 0x4e, 0x47, 0x45, 0x4c, 0x49, 0x53, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, + 0x5f, 0x53, 0x55, 0x42, 0x4d, 0x49, 0x54, 0x54, 0x45, 0x44, 0x10, 0x01, 0x12, 0x25, 0x0a, 0x21, + 0x50, 0x45, 0x52, 0x46, 0x4f, 0x52, 0x43, 0x45, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x47, 0x45, 0x4c, + 0x49, 0x53, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x50, 0x45, 0x4e, 0x44, 0x49, 0x4e, + 0x47, 0x10, 0x02, 0x12, 0x25, 0x0a, 0x21, 0x50, 0x45, 0x52, 0x46, 0x4f, 0x52, 0x43, 0x45, 0x5f, + 0x43, 0x48, 0x41, 0x4e, 0x47, 0x45, 0x4c, 0x49, 0x53, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, + 0x5f, 0x53, 0x48, 0x45, 0x4c, 0x56, 0x45, 0x44, 0x10, 0x03, 0x12, 0x24, 0x0a, 0x20, 0x50, 0x45, + 0x52, 0x46, 0x4f, 0x52, 0x43, 0x45, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x47, 0x45, 0x4c, 0x49, 0x53, + 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x43, 0x4c, 0x4f, 0x53, 0x45, 0x44, 0x10, 0x04, + 0x22, 0x74, 0x0a, 0x1a, 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, 0x12, 0x56, + 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x74, + 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x69, 0x74, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, + 0x63, 0x65, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, + 0x69, 0x6c, 0x73, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, + 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x1d, 0x0a, 0x1b, 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, 0x8f, 0x01, 0x0a, 0x1f, 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, 0x12, 0x56, 0x0a, 0x12, 0x63, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x11, + 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x12, 0x14, 0x0a, 0x05, 0x64, 0x65, 0x70, 0x6f, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x05, 0x64, 0x65, 0x70, 0x6f, 0x74, 0x22, 0x5d, 0x0a, 0x20, 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, 0x12, 0x39, 0x0a, 0x08, 0x70, + 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, - 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x2e, - 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, - 0x73, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x16, - 0x0a, 0x06, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, - 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x18, - 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x12, 0x18, 0x0a, 0x07, - 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, - 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0xe1, 0x01, 0x0a, 0x17, 0x50, 0x65, 0x72, 0x66, 0x6f, - 0x72, 0x63, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x6c, 0x69, 0x73, 0x74, 0x53, 0x74, 0x61, - 0x74, 0x65, 0x12, 0x29, 0x0a, 0x25, 0x50, 0x45, 0x52, 0x46, 0x4f, 0x52, 0x43, 0x45, 0x5f, 0x43, - 0x48, 0x41, 0x4e, 0x47, 0x45, 0x4c, 0x49, 0x53, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, - 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x27, 0x0a, - 0x23, 0x50, 0x45, 0x52, 0x46, 0x4f, 0x52, 0x43, 0x45, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x47, 0x45, - 0x4c, 0x49, 0x53, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x55, 0x42, 0x4d, 0x49, - 0x54, 0x54, 0x45, 0x44, 0x10, 0x01, 0x12, 0x25, 0x0a, 0x21, 0x50, 0x45, 0x52, 0x46, 0x4f, 0x52, - 0x43, 0x45, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x47, 0x45, 0x4c, 0x49, 0x53, 0x54, 0x5f, 0x53, 0x54, - 0x41, 0x54, 0x45, 0x5f, 0x50, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x12, 0x25, 0x0a, - 0x21, 0x50, 0x45, 0x52, 0x46, 0x4f, 0x52, 0x43, 0x45, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x47, 0x45, - 0x4c, 0x49, 0x53, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x45, 0x5f, 0x53, 0x48, 0x45, 0x4c, 0x56, - 0x45, 0x44, 0x10, 0x03, 0x12, 0x24, 0x0a, 0x20, 0x50, 0x45, 0x52, 0x46, 0x4f, 0x52, 0x43, 0x45, - 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x47, 0x45, 0x4c, 0x49, 0x53, 0x54, 0x5f, 0x53, 0x54, 0x41, 0x54, - 0x45, 0x5f, 0x43, 0x4c, 0x4f, 0x53, 0x45, 0x44, 0x10, 0x04, 0x22, 0x74, 0x0a, 0x1a, 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, 0x12, 0x56, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x6e, + 0x66, 0x6f, 0x72, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x52, 0x08, 0x70, 0x72, + 0x6f, 0x74, 0x65, 0x63, 0x74, 0x73, 0x22, 0x94, 0x01, 0x0a, 0x1e, 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, 0x12, 0x56, 0x0a, 0x12, 0x63, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x11, + 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x75, 0x73, 0x65, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x08, 0x75, 0x73, 0x65, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x5c, 0x0a, + 0x1f, 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, + 0x12, 0x39, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x1d, 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, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x73, 0x22, 0xb6, 0x01, 0x0a, 0x0f, + 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x12, + 0x14, 0x0a, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, + 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x65, 0x6e, 0x74, 0x69, + 0x74, 0x79, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, + 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x61, 0x74, 0x63, 0x68, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x12, 0x21, 0x0a, + 0x0c, 0x69, 0x73, 0x5f, 0x65, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x73, 0x45, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, + 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, + 0x68, 0x6f, 0x73, 0x74, 0x22, 0x8b, 0x01, 0x0a, 0x1b, 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, 0x12, 0x56, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x27, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x14, 0x0a, 0x05, + 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x67, 0x72, 0x6f, + 0x75, 0x70, 0x22, 0x3c, 0x0a, 0x1c, 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, 0x12, 0x1c, 0x0a, 0x09, 0x75, 0x73, 0x65, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x75, 0x73, 0x65, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x73, + 0x22, 0x6e, 0x0a, 0x14, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x55, 0x73, 0x65, 0x72, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x56, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, - 0x22, 0x1d, 0x0a, 0x1b, 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, - 0x8f, 0x01, 0x0a, 0x1f, 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, 0x12, 0x56, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, - 0x6e, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x27, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, - 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, - 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, - 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x64, - 0x65, 0x70, 0x6f, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x64, 0x65, 0x70, 0x6f, - 0x74, 0x22, 0x5d, 0x0a, 0x20, 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, 0x12, 0x39, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, - 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 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, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x73, - 0x22, 0x94, 0x01, 0x0a, 0x1e, 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, 0x12, 0x56, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, - 0x6e, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x27, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, - 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, - 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, - 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x75, - 0x73, 0x65, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x75, - 0x73, 0x65, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x5c, 0x0a, 0x1f, 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, 0x12, 0x39, 0x0a, 0x08, 0x70, 0x72, - 0x6f, 0x74, 0x65, 0x63, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 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, 0x52, 0x08, 0x70, 0x72, 0x6f, - 0x74, 0x65, 0x63, 0x74, 0x73, 0x22, 0xb6, 0x01, 0x0a, 0x0f, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, - 0x63, 0x65, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x65, 0x76, - 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x12, - 0x1f, 0x0a, 0x0b, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x54, 0x79, 0x70, 0x65, - 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, - 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x4e, 0x61, 0x6d, - 0x65, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x05, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x12, 0x21, 0x0a, 0x0c, 0x69, 0x73, 0x5f, 0x65, 0x78, - 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, - 0x73, 0x45, 0x78, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x6f, - 0x73, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x22, 0x8b, - 0x01, 0x0a, 0x1b, 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, 0x12, 0x56, - 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x65, 0x74, - 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 0x69, 0x74, - 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, - 0x63, 0x65, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, - 0x69, 0x6c, 0x73, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x44, - 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x22, 0x3c, 0x0a, 0x1c, - 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, 0x12, 0x1c, 0x0a, 0x09, - 0x75, 0x73, 0x65, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, - 0x09, 0x75, 0x73, 0x65, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x22, 0x6e, 0x0a, 0x14, 0x50, 0x65, - 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x12, 0x56, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, - 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x65, - 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, - 0x69, 0x6f, 0x6e, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x22, 0x49, 0x0a, 0x15, 0x50, 0x65, - 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x55, 0x73, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x12, 0x30, 0x0a, 0x05, 0x75, 0x73, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x1a, 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, 0x52, 0x05, - 0x75, 0x73, 0x65, 0x72, 0x73, 0x22, 0x40, 0x0a, 0x0c, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, - 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x75, 0x73, 0x65, 0x72, 0x6e, 0x61, 0x6d, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x75, 0x73, 0x65, 0x72, 0x6e, 0x61, 0x6d, - 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x22, 0x57, 0x0a, 0x10, 0x4d, 0x65, 0x72, 0x67, 0x65, - 0x42, 0x61, 0x73, 0x65, 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, 0x12, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, - 0x68, 0x65, 0x61, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x68, 0x65, 0x61, 0x64, - 0x22, 0x46, 0x0a, 0x11, 0x4d, 0x65, 0x72, 0x67, 0x65, 0x42, 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x31, 0x0a, 0x15, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x5f, 0x62, - 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x6d, 0x65, 0x72, 0x67, 0x65, 0x42, 0x61, 0x73, 0x65, 0x43, - 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x53, 0x68, 0x61, 0x22, 0x35, 0x0a, 0x16, 0x46, 0x69, 0x72, 0x73, - 0x74, 0x45, 0x76, 0x65, 0x72, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 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, 0x22, - 0x4a, 0x0a, 0x17, 0x46, 0x69, 0x72, 0x73, 0x74, 0x45, 0x76, 0x65, 0x72, 0x43, 0x6f, 0x6d, 0x6d, - 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2f, 0x0a, 0x06, 0x63, 0x6f, - 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x69, 0x74, - 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x69, 0x74, 0x43, 0x6f, 0x6d, - 0x6d, 0x69, 0x74, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x22, 0x5b, 0x0a, 0x12, 0x42, - 0x65, 0x68, 0x69, 0x6e, 0x64, 0x41, 0x68, 0x65, 0x61, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x22, 0x49, 0x0a, 0x15, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x55, 0x73, 0x65, 0x72, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x30, 0x0a, 0x05, 0x75, 0x73, 0x65, + 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 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, 0x52, 0x05, 0x75, 0x73, 0x65, 0x72, 0x73, 0x22, 0x40, 0x0a, 0x0c, 0x50, + 0x65, 0x72, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x55, 0x73, 0x65, 0x72, 0x12, 0x1a, 0x0a, 0x08, 0x75, + 0x73, 0x65, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x75, + 0x73, 0x65, 0x72, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x65, 0x6d, 0x61, 0x69, 0x6c, 0x22, 0x57, 0x0a, + 0x10, 0x4d, 0x65, 0x72, 0x67, 0x65, 0x42, 0x61, 0x73, 0x65, 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, 0x12, - 0x0a, 0x04, 0x6c, 0x65, 0x66, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x6c, 0x65, - 0x66, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x72, 0x69, 0x67, 0x68, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x0c, 0x52, 0x05, 0x72, 0x69, 0x67, 0x68, 0x74, 0x22, 0x43, 0x0a, 0x13, 0x42, 0x65, 0x68, 0x69, - 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, 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, 0xd1, 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, 0x74, - 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, 0x12, 0x17, 0x0a, 0x13, 0x53, - 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x47, - 0x45, 0x44, 0x10, 0x04, 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, 0xce, 0x02, 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, + 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x62, 0x61, + 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x65, 0x61, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, + 0x52, 0x04, 0x68, 0x65, 0x61, 0x64, 0x22, 0x46, 0x0a, 0x11, 0x4d, 0x65, 0x72, 0x67, 0x65, 0x42, + 0x61, 0x73, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x31, 0x0a, 0x15, 0x6d, + 0x65, 0x72, 0x67, 0x65, 0x5f, 0x62, 0x61, 0x73, 0x65, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, + 0x5f, 0x73, 0x68, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, 0x6d, 0x65, 0x72, 0x67, + 0x65, 0x42, 0x61, 0x73, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x53, 0x68, 0x61, 0x22, 0x35, + 0x0a, 0x16, 0x46, 0x69, 0x72, 0x73, 0x74, 0x45, 0x76, 0x65, 0x72, 0x43, 0x6f, 0x6d, 0x6d, 0x69, + 0x74, 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, 0x22, 0x4a, 0x0a, 0x17, 0x46, 0x69, 0x72, 0x73, 0x74, 0x45, 0x76, + 0x65, 0x72, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x12, 0x2f, 0x0a, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x17, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x47, 0x69, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x52, 0x06, 0x63, 0x6f, 0x6d, 0x6d, 0x69, + 0x74, 0x22, 0x5b, 0x0a, 0x12, 0x42, 0x65, 0x68, 0x69, 0x6e, 0x64, 0x41, 0x68, 0x65, 0x61, 0x64, + 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, 0x12, 0x0a, 0x04, 0x6c, 0x65, 0x66, 0x74, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0c, 0x52, 0x04, 0x6c, 0x65, 0x66, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x72, 0x69, 0x67, 0x68, + 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x72, 0x69, 0x67, 0x68, 0x74, 0x22, 0x43, + 0x0a, 0x13, 0x42, 0x65, 0x68, 0x69, 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, 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, 0xd1, 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, 0x74, 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, 0x12, 0x17, 0x0a, 0x13, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x54, 0x59, 0x50, 0x45, + 0x5f, 0x43, 0x48, 0x41, 0x4e, 0x47, 0x45, 0x44, 0x10, 0x04, 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, 0xce, + 0x02, 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, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, - 0x02, 0x12, 0x66, 0x0a, 0x10, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, - 0x6f, 0x72, 0x69, 0x65, 0x73, 0x12, 0x25, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, - 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, - 0x6f, 0x72, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x67, - 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, - 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x32, 0x90, 0x18, 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, 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, + 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, 0x12, 0x66, 0x0a, 0x10, 0x4c, 0x69, 0x73, 0x74, 0x52, + 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x12, 0x25, 0x2e, 0x67, 0x69, + 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, + 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x6f, 0x72, 0x69, + 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x32, + 0xe5, 0x18, 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, 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, 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, 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, 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, + 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, 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, - 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, + 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, 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, 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, + 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, 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, - 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, + 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, 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, 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, + 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, 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, 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, 0x12, 0x42, 0x0a, 0x04, 0x53, 0x74, 0x61, - 0x74, 0x12, 0x19, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, - 0x2e, 0x53, 0x74, 0x61, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x67, - 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, 0x12, 0x4d, 0x0a, - 0x07, 0x52, 0x65, 0x61, 0x64, 0x44, 0x69, 0x72, 0x12, 0x1c, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, - 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x61, 0x64, 0x44, 0x69, 0x72, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x61, 0x64, 0x44, 0x69, 0x72, 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, + 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, 0x12, + 0x42, 0x0a, 0x04, 0x53, 0x74, 0x61, 0x74, 0x12, 0x19, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, + 0x90, 0x02, 0x01, 0x12, 0x4d, 0x0a, 0x07, 0x52, 0x65, 0x61, 0x64, 0x44, 0x69, 0x72, 0x12, 0x1c, + 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, + 0x61, 0x64, 0x44, 0x69, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x67, + 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x61, 0x64, + 0x44, 0x69, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x03, 0x90, 0x02, 0x01, + 0x30, 0x01, 0x12, 0x53, 0x0a, 0x09, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4c, 0x6f, 0x67, 0x12, + 0x1e, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, + 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4c, 0x6f, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x1f, 0x2e, 0x67, 0x69, 0x74, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, + 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x4c, 0x6f, 0x67, 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 ( @@ -8512,280 +8848,289 @@ func file_gitserver_proto_rawDescGZIP() []byte { return file_gitserver_proto_rawDescData } -var file_gitserver_proto_enumTypes = make([]protoimpl.EnumInfo, 7) -var file_gitserver_proto_msgTypes = make([]protoimpl.MessageInfo, 113) +var file_gitserver_proto_enumTypes = make([]protoimpl.EnumInfo, 8) +var file_gitserver_proto_msgTypes = make([]protoimpl.MessageInfo, 115) var file_gitserver_proto_goTypes = []interface{}{ (OperatorKind)(0), // 0: gitserver.v1.OperatorKind (ArchiveFormat)(0), // 1: gitserver.v1.ArchiveFormat - (RawDiffRequest_ComparisonType)(0), // 2: gitserver.v1.RawDiffRequest.ComparisonType - (GitRef_RefType)(0), // 3: gitserver.v1.GitRef.RefType - (GitObject_ObjectType)(0), // 4: gitserver.v1.GitObject.ObjectType - (PerforceChangelist_PerforceChangelistState)(0), // 5: gitserver.v1.PerforceChangelist.PerforceChangelistState - (ChangedFile_Status)(0), // 6: gitserver.v1.ChangedFile.Status - (*ListRepositoriesRequest)(nil), // 7: gitserver.v1.ListRepositoriesRequest - (*ListRepositoriesResponse)(nil), // 8: gitserver.v1.ListRepositoriesResponse - (*DeleteRepositoryRequest)(nil), // 9: gitserver.v1.DeleteRepositoryRequest - (*DeleteRepositoryResponse)(nil), // 10: gitserver.v1.DeleteRepositoryResponse - (*FetchRepositoryRequest)(nil), // 11: gitserver.v1.FetchRepositoryRequest - (*FetchRepositoryResponse)(nil), // 12: gitserver.v1.FetchRepositoryResponse - (*ContributorCountsRequest)(nil), // 13: gitserver.v1.ContributorCountsRequest - (*ContributorCount)(nil), // 14: gitserver.v1.ContributorCount - (*ContributorCountsResponse)(nil), // 15: gitserver.v1.ContributorCountsResponse - (*RawDiffRequest)(nil), // 16: gitserver.v1.RawDiffRequest - (*RawDiffResponse)(nil), // 17: gitserver.v1.RawDiffResponse - (*ListRefsRequest)(nil), // 18: gitserver.v1.ListRefsRequest - (*ListRefsResponse)(nil), // 19: gitserver.v1.ListRefsResponse - (*GitRef)(nil), // 20: gitserver.v1.GitRef - (*StatRequest)(nil), // 21: gitserver.v1.StatRequest - (*StatResponse)(nil), // 22: gitserver.v1.StatResponse - (*ReadDirRequest)(nil), // 23: gitserver.v1.ReadDirRequest - (*ReadDirResponse)(nil), // 24: gitserver.v1.ReadDirResponse - (*GitSubmodule)(nil), // 25: gitserver.v1.GitSubmodule - (*FileInfo)(nil), // 26: gitserver.v1.FileInfo - (*ResolveRevisionRequest)(nil), // 27: gitserver.v1.ResolveRevisionRequest - (*ResolveRevisionResponse)(nil), // 28: gitserver.v1.ResolveRevisionResponse - (*RevAtTimeRequest)(nil), // 29: gitserver.v1.RevAtTimeRequest - (*RevAtTimeResponse)(nil), // 30: gitserver.v1.RevAtTimeResponse - (*GetCommitRequest)(nil), // 31: gitserver.v1.GetCommitRequest - (*GetCommitResponse)(nil), // 32: gitserver.v1.GetCommitResponse - (*GitCommit)(nil), // 33: gitserver.v1.GitCommit - (*GitSignature)(nil), // 34: gitserver.v1.GitSignature - (*BlameRequest)(nil), // 35: gitserver.v1.BlameRequest - (*BlameRange)(nil), // 36: gitserver.v1.BlameRange - (*BlameResponse)(nil), // 37: gitserver.v1.BlameResponse - (*BlameHunk)(nil), // 38: gitserver.v1.BlameHunk - (*BlameAuthor)(nil), // 39: gitserver.v1.BlameAuthor - (*PreviousCommit)(nil), // 40: gitserver.v1.PreviousCommit - (*DefaultBranchRequest)(nil), // 41: gitserver.v1.DefaultBranchRequest - (*DefaultBranchResponse)(nil), // 42: gitserver.v1.DefaultBranchResponse - (*ReadFileRequest)(nil), // 43: gitserver.v1.ReadFileRequest - (*ReadFileResponse)(nil), // 44: gitserver.v1.ReadFileResponse - (*DiskInfoRequest)(nil), // 45: gitserver.v1.DiskInfoRequest - (*DiskInfoResponse)(nil), // 46: gitserver.v1.DiskInfoResponse - (*PatchCommitInfo)(nil), // 47: gitserver.v1.PatchCommitInfo - (*PushConfig)(nil), // 48: gitserver.v1.PushConfig - (*CreateCommitFromPatchBinaryRequest)(nil), // 49: gitserver.v1.CreateCommitFromPatchBinaryRequest - (*CreateCommitFromPatchError)(nil), // 50: gitserver.v1.CreateCommitFromPatchError - (*CreateCommitFromPatchBinaryResponse)(nil), // 51: gitserver.v1.CreateCommitFromPatchBinaryResponse - (*ExecRequest)(nil), // 52: gitserver.v1.ExecRequest - (*ExecResponse)(nil), // 53: gitserver.v1.ExecResponse - (*RepoNotFoundPayload)(nil), // 54: gitserver.v1.RepoNotFoundPayload - (*RevisionNotFoundPayload)(nil), // 55: gitserver.v1.RevisionNotFoundPayload - (*FileNotFoundPayload)(nil), // 56: gitserver.v1.FileNotFoundPayload - (*ExecStatusPayload)(nil), // 57: gitserver.v1.ExecStatusPayload - (*SearchRequest)(nil), // 58: gitserver.v1.SearchRequest - (*RevisionSpecifier)(nil), // 59: gitserver.v1.RevisionSpecifier - (*AuthorMatchesNode)(nil), // 60: gitserver.v1.AuthorMatchesNode - (*CommitterMatchesNode)(nil), // 61: gitserver.v1.CommitterMatchesNode - (*CommitBeforeNode)(nil), // 62: gitserver.v1.CommitBeforeNode - (*CommitAfterNode)(nil), // 63: gitserver.v1.CommitAfterNode - (*MessageMatchesNode)(nil), // 64: gitserver.v1.MessageMatchesNode - (*DiffMatchesNode)(nil), // 65: gitserver.v1.DiffMatchesNode - (*DiffModifiesFileNode)(nil), // 66: gitserver.v1.DiffModifiesFileNode - (*BooleanNode)(nil), // 67: gitserver.v1.BooleanNode - (*OperatorNode)(nil), // 68: gitserver.v1.OperatorNode - (*QueryNode)(nil), // 69: gitserver.v1.QueryNode - (*SearchResponse)(nil), // 70: gitserver.v1.SearchResponse - (*CommitMatch)(nil), // 71: gitserver.v1.CommitMatch - (*ArchiveRequest)(nil), // 72: gitserver.v1.ArchiveRequest - (*ArchiveResponse)(nil), // 73: gitserver.v1.ArchiveResponse - (*IsRepoCloneableRequest)(nil), // 74: gitserver.v1.IsRepoCloneableRequest - (*IsRepoCloneableResponse)(nil), // 75: gitserver.v1.IsRepoCloneableResponse - (*RepoCloneProgressRequest)(nil), // 76: gitserver.v1.RepoCloneProgressRequest - (*RepoCloneProgressResponse)(nil), // 77: gitserver.v1.RepoCloneProgressResponse - (*ListGitoliteRequest)(nil), // 78: gitserver.v1.ListGitoliteRequest - (*GitoliteRepo)(nil), // 79: gitserver.v1.GitoliteRepo - (*ListGitoliteResponse)(nil), // 80: gitserver.v1.ListGitoliteResponse - (*GetObjectRequest)(nil), // 81: gitserver.v1.GetObjectRequest - (*GetObjectResponse)(nil), // 82: gitserver.v1.GetObjectResponse - (*GitObject)(nil), // 83: gitserver.v1.GitObject - (*IsPerforcePathCloneableRequest)(nil), // 84: gitserver.v1.IsPerforcePathCloneableRequest - (*IsPerforcePathCloneableResponse)(nil), // 85: gitserver.v1.IsPerforcePathCloneableResponse - (*CheckPerforceCredentialsRequest)(nil), // 86: gitserver.v1.CheckPerforceCredentialsRequest - (*CheckPerforceCredentialsResponse)(nil), // 87: gitserver.v1.CheckPerforceCredentialsResponse - (*PerforceConnectionDetails)(nil), // 88: gitserver.v1.PerforceConnectionDetails - (*PerforceGetChangelistRequest)(nil), // 89: gitserver.v1.PerforceGetChangelistRequest - (*PerforceGetChangelistResponse)(nil), // 90: gitserver.v1.PerforceGetChangelistResponse - (*PerforceChangelist)(nil), // 91: gitserver.v1.PerforceChangelist - (*IsPerforceSuperUserRequest)(nil), // 92: gitserver.v1.IsPerforceSuperUserRequest - (*IsPerforceSuperUserResponse)(nil), // 93: gitserver.v1.IsPerforceSuperUserResponse - (*PerforceProtectsForDepotRequest)(nil), // 94: gitserver.v1.PerforceProtectsForDepotRequest - (*PerforceProtectsForDepotResponse)(nil), // 95: gitserver.v1.PerforceProtectsForDepotResponse - (*PerforceProtectsForUserRequest)(nil), // 96: gitserver.v1.PerforceProtectsForUserRequest - (*PerforceProtectsForUserResponse)(nil), // 97: gitserver.v1.PerforceProtectsForUserResponse - (*PerforceProtect)(nil), // 98: gitserver.v1.PerforceProtect - (*PerforceGroupMembersRequest)(nil), // 99: gitserver.v1.PerforceGroupMembersRequest - (*PerforceGroupMembersResponse)(nil), // 100: gitserver.v1.PerforceGroupMembersResponse - (*PerforceUsersRequest)(nil), // 101: gitserver.v1.PerforceUsersRequest - (*PerforceUsersResponse)(nil), // 102: gitserver.v1.PerforceUsersResponse - (*PerforceUser)(nil), // 103: gitserver.v1.PerforceUser - (*MergeBaseRequest)(nil), // 104: gitserver.v1.MergeBaseRequest - (*MergeBaseResponse)(nil), // 105: gitserver.v1.MergeBaseResponse - (*FirstEverCommitRequest)(nil), // 106: gitserver.v1.FirstEverCommitRequest - (*FirstEverCommitResponse)(nil), // 107: gitserver.v1.FirstEverCommitResponse - (*BehindAheadRequest)(nil), // 108: gitserver.v1.BehindAheadRequest - (*BehindAheadResponse)(nil), // 109: gitserver.v1.BehindAheadResponse - (*ChangedFilesRequest)(nil), // 110: gitserver.v1.ChangedFilesRequest - (*ChangedFilesResponse)(nil), // 111: gitserver.v1.ChangedFilesResponse - (*ChangedFile)(nil), // 112: gitserver.v1.ChangedFile - (*ListRepositoriesResponse_GitRepository)(nil), // 113: gitserver.v1.ListRepositoriesResponse.GitRepository - (*CreateCommitFromPatchBinaryRequest_Metadata)(nil), // 114: gitserver.v1.CreateCommitFromPatchBinaryRequest.Metadata - (*CreateCommitFromPatchBinaryRequest_Patch)(nil), // 115: gitserver.v1.CreateCommitFromPatchBinaryRequest.Patch - (*CommitMatch_Signature)(nil), // 116: gitserver.v1.CommitMatch.Signature - (*CommitMatch_MatchedString)(nil), // 117: gitserver.v1.CommitMatch.MatchedString - (*CommitMatch_Range)(nil), // 118: gitserver.v1.CommitMatch.Range - (*CommitMatch_Location)(nil), // 119: gitserver.v1.CommitMatch.Location - (*timestamppb.Timestamp)(nil), // 120: google.protobuf.Timestamp + (CommitLogRequest_CommitLogOrder)(0), // 2: gitserver.v1.CommitLogRequest.CommitLogOrder + (RawDiffRequest_ComparisonType)(0), // 3: gitserver.v1.RawDiffRequest.ComparisonType + (GitRef_RefType)(0), // 4: gitserver.v1.GitRef.RefType + (GitObject_ObjectType)(0), // 5: gitserver.v1.GitObject.ObjectType + (PerforceChangelist_PerforceChangelistState)(0), // 6: gitserver.v1.PerforceChangelist.PerforceChangelistState + (ChangedFile_Status)(0), // 7: gitserver.v1.ChangedFile.Status + (*ListRepositoriesRequest)(nil), // 8: gitserver.v1.ListRepositoriesRequest + (*ListRepositoriesResponse)(nil), // 9: gitserver.v1.ListRepositoriesResponse + (*DeleteRepositoryRequest)(nil), // 10: gitserver.v1.DeleteRepositoryRequest + (*DeleteRepositoryResponse)(nil), // 11: gitserver.v1.DeleteRepositoryResponse + (*FetchRepositoryRequest)(nil), // 12: gitserver.v1.FetchRepositoryRequest + (*FetchRepositoryResponse)(nil), // 13: gitserver.v1.FetchRepositoryResponse + (*CommitLogRequest)(nil), // 14: gitserver.v1.CommitLogRequest + (*CommitLogResponse)(nil), // 15: gitserver.v1.CommitLogResponse + (*ContributorCountsRequest)(nil), // 16: gitserver.v1.ContributorCountsRequest + (*ContributorCount)(nil), // 17: gitserver.v1.ContributorCount + (*ContributorCountsResponse)(nil), // 18: gitserver.v1.ContributorCountsResponse + (*RawDiffRequest)(nil), // 19: gitserver.v1.RawDiffRequest + (*RawDiffResponse)(nil), // 20: gitserver.v1.RawDiffResponse + (*ListRefsRequest)(nil), // 21: gitserver.v1.ListRefsRequest + (*ListRefsResponse)(nil), // 22: gitserver.v1.ListRefsResponse + (*GitRef)(nil), // 23: gitserver.v1.GitRef + (*StatRequest)(nil), // 24: gitserver.v1.StatRequest + (*StatResponse)(nil), // 25: gitserver.v1.StatResponse + (*ReadDirRequest)(nil), // 26: gitserver.v1.ReadDirRequest + (*ReadDirResponse)(nil), // 27: gitserver.v1.ReadDirResponse + (*GitSubmodule)(nil), // 28: gitserver.v1.GitSubmodule + (*FileInfo)(nil), // 29: gitserver.v1.FileInfo + (*ResolveRevisionRequest)(nil), // 30: gitserver.v1.ResolveRevisionRequest + (*ResolveRevisionResponse)(nil), // 31: gitserver.v1.ResolveRevisionResponse + (*RevAtTimeRequest)(nil), // 32: gitserver.v1.RevAtTimeRequest + (*RevAtTimeResponse)(nil), // 33: gitserver.v1.RevAtTimeResponse + (*GetCommitRequest)(nil), // 34: gitserver.v1.GetCommitRequest + (*GetCommitResponse)(nil), // 35: gitserver.v1.GetCommitResponse + (*GitCommit)(nil), // 36: gitserver.v1.GitCommit + (*GitSignature)(nil), // 37: gitserver.v1.GitSignature + (*BlameRequest)(nil), // 38: gitserver.v1.BlameRequest + (*BlameRange)(nil), // 39: gitserver.v1.BlameRange + (*BlameResponse)(nil), // 40: gitserver.v1.BlameResponse + (*BlameHunk)(nil), // 41: gitserver.v1.BlameHunk + (*BlameAuthor)(nil), // 42: gitserver.v1.BlameAuthor + (*PreviousCommit)(nil), // 43: gitserver.v1.PreviousCommit + (*DefaultBranchRequest)(nil), // 44: gitserver.v1.DefaultBranchRequest + (*DefaultBranchResponse)(nil), // 45: gitserver.v1.DefaultBranchResponse + (*ReadFileRequest)(nil), // 46: gitserver.v1.ReadFileRequest + (*ReadFileResponse)(nil), // 47: gitserver.v1.ReadFileResponse + (*DiskInfoRequest)(nil), // 48: gitserver.v1.DiskInfoRequest + (*DiskInfoResponse)(nil), // 49: gitserver.v1.DiskInfoResponse + (*PatchCommitInfo)(nil), // 50: gitserver.v1.PatchCommitInfo + (*PushConfig)(nil), // 51: gitserver.v1.PushConfig + (*CreateCommitFromPatchBinaryRequest)(nil), // 52: gitserver.v1.CreateCommitFromPatchBinaryRequest + (*CreateCommitFromPatchError)(nil), // 53: gitserver.v1.CreateCommitFromPatchError + (*CreateCommitFromPatchBinaryResponse)(nil), // 54: gitserver.v1.CreateCommitFromPatchBinaryResponse + (*ExecRequest)(nil), // 55: gitserver.v1.ExecRequest + (*ExecResponse)(nil), // 56: gitserver.v1.ExecResponse + (*RepoNotFoundPayload)(nil), // 57: gitserver.v1.RepoNotFoundPayload + (*RevisionNotFoundPayload)(nil), // 58: gitserver.v1.RevisionNotFoundPayload + (*FileNotFoundPayload)(nil), // 59: gitserver.v1.FileNotFoundPayload + (*ExecStatusPayload)(nil), // 60: gitserver.v1.ExecStatusPayload + (*SearchRequest)(nil), // 61: gitserver.v1.SearchRequest + (*RevisionSpecifier)(nil), // 62: gitserver.v1.RevisionSpecifier + (*AuthorMatchesNode)(nil), // 63: gitserver.v1.AuthorMatchesNode + (*CommitterMatchesNode)(nil), // 64: gitserver.v1.CommitterMatchesNode + (*CommitBeforeNode)(nil), // 65: gitserver.v1.CommitBeforeNode + (*CommitAfterNode)(nil), // 66: gitserver.v1.CommitAfterNode + (*MessageMatchesNode)(nil), // 67: gitserver.v1.MessageMatchesNode + (*DiffMatchesNode)(nil), // 68: gitserver.v1.DiffMatchesNode + (*DiffModifiesFileNode)(nil), // 69: gitserver.v1.DiffModifiesFileNode + (*BooleanNode)(nil), // 70: gitserver.v1.BooleanNode + (*OperatorNode)(nil), // 71: gitserver.v1.OperatorNode + (*QueryNode)(nil), // 72: gitserver.v1.QueryNode + (*SearchResponse)(nil), // 73: gitserver.v1.SearchResponse + (*CommitMatch)(nil), // 74: gitserver.v1.CommitMatch + (*ArchiveRequest)(nil), // 75: gitserver.v1.ArchiveRequest + (*ArchiveResponse)(nil), // 76: gitserver.v1.ArchiveResponse + (*IsRepoCloneableRequest)(nil), // 77: gitserver.v1.IsRepoCloneableRequest + (*IsRepoCloneableResponse)(nil), // 78: gitserver.v1.IsRepoCloneableResponse + (*RepoCloneProgressRequest)(nil), // 79: gitserver.v1.RepoCloneProgressRequest + (*RepoCloneProgressResponse)(nil), // 80: gitserver.v1.RepoCloneProgressResponse + (*ListGitoliteRequest)(nil), // 81: gitserver.v1.ListGitoliteRequest + (*GitoliteRepo)(nil), // 82: gitserver.v1.GitoliteRepo + (*ListGitoliteResponse)(nil), // 83: gitserver.v1.ListGitoliteResponse + (*GetObjectRequest)(nil), // 84: gitserver.v1.GetObjectRequest + (*GetObjectResponse)(nil), // 85: gitserver.v1.GetObjectResponse + (*GitObject)(nil), // 86: gitserver.v1.GitObject + (*IsPerforcePathCloneableRequest)(nil), // 87: gitserver.v1.IsPerforcePathCloneableRequest + (*IsPerforcePathCloneableResponse)(nil), // 88: gitserver.v1.IsPerforcePathCloneableResponse + (*CheckPerforceCredentialsRequest)(nil), // 89: gitserver.v1.CheckPerforceCredentialsRequest + (*CheckPerforceCredentialsResponse)(nil), // 90: gitserver.v1.CheckPerforceCredentialsResponse + (*PerforceConnectionDetails)(nil), // 91: gitserver.v1.PerforceConnectionDetails + (*PerforceGetChangelistRequest)(nil), // 92: gitserver.v1.PerforceGetChangelistRequest + (*PerforceGetChangelistResponse)(nil), // 93: gitserver.v1.PerforceGetChangelistResponse + (*PerforceChangelist)(nil), // 94: gitserver.v1.PerforceChangelist + (*IsPerforceSuperUserRequest)(nil), // 95: gitserver.v1.IsPerforceSuperUserRequest + (*IsPerforceSuperUserResponse)(nil), // 96: gitserver.v1.IsPerforceSuperUserResponse + (*PerforceProtectsForDepotRequest)(nil), // 97: gitserver.v1.PerforceProtectsForDepotRequest + (*PerforceProtectsForDepotResponse)(nil), // 98: gitserver.v1.PerforceProtectsForDepotResponse + (*PerforceProtectsForUserRequest)(nil), // 99: gitserver.v1.PerforceProtectsForUserRequest + (*PerforceProtectsForUserResponse)(nil), // 100: gitserver.v1.PerforceProtectsForUserResponse + (*PerforceProtect)(nil), // 101: gitserver.v1.PerforceProtect + (*PerforceGroupMembersRequest)(nil), // 102: gitserver.v1.PerforceGroupMembersRequest + (*PerforceGroupMembersResponse)(nil), // 103: gitserver.v1.PerforceGroupMembersResponse + (*PerforceUsersRequest)(nil), // 104: gitserver.v1.PerforceUsersRequest + (*PerforceUsersResponse)(nil), // 105: gitserver.v1.PerforceUsersResponse + (*PerforceUser)(nil), // 106: gitserver.v1.PerforceUser + (*MergeBaseRequest)(nil), // 107: gitserver.v1.MergeBaseRequest + (*MergeBaseResponse)(nil), // 108: gitserver.v1.MergeBaseResponse + (*FirstEverCommitRequest)(nil), // 109: gitserver.v1.FirstEverCommitRequest + (*FirstEverCommitResponse)(nil), // 110: gitserver.v1.FirstEverCommitResponse + (*BehindAheadRequest)(nil), // 111: gitserver.v1.BehindAheadRequest + (*BehindAheadResponse)(nil), // 112: gitserver.v1.BehindAheadResponse + (*ChangedFilesRequest)(nil), // 113: gitserver.v1.ChangedFilesRequest + (*ChangedFilesResponse)(nil), // 114: gitserver.v1.ChangedFilesResponse + (*ChangedFile)(nil), // 115: gitserver.v1.ChangedFile + (*ListRepositoriesResponse_GitRepository)(nil), // 116: gitserver.v1.ListRepositoriesResponse.GitRepository + (*CreateCommitFromPatchBinaryRequest_Metadata)(nil), // 117: gitserver.v1.CreateCommitFromPatchBinaryRequest.Metadata + (*CreateCommitFromPatchBinaryRequest_Patch)(nil), // 118: gitserver.v1.CreateCommitFromPatchBinaryRequest.Patch + (*CommitMatch_Signature)(nil), // 119: gitserver.v1.CommitMatch.Signature + (*CommitMatch_MatchedString)(nil), // 120: gitserver.v1.CommitMatch.MatchedString + (*CommitMatch_Range)(nil), // 121: gitserver.v1.CommitMatch.Range + (*CommitMatch_Location)(nil), // 122: gitserver.v1.CommitMatch.Location + (*timestamppb.Timestamp)(nil), // 123: google.protobuf.Timestamp } var file_gitserver_proto_depIdxs = []int32{ - 113, // 0: gitserver.v1.ListRepositoriesResponse.repositories:type_name -> gitserver.v1.ListRepositoriesResponse.GitRepository - 120, // 1: gitserver.v1.FetchRepositoryResponse.last_fetched:type_name -> google.protobuf.Timestamp - 120, // 2: gitserver.v1.FetchRepositoryResponse.last_changed:type_name -> google.protobuf.Timestamp - 120, // 3: gitserver.v1.ContributorCountsRequest.after:type_name -> google.protobuf.Timestamp - 34, // 4: gitserver.v1.ContributorCount.author:type_name -> gitserver.v1.GitSignature - 14, // 5: gitserver.v1.ContributorCountsResponse.counts:type_name -> gitserver.v1.ContributorCount - 2, // 6: gitserver.v1.RawDiffRequest.comparison_type:type_name -> gitserver.v1.RawDiffRequest.ComparisonType - 20, // 7: gitserver.v1.ListRefsResponse.refs:type_name -> gitserver.v1.GitRef - 120, // 8: gitserver.v1.GitRef.created_at:type_name -> google.protobuf.Timestamp - 3, // 9: gitserver.v1.GitRef.ref_type:type_name -> gitserver.v1.GitRef.RefType - 26, // 10: gitserver.v1.StatResponse.file_info:type_name -> gitserver.v1.FileInfo - 26, // 11: gitserver.v1.ReadDirResponse.file_info:type_name -> gitserver.v1.FileInfo - 25, // 12: gitserver.v1.FileInfo.submodule:type_name -> gitserver.v1.GitSubmodule - 120, // 13: gitserver.v1.RevAtTimeRequest.time:type_name -> google.protobuf.Timestamp - 33, // 14: gitserver.v1.GetCommitResponse.commit:type_name -> gitserver.v1.GitCommit - 34, // 15: gitserver.v1.GitCommit.author:type_name -> gitserver.v1.GitSignature - 34, // 16: gitserver.v1.GitCommit.committer:type_name -> gitserver.v1.GitSignature - 120, // 17: gitserver.v1.GitSignature.date:type_name -> google.protobuf.Timestamp - 36, // 18: gitserver.v1.BlameRequest.range:type_name -> gitserver.v1.BlameRange - 38, // 19: gitserver.v1.BlameResponse.hunk:type_name -> gitserver.v1.BlameHunk - 39, // 20: gitserver.v1.BlameHunk.author:type_name -> gitserver.v1.BlameAuthor - 40, // 21: gitserver.v1.BlameHunk.previous_commit:type_name -> gitserver.v1.PreviousCommit - 120, // 22: gitserver.v1.BlameAuthor.date:type_name -> google.protobuf.Timestamp - 120, // 23: gitserver.v1.PatchCommitInfo.date:type_name -> google.protobuf.Timestamp - 114, // 24: gitserver.v1.CreateCommitFromPatchBinaryRequest.metadata:type_name -> gitserver.v1.CreateCommitFromPatchBinaryRequest.Metadata - 115, // 25: gitserver.v1.CreateCommitFromPatchBinaryRequest.patch:type_name -> gitserver.v1.CreateCommitFromPatchBinaryRequest.Patch - 59, // 26: gitserver.v1.SearchRequest.revisions:type_name -> gitserver.v1.RevisionSpecifier - 69, // 27: gitserver.v1.SearchRequest.query:type_name -> gitserver.v1.QueryNode - 120, // 28: gitserver.v1.CommitBeforeNode.timestamp:type_name -> google.protobuf.Timestamp - 120, // 29: gitserver.v1.CommitAfterNode.timestamp:type_name -> google.protobuf.Timestamp - 0, // 30: gitserver.v1.OperatorNode.kind:type_name -> gitserver.v1.OperatorKind - 69, // 31: gitserver.v1.OperatorNode.operands:type_name -> gitserver.v1.QueryNode - 60, // 32: gitserver.v1.QueryNode.author_matches:type_name -> gitserver.v1.AuthorMatchesNode - 61, // 33: gitserver.v1.QueryNode.committer_matches:type_name -> gitserver.v1.CommitterMatchesNode - 62, // 34: gitserver.v1.QueryNode.commit_before:type_name -> gitserver.v1.CommitBeforeNode - 63, // 35: gitserver.v1.QueryNode.commit_after:type_name -> gitserver.v1.CommitAfterNode - 64, // 36: gitserver.v1.QueryNode.message_matches:type_name -> gitserver.v1.MessageMatchesNode - 65, // 37: gitserver.v1.QueryNode.diff_matches:type_name -> gitserver.v1.DiffMatchesNode - 66, // 38: gitserver.v1.QueryNode.diff_modifies_file:type_name -> gitserver.v1.DiffModifiesFileNode - 67, // 39: gitserver.v1.QueryNode.boolean:type_name -> gitserver.v1.BooleanNode - 68, // 40: gitserver.v1.QueryNode.operator:type_name -> gitserver.v1.OperatorNode - 71, // 41: gitserver.v1.SearchResponse.match:type_name -> gitserver.v1.CommitMatch - 116, // 42: gitserver.v1.CommitMatch.author:type_name -> gitserver.v1.CommitMatch.Signature - 116, // 43: gitserver.v1.CommitMatch.committer:type_name -> gitserver.v1.CommitMatch.Signature - 117, // 44: gitserver.v1.CommitMatch.message:type_name -> gitserver.v1.CommitMatch.MatchedString - 117, // 45: gitserver.v1.CommitMatch.diff:type_name -> gitserver.v1.CommitMatch.MatchedString - 1, // 46: gitserver.v1.ArchiveRequest.format:type_name -> gitserver.v1.ArchiveFormat - 79, // 47: gitserver.v1.ListGitoliteResponse.repos:type_name -> gitserver.v1.GitoliteRepo - 83, // 48: gitserver.v1.GetObjectResponse.object:type_name -> gitserver.v1.GitObject - 4, // 49: gitserver.v1.GitObject.type:type_name -> gitserver.v1.GitObject.ObjectType - 88, // 50: gitserver.v1.IsPerforcePathCloneableRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails - 88, // 51: gitserver.v1.CheckPerforceCredentialsRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails - 88, // 52: gitserver.v1.PerforceGetChangelistRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails - 91, // 53: gitserver.v1.PerforceGetChangelistResponse.changelist:type_name -> gitserver.v1.PerforceChangelist - 120, // 54: gitserver.v1.PerforceChangelist.creation_date:type_name -> google.protobuf.Timestamp - 5, // 55: gitserver.v1.PerforceChangelist.state:type_name -> gitserver.v1.PerforceChangelist.PerforceChangelistState - 88, // 56: gitserver.v1.IsPerforceSuperUserRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails - 88, // 57: gitserver.v1.PerforceProtectsForDepotRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails - 98, // 58: gitserver.v1.PerforceProtectsForDepotResponse.protects:type_name -> gitserver.v1.PerforceProtect - 88, // 59: gitserver.v1.PerforceProtectsForUserRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails - 98, // 60: gitserver.v1.PerforceProtectsForUserResponse.protects:type_name -> gitserver.v1.PerforceProtect - 88, // 61: gitserver.v1.PerforceGroupMembersRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails - 88, // 62: gitserver.v1.PerforceUsersRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails - 103, // 63: gitserver.v1.PerforceUsersResponse.users:type_name -> gitserver.v1.PerforceUser - 33, // 64: gitserver.v1.FirstEverCommitResponse.commit:type_name -> gitserver.v1.GitCommit - 112, // 65: gitserver.v1.ChangedFilesResponse.files:type_name -> gitserver.v1.ChangedFile - 6, // 66: gitserver.v1.ChangedFile.status:type_name -> gitserver.v1.ChangedFile.Status - 47, // 67: gitserver.v1.CreateCommitFromPatchBinaryRequest.Metadata.commit_info:type_name -> gitserver.v1.PatchCommitInfo - 48, // 68: gitserver.v1.CreateCommitFromPatchBinaryRequest.Metadata.push:type_name -> gitserver.v1.PushConfig - 120, // 69: gitserver.v1.CommitMatch.Signature.date:type_name -> google.protobuf.Timestamp - 118, // 70: gitserver.v1.CommitMatch.MatchedString.ranges:type_name -> gitserver.v1.CommitMatch.Range - 119, // 71: gitserver.v1.CommitMatch.Range.start:type_name -> gitserver.v1.CommitMatch.Location - 119, // 72: gitserver.v1.CommitMatch.Range.end:type_name -> gitserver.v1.CommitMatch.Location - 9, // 73: gitserver.v1.GitserverRepositoryService.DeleteRepository:input_type -> gitserver.v1.DeleteRepositoryRequest - 11, // 74: gitserver.v1.GitserverRepositoryService.FetchRepository:input_type -> gitserver.v1.FetchRepositoryRequest - 7, // 75: gitserver.v1.GitserverRepositoryService.ListRepositories:input_type -> gitserver.v1.ListRepositoriesRequest - 49, // 76: gitserver.v1.GitserverService.CreateCommitFromPatchBinary:input_type -> gitserver.v1.CreateCommitFromPatchBinaryRequest - 45, // 77: gitserver.v1.GitserverService.DiskInfo:input_type -> gitserver.v1.DiskInfoRequest - 52, // 78: gitserver.v1.GitserverService.Exec:input_type -> gitserver.v1.ExecRequest - 81, // 79: gitserver.v1.GitserverService.GetObject:input_type -> gitserver.v1.GetObjectRequest - 74, // 80: gitserver.v1.GitserverService.IsRepoCloneable:input_type -> gitserver.v1.IsRepoCloneableRequest - 78, // 81: gitserver.v1.GitserverService.ListGitolite:input_type -> gitserver.v1.ListGitoliteRequest - 58, // 82: gitserver.v1.GitserverService.Search:input_type -> gitserver.v1.SearchRequest - 72, // 83: gitserver.v1.GitserverService.Archive:input_type -> gitserver.v1.ArchiveRequest - 76, // 84: gitserver.v1.GitserverService.RepoCloneProgress:input_type -> gitserver.v1.RepoCloneProgressRequest - 84, // 85: gitserver.v1.GitserverService.IsPerforcePathCloneable:input_type -> gitserver.v1.IsPerforcePathCloneableRequest - 86, // 86: gitserver.v1.GitserverService.CheckPerforceCredentials:input_type -> gitserver.v1.CheckPerforceCredentialsRequest - 101, // 87: gitserver.v1.GitserverService.PerforceUsers:input_type -> gitserver.v1.PerforceUsersRequest - 96, // 88: gitserver.v1.GitserverService.PerforceProtectsForUser:input_type -> gitserver.v1.PerforceProtectsForUserRequest - 94, // 89: gitserver.v1.GitserverService.PerforceProtectsForDepot:input_type -> gitserver.v1.PerforceProtectsForDepotRequest - 99, // 90: gitserver.v1.GitserverService.PerforceGroupMembers:input_type -> gitserver.v1.PerforceGroupMembersRequest - 92, // 91: gitserver.v1.GitserverService.IsPerforceSuperUser:input_type -> gitserver.v1.IsPerforceSuperUserRequest - 89, // 92: gitserver.v1.GitserverService.PerforceGetChangelist:input_type -> gitserver.v1.PerforceGetChangelistRequest - 104, // 93: gitserver.v1.GitserverService.MergeBase:input_type -> gitserver.v1.MergeBaseRequest - 35, // 94: gitserver.v1.GitserverService.Blame:input_type -> gitserver.v1.BlameRequest - 41, // 95: gitserver.v1.GitserverService.DefaultBranch:input_type -> gitserver.v1.DefaultBranchRequest - 43, // 96: gitserver.v1.GitserverService.ReadFile:input_type -> gitserver.v1.ReadFileRequest - 31, // 97: gitserver.v1.GitserverService.GetCommit:input_type -> gitserver.v1.GetCommitRequest - 27, // 98: gitserver.v1.GitserverService.ResolveRevision:input_type -> gitserver.v1.ResolveRevisionRequest - 18, // 99: gitserver.v1.GitserverService.ListRefs:input_type -> gitserver.v1.ListRefsRequest - 29, // 100: gitserver.v1.GitserverService.RevAtTime:input_type -> gitserver.v1.RevAtTimeRequest - 16, // 101: gitserver.v1.GitserverService.RawDiff:input_type -> gitserver.v1.RawDiffRequest - 13, // 102: gitserver.v1.GitserverService.ContributorCounts:input_type -> gitserver.v1.ContributorCountsRequest - 106, // 103: gitserver.v1.GitserverService.FirstEverCommit:input_type -> gitserver.v1.FirstEverCommitRequest - 108, // 104: gitserver.v1.GitserverService.BehindAhead:input_type -> gitserver.v1.BehindAheadRequest - 110, // 105: gitserver.v1.GitserverService.ChangedFiles:input_type -> gitserver.v1.ChangedFilesRequest - 21, // 106: gitserver.v1.GitserverService.Stat:input_type -> gitserver.v1.StatRequest - 23, // 107: gitserver.v1.GitserverService.ReadDir:input_type -> gitserver.v1.ReadDirRequest - 10, // 108: gitserver.v1.GitserverRepositoryService.DeleteRepository:output_type -> gitserver.v1.DeleteRepositoryResponse - 12, // 109: gitserver.v1.GitserverRepositoryService.FetchRepository:output_type -> gitserver.v1.FetchRepositoryResponse - 8, // 110: gitserver.v1.GitserverRepositoryService.ListRepositories:output_type -> gitserver.v1.ListRepositoriesResponse - 51, // 111: gitserver.v1.GitserverService.CreateCommitFromPatchBinary:output_type -> gitserver.v1.CreateCommitFromPatchBinaryResponse - 46, // 112: gitserver.v1.GitserverService.DiskInfo:output_type -> gitserver.v1.DiskInfoResponse - 53, // 113: gitserver.v1.GitserverService.Exec:output_type -> gitserver.v1.ExecResponse - 82, // 114: gitserver.v1.GitserverService.GetObject:output_type -> gitserver.v1.GetObjectResponse - 75, // 115: gitserver.v1.GitserverService.IsRepoCloneable:output_type -> gitserver.v1.IsRepoCloneableResponse - 80, // 116: gitserver.v1.GitserverService.ListGitolite:output_type -> gitserver.v1.ListGitoliteResponse - 70, // 117: gitserver.v1.GitserverService.Search:output_type -> gitserver.v1.SearchResponse - 73, // 118: gitserver.v1.GitserverService.Archive:output_type -> gitserver.v1.ArchiveResponse - 77, // 119: gitserver.v1.GitserverService.RepoCloneProgress:output_type -> gitserver.v1.RepoCloneProgressResponse - 85, // 120: gitserver.v1.GitserverService.IsPerforcePathCloneable:output_type -> gitserver.v1.IsPerforcePathCloneableResponse - 87, // 121: gitserver.v1.GitserverService.CheckPerforceCredentials:output_type -> gitserver.v1.CheckPerforceCredentialsResponse - 102, // 122: gitserver.v1.GitserverService.PerforceUsers:output_type -> gitserver.v1.PerforceUsersResponse - 97, // 123: gitserver.v1.GitserverService.PerforceProtectsForUser:output_type -> gitserver.v1.PerforceProtectsForUserResponse - 95, // 124: gitserver.v1.GitserverService.PerforceProtectsForDepot:output_type -> gitserver.v1.PerforceProtectsForDepotResponse - 100, // 125: gitserver.v1.GitserverService.PerforceGroupMembers:output_type -> gitserver.v1.PerforceGroupMembersResponse - 93, // 126: gitserver.v1.GitserverService.IsPerforceSuperUser:output_type -> gitserver.v1.IsPerforceSuperUserResponse - 90, // 127: gitserver.v1.GitserverService.PerforceGetChangelist:output_type -> gitserver.v1.PerforceGetChangelistResponse - 105, // 128: gitserver.v1.GitserverService.MergeBase:output_type -> gitserver.v1.MergeBaseResponse - 37, // 129: gitserver.v1.GitserverService.Blame:output_type -> gitserver.v1.BlameResponse - 42, // 130: gitserver.v1.GitserverService.DefaultBranch:output_type -> gitserver.v1.DefaultBranchResponse - 44, // 131: gitserver.v1.GitserverService.ReadFile:output_type -> gitserver.v1.ReadFileResponse - 32, // 132: gitserver.v1.GitserverService.GetCommit:output_type -> gitserver.v1.GetCommitResponse - 28, // 133: gitserver.v1.GitserverService.ResolveRevision:output_type -> gitserver.v1.ResolveRevisionResponse - 19, // 134: gitserver.v1.GitserverService.ListRefs:output_type -> gitserver.v1.ListRefsResponse - 30, // 135: gitserver.v1.GitserverService.RevAtTime:output_type -> gitserver.v1.RevAtTimeResponse - 17, // 136: gitserver.v1.GitserverService.RawDiff:output_type -> gitserver.v1.RawDiffResponse - 15, // 137: gitserver.v1.GitserverService.ContributorCounts:output_type -> gitserver.v1.ContributorCountsResponse - 107, // 138: gitserver.v1.GitserverService.FirstEverCommit:output_type -> gitserver.v1.FirstEverCommitResponse - 109, // 139: gitserver.v1.GitserverService.BehindAhead:output_type -> gitserver.v1.BehindAheadResponse - 111, // 140: gitserver.v1.GitserverService.ChangedFiles:output_type -> gitserver.v1.ChangedFilesResponse - 22, // 141: gitserver.v1.GitserverService.Stat:output_type -> gitserver.v1.StatResponse - 24, // 142: gitserver.v1.GitserverService.ReadDir:output_type -> gitserver.v1.ReadDirResponse - 108, // [108:143] is the sub-list for method output_type - 73, // [73:108] is the sub-list for method input_type - 73, // [73:73] is the sub-list for extension type_name - 73, // [73:73] is the sub-list for extension extendee - 0, // [0:73] is the sub-list for field type_name + 116, // 0: gitserver.v1.ListRepositoriesResponse.repositories:type_name -> gitserver.v1.ListRepositoriesResponse.GitRepository + 123, // 1: gitserver.v1.FetchRepositoryResponse.last_fetched:type_name -> google.protobuf.Timestamp + 123, // 2: gitserver.v1.FetchRepositoryResponse.last_changed:type_name -> google.protobuf.Timestamp + 123, // 3: gitserver.v1.CommitLogRequest.after:type_name -> google.protobuf.Timestamp + 123, // 4: gitserver.v1.CommitLogRequest.before:type_name -> google.protobuf.Timestamp + 2, // 5: gitserver.v1.CommitLogRequest.order:type_name -> gitserver.v1.CommitLogRequest.CommitLogOrder + 35, // 6: gitserver.v1.CommitLogResponse.commits:type_name -> gitserver.v1.GetCommitResponse + 123, // 7: gitserver.v1.ContributorCountsRequest.after:type_name -> google.protobuf.Timestamp + 37, // 8: gitserver.v1.ContributorCount.author:type_name -> gitserver.v1.GitSignature + 17, // 9: gitserver.v1.ContributorCountsResponse.counts:type_name -> gitserver.v1.ContributorCount + 3, // 10: gitserver.v1.RawDiffRequest.comparison_type:type_name -> gitserver.v1.RawDiffRequest.ComparisonType + 23, // 11: gitserver.v1.ListRefsResponse.refs:type_name -> gitserver.v1.GitRef + 123, // 12: gitserver.v1.GitRef.created_at:type_name -> google.protobuf.Timestamp + 4, // 13: gitserver.v1.GitRef.ref_type:type_name -> gitserver.v1.GitRef.RefType + 29, // 14: gitserver.v1.StatResponse.file_info:type_name -> gitserver.v1.FileInfo + 29, // 15: gitserver.v1.ReadDirResponse.file_info:type_name -> gitserver.v1.FileInfo + 28, // 16: gitserver.v1.FileInfo.submodule:type_name -> gitserver.v1.GitSubmodule + 123, // 17: gitserver.v1.RevAtTimeRequest.time:type_name -> google.protobuf.Timestamp + 36, // 18: gitserver.v1.GetCommitResponse.commit:type_name -> gitserver.v1.GitCommit + 37, // 19: gitserver.v1.GitCommit.author:type_name -> gitserver.v1.GitSignature + 37, // 20: gitserver.v1.GitCommit.committer:type_name -> gitserver.v1.GitSignature + 123, // 21: gitserver.v1.GitSignature.date:type_name -> google.protobuf.Timestamp + 39, // 22: gitserver.v1.BlameRequest.range:type_name -> gitserver.v1.BlameRange + 41, // 23: gitserver.v1.BlameResponse.hunk:type_name -> gitserver.v1.BlameHunk + 42, // 24: gitserver.v1.BlameHunk.author:type_name -> gitserver.v1.BlameAuthor + 43, // 25: gitserver.v1.BlameHunk.previous_commit:type_name -> gitserver.v1.PreviousCommit + 123, // 26: gitserver.v1.BlameAuthor.date:type_name -> google.protobuf.Timestamp + 123, // 27: gitserver.v1.PatchCommitInfo.date:type_name -> google.protobuf.Timestamp + 117, // 28: gitserver.v1.CreateCommitFromPatchBinaryRequest.metadata:type_name -> gitserver.v1.CreateCommitFromPatchBinaryRequest.Metadata + 118, // 29: gitserver.v1.CreateCommitFromPatchBinaryRequest.patch:type_name -> gitserver.v1.CreateCommitFromPatchBinaryRequest.Patch + 62, // 30: gitserver.v1.SearchRequest.revisions:type_name -> gitserver.v1.RevisionSpecifier + 72, // 31: gitserver.v1.SearchRequest.query:type_name -> gitserver.v1.QueryNode + 123, // 32: gitserver.v1.CommitBeforeNode.timestamp:type_name -> google.protobuf.Timestamp + 123, // 33: gitserver.v1.CommitAfterNode.timestamp:type_name -> google.protobuf.Timestamp + 0, // 34: gitserver.v1.OperatorNode.kind:type_name -> gitserver.v1.OperatorKind + 72, // 35: gitserver.v1.OperatorNode.operands:type_name -> gitserver.v1.QueryNode + 63, // 36: gitserver.v1.QueryNode.author_matches:type_name -> gitserver.v1.AuthorMatchesNode + 64, // 37: gitserver.v1.QueryNode.committer_matches:type_name -> gitserver.v1.CommitterMatchesNode + 65, // 38: gitserver.v1.QueryNode.commit_before:type_name -> gitserver.v1.CommitBeforeNode + 66, // 39: gitserver.v1.QueryNode.commit_after:type_name -> gitserver.v1.CommitAfterNode + 67, // 40: gitserver.v1.QueryNode.message_matches:type_name -> gitserver.v1.MessageMatchesNode + 68, // 41: gitserver.v1.QueryNode.diff_matches:type_name -> gitserver.v1.DiffMatchesNode + 69, // 42: gitserver.v1.QueryNode.diff_modifies_file:type_name -> gitserver.v1.DiffModifiesFileNode + 70, // 43: gitserver.v1.QueryNode.boolean:type_name -> gitserver.v1.BooleanNode + 71, // 44: gitserver.v1.QueryNode.operator:type_name -> gitserver.v1.OperatorNode + 74, // 45: gitserver.v1.SearchResponse.match:type_name -> gitserver.v1.CommitMatch + 119, // 46: gitserver.v1.CommitMatch.author:type_name -> gitserver.v1.CommitMatch.Signature + 119, // 47: gitserver.v1.CommitMatch.committer:type_name -> gitserver.v1.CommitMatch.Signature + 120, // 48: gitserver.v1.CommitMatch.message:type_name -> gitserver.v1.CommitMatch.MatchedString + 120, // 49: gitserver.v1.CommitMatch.diff:type_name -> gitserver.v1.CommitMatch.MatchedString + 1, // 50: gitserver.v1.ArchiveRequest.format:type_name -> gitserver.v1.ArchiveFormat + 82, // 51: gitserver.v1.ListGitoliteResponse.repos:type_name -> gitserver.v1.GitoliteRepo + 86, // 52: gitserver.v1.GetObjectResponse.object:type_name -> gitserver.v1.GitObject + 5, // 53: gitserver.v1.GitObject.type:type_name -> gitserver.v1.GitObject.ObjectType + 91, // 54: gitserver.v1.IsPerforcePathCloneableRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails + 91, // 55: gitserver.v1.CheckPerforceCredentialsRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails + 91, // 56: gitserver.v1.PerforceGetChangelistRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails + 94, // 57: gitserver.v1.PerforceGetChangelistResponse.changelist:type_name -> gitserver.v1.PerforceChangelist + 123, // 58: gitserver.v1.PerforceChangelist.creation_date:type_name -> google.protobuf.Timestamp + 6, // 59: gitserver.v1.PerforceChangelist.state:type_name -> gitserver.v1.PerforceChangelist.PerforceChangelistState + 91, // 60: gitserver.v1.IsPerforceSuperUserRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails + 91, // 61: gitserver.v1.PerforceProtectsForDepotRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails + 101, // 62: gitserver.v1.PerforceProtectsForDepotResponse.protects:type_name -> gitserver.v1.PerforceProtect + 91, // 63: gitserver.v1.PerforceProtectsForUserRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails + 101, // 64: gitserver.v1.PerforceProtectsForUserResponse.protects:type_name -> gitserver.v1.PerforceProtect + 91, // 65: gitserver.v1.PerforceGroupMembersRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails + 91, // 66: gitserver.v1.PerforceUsersRequest.connection_details:type_name -> gitserver.v1.PerforceConnectionDetails + 106, // 67: gitserver.v1.PerforceUsersResponse.users:type_name -> gitserver.v1.PerforceUser + 36, // 68: gitserver.v1.FirstEverCommitResponse.commit:type_name -> gitserver.v1.GitCommit + 115, // 69: gitserver.v1.ChangedFilesResponse.files:type_name -> gitserver.v1.ChangedFile + 7, // 70: gitserver.v1.ChangedFile.status:type_name -> gitserver.v1.ChangedFile.Status + 50, // 71: gitserver.v1.CreateCommitFromPatchBinaryRequest.Metadata.commit_info:type_name -> gitserver.v1.PatchCommitInfo + 51, // 72: gitserver.v1.CreateCommitFromPatchBinaryRequest.Metadata.push:type_name -> gitserver.v1.PushConfig + 123, // 73: gitserver.v1.CommitMatch.Signature.date:type_name -> google.protobuf.Timestamp + 121, // 74: gitserver.v1.CommitMatch.MatchedString.ranges:type_name -> gitserver.v1.CommitMatch.Range + 122, // 75: gitserver.v1.CommitMatch.Range.start:type_name -> gitserver.v1.CommitMatch.Location + 122, // 76: gitserver.v1.CommitMatch.Range.end:type_name -> gitserver.v1.CommitMatch.Location + 10, // 77: gitserver.v1.GitserverRepositoryService.DeleteRepository:input_type -> gitserver.v1.DeleteRepositoryRequest + 12, // 78: gitserver.v1.GitserverRepositoryService.FetchRepository:input_type -> gitserver.v1.FetchRepositoryRequest + 8, // 79: gitserver.v1.GitserverRepositoryService.ListRepositories:input_type -> gitserver.v1.ListRepositoriesRequest + 52, // 80: gitserver.v1.GitserverService.CreateCommitFromPatchBinary:input_type -> gitserver.v1.CreateCommitFromPatchBinaryRequest + 48, // 81: gitserver.v1.GitserverService.DiskInfo:input_type -> gitserver.v1.DiskInfoRequest + 55, // 82: gitserver.v1.GitserverService.Exec:input_type -> gitserver.v1.ExecRequest + 84, // 83: gitserver.v1.GitserverService.GetObject:input_type -> gitserver.v1.GetObjectRequest + 77, // 84: gitserver.v1.GitserverService.IsRepoCloneable:input_type -> gitserver.v1.IsRepoCloneableRequest + 81, // 85: gitserver.v1.GitserverService.ListGitolite:input_type -> gitserver.v1.ListGitoliteRequest + 61, // 86: gitserver.v1.GitserverService.Search:input_type -> gitserver.v1.SearchRequest + 75, // 87: gitserver.v1.GitserverService.Archive:input_type -> gitserver.v1.ArchiveRequest + 79, // 88: gitserver.v1.GitserverService.RepoCloneProgress:input_type -> gitserver.v1.RepoCloneProgressRequest + 87, // 89: gitserver.v1.GitserverService.IsPerforcePathCloneable:input_type -> gitserver.v1.IsPerforcePathCloneableRequest + 89, // 90: gitserver.v1.GitserverService.CheckPerforceCredentials:input_type -> gitserver.v1.CheckPerforceCredentialsRequest + 104, // 91: gitserver.v1.GitserverService.PerforceUsers:input_type -> gitserver.v1.PerforceUsersRequest + 99, // 92: gitserver.v1.GitserverService.PerforceProtectsForUser:input_type -> gitserver.v1.PerforceProtectsForUserRequest + 97, // 93: gitserver.v1.GitserverService.PerforceProtectsForDepot:input_type -> gitserver.v1.PerforceProtectsForDepotRequest + 102, // 94: gitserver.v1.GitserverService.PerforceGroupMembers:input_type -> gitserver.v1.PerforceGroupMembersRequest + 95, // 95: gitserver.v1.GitserverService.IsPerforceSuperUser:input_type -> gitserver.v1.IsPerforceSuperUserRequest + 92, // 96: gitserver.v1.GitserverService.PerforceGetChangelist:input_type -> gitserver.v1.PerforceGetChangelistRequest + 107, // 97: gitserver.v1.GitserverService.MergeBase:input_type -> gitserver.v1.MergeBaseRequest + 38, // 98: gitserver.v1.GitserverService.Blame:input_type -> gitserver.v1.BlameRequest + 44, // 99: gitserver.v1.GitserverService.DefaultBranch:input_type -> gitserver.v1.DefaultBranchRequest + 46, // 100: gitserver.v1.GitserverService.ReadFile:input_type -> gitserver.v1.ReadFileRequest + 34, // 101: gitserver.v1.GitserverService.GetCommit:input_type -> gitserver.v1.GetCommitRequest + 30, // 102: gitserver.v1.GitserverService.ResolveRevision:input_type -> gitserver.v1.ResolveRevisionRequest + 21, // 103: gitserver.v1.GitserverService.ListRefs:input_type -> gitserver.v1.ListRefsRequest + 32, // 104: gitserver.v1.GitserverService.RevAtTime:input_type -> gitserver.v1.RevAtTimeRequest + 19, // 105: gitserver.v1.GitserverService.RawDiff:input_type -> gitserver.v1.RawDiffRequest + 16, // 106: gitserver.v1.GitserverService.ContributorCounts:input_type -> gitserver.v1.ContributorCountsRequest + 109, // 107: gitserver.v1.GitserverService.FirstEverCommit:input_type -> gitserver.v1.FirstEverCommitRequest + 111, // 108: gitserver.v1.GitserverService.BehindAhead:input_type -> gitserver.v1.BehindAheadRequest + 113, // 109: gitserver.v1.GitserverService.ChangedFiles:input_type -> gitserver.v1.ChangedFilesRequest + 24, // 110: gitserver.v1.GitserverService.Stat:input_type -> gitserver.v1.StatRequest + 26, // 111: gitserver.v1.GitserverService.ReadDir:input_type -> gitserver.v1.ReadDirRequest + 14, // 112: gitserver.v1.GitserverService.CommitLog:input_type -> gitserver.v1.CommitLogRequest + 11, // 113: gitserver.v1.GitserverRepositoryService.DeleteRepository:output_type -> gitserver.v1.DeleteRepositoryResponse + 13, // 114: gitserver.v1.GitserverRepositoryService.FetchRepository:output_type -> gitserver.v1.FetchRepositoryResponse + 9, // 115: gitserver.v1.GitserverRepositoryService.ListRepositories:output_type -> gitserver.v1.ListRepositoriesResponse + 54, // 116: gitserver.v1.GitserverService.CreateCommitFromPatchBinary:output_type -> gitserver.v1.CreateCommitFromPatchBinaryResponse + 49, // 117: gitserver.v1.GitserverService.DiskInfo:output_type -> gitserver.v1.DiskInfoResponse + 56, // 118: gitserver.v1.GitserverService.Exec:output_type -> gitserver.v1.ExecResponse + 85, // 119: gitserver.v1.GitserverService.GetObject:output_type -> gitserver.v1.GetObjectResponse + 78, // 120: gitserver.v1.GitserverService.IsRepoCloneable:output_type -> gitserver.v1.IsRepoCloneableResponse + 83, // 121: gitserver.v1.GitserverService.ListGitolite:output_type -> gitserver.v1.ListGitoliteResponse + 73, // 122: gitserver.v1.GitserverService.Search:output_type -> gitserver.v1.SearchResponse + 76, // 123: gitserver.v1.GitserverService.Archive:output_type -> gitserver.v1.ArchiveResponse + 80, // 124: gitserver.v1.GitserverService.RepoCloneProgress:output_type -> gitserver.v1.RepoCloneProgressResponse + 88, // 125: gitserver.v1.GitserverService.IsPerforcePathCloneable:output_type -> gitserver.v1.IsPerforcePathCloneableResponse + 90, // 126: gitserver.v1.GitserverService.CheckPerforceCredentials:output_type -> gitserver.v1.CheckPerforceCredentialsResponse + 105, // 127: gitserver.v1.GitserverService.PerforceUsers:output_type -> gitserver.v1.PerforceUsersResponse + 100, // 128: gitserver.v1.GitserverService.PerforceProtectsForUser:output_type -> gitserver.v1.PerforceProtectsForUserResponse + 98, // 129: gitserver.v1.GitserverService.PerforceProtectsForDepot:output_type -> gitserver.v1.PerforceProtectsForDepotResponse + 103, // 130: gitserver.v1.GitserverService.PerforceGroupMembers:output_type -> gitserver.v1.PerforceGroupMembersResponse + 96, // 131: gitserver.v1.GitserverService.IsPerforceSuperUser:output_type -> gitserver.v1.IsPerforceSuperUserResponse + 93, // 132: gitserver.v1.GitserverService.PerforceGetChangelist:output_type -> gitserver.v1.PerforceGetChangelistResponse + 108, // 133: gitserver.v1.GitserverService.MergeBase:output_type -> gitserver.v1.MergeBaseResponse + 40, // 134: gitserver.v1.GitserverService.Blame:output_type -> gitserver.v1.BlameResponse + 45, // 135: gitserver.v1.GitserverService.DefaultBranch:output_type -> gitserver.v1.DefaultBranchResponse + 47, // 136: gitserver.v1.GitserverService.ReadFile:output_type -> gitserver.v1.ReadFileResponse + 35, // 137: gitserver.v1.GitserverService.GetCommit:output_type -> gitserver.v1.GetCommitResponse + 31, // 138: gitserver.v1.GitserverService.ResolveRevision:output_type -> gitserver.v1.ResolveRevisionResponse + 22, // 139: gitserver.v1.GitserverService.ListRefs:output_type -> gitserver.v1.ListRefsResponse + 33, // 140: gitserver.v1.GitserverService.RevAtTime:output_type -> gitserver.v1.RevAtTimeResponse + 20, // 141: gitserver.v1.GitserverService.RawDiff:output_type -> gitserver.v1.RawDiffResponse + 18, // 142: gitserver.v1.GitserverService.ContributorCounts:output_type -> gitserver.v1.ContributorCountsResponse + 110, // 143: gitserver.v1.GitserverService.FirstEverCommit:output_type -> gitserver.v1.FirstEverCommitResponse + 112, // 144: gitserver.v1.GitserverService.BehindAhead:output_type -> gitserver.v1.BehindAheadResponse + 114, // 145: gitserver.v1.GitserverService.ChangedFiles:output_type -> gitserver.v1.ChangedFilesResponse + 25, // 146: gitserver.v1.GitserverService.Stat:output_type -> gitserver.v1.StatResponse + 27, // 147: gitserver.v1.GitserverService.ReadDir:output_type -> gitserver.v1.ReadDirResponse + 15, // 148: gitserver.v1.GitserverService.CommitLog:output_type -> gitserver.v1.CommitLogResponse + 113, // [113:149] is the sub-list for method output_type + 77, // [77:113] is the sub-list for method input_type + 77, // [77:77] is the sub-list for extension type_name + 77, // [77:77] is the sub-list for extension extendee + 0, // [0:77] is the sub-list for field type_name } func init() { file_gitserver_proto_init() } @@ -8867,7 +9212,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ContributorCountsRequest); i { + switch v := v.(*CommitLogRequest); i { case 0: return &v.state case 1: @@ -8879,7 +9224,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ContributorCount); i { + switch v := v.(*CommitLogResponse); i { case 0: return &v.state case 1: @@ -8891,7 +9236,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ContributorCountsResponse); i { + switch v := v.(*ContributorCountsRequest); i { case 0: return &v.state case 1: @@ -8903,7 +9248,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*RawDiffRequest); i { + switch v := v.(*ContributorCount); i { case 0: return &v.state case 1: @@ -8915,7 +9260,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*RawDiffResponse); i { + switch v := v.(*ContributorCountsResponse); i { case 0: return &v.state case 1: @@ -8927,7 +9272,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListRefsRequest); i { + switch v := v.(*RawDiffRequest); i { case 0: return &v.state case 1: @@ -8939,7 +9284,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListRefsResponse); i { + switch v := v.(*RawDiffResponse); i { case 0: return &v.state case 1: @@ -8951,7 +9296,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GitRef); i { + switch v := v.(*ListRefsRequest); i { case 0: return &v.state case 1: @@ -8963,7 +9308,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*StatRequest); i { + switch v := v.(*ListRefsResponse); i { case 0: return &v.state case 1: @@ -8975,7 +9320,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*StatResponse); i { + switch v := v.(*GitRef); i { case 0: return &v.state case 1: @@ -8987,7 +9332,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ReadDirRequest); i { + switch v := v.(*StatRequest); i { case 0: return &v.state case 1: @@ -8999,7 +9344,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ReadDirResponse); i { + switch v := v.(*StatResponse); i { case 0: return &v.state case 1: @@ -9011,7 +9356,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GitSubmodule); i { + switch v := v.(*ReadDirRequest); i { case 0: return &v.state case 1: @@ -9023,7 +9368,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*FileInfo); i { + switch v := v.(*ReadDirResponse); i { case 0: return &v.state case 1: @@ -9035,7 +9380,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ResolveRevisionRequest); i { + switch v := v.(*GitSubmodule); i { case 0: return &v.state case 1: @@ -9047,7 +9392,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ResolveRevisionResponse); i { + switch v := v.(*FileInfo); i { case 0: return &v.state case 1: @@ -9059,7 +9404,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*RevAtTimeRequest); i { + switch v := v.(*ResolveRevisionRequest); i { case 0: return &v.state case 1: @@ -9071,7 +9416,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*RevAtTimeResponse); i { + switch v := v.(*ResolveRevisionResponse); i { case 0: return &v.state case 1: @@ -9083,7 +9428,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetCommitRequest); i { + switch v := v.(*RevAtTimeRequest); i { case 0: return &v.state case 1: @@ -9095,7 +9440,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetCommitResponse); i { + switch v := v.(*RevAtTimeResponse); i { case 0: return &v.state case 1: @@ -9107,7 +9452,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GitCommit); i { + switch v := v.(*GetCommitRequest); i { case 0: return &v.state case 1: @@ -9119,7 +9464,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GitSignature); i { + switch v := v.(*GetCommitResponse); i { case 0: return &v.state case 1: @@ -9131,7 +9476,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*BlameRequest); i { + switch v := v.(*GitCommit); i { case 0: return &v.state case 1: @@ -9143,7 +9488,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*BlameRange); i { + switch v := v.(*GitSignature); i { case 0: return &v.state case 1: @@ -9155,7 +9500,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*BlameResponse); i { + switch v := v.(*BlameRequest); i { case 0: return &v.state case 1: @@ -9167,7 +9512,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*BlameHunk); i { + switch v := v.(*BlameRange); i { case 0: return &v.state case 1: @@ -9179,7 +9524,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*BlameAuthor); i { + switch v := v.(*BlameResponse); i { case 0: return &v.state case 1: @@ -9191,7 +9536,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PreviousCommit); i { + switch v := v.(*BlameHunk); i { case 0: return &v.state case 1: @@ -9203,7 +9548,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DefaultBranchRequest); i { + switch v := v.(*BlameAuthor); i { case 0: return &v.state case 1: @@ -9215,7 +9560,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DefaultBranchResponse); i { + switch v := v.(*PreviousCommit); i { case 0: return &v.state case 1: @@ -9227,7 +9572,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ReadFileRequest); i { + switch v := v.(*DefaultBranchRequest); i { case 0: return &v.state case 1: @@ -9239,7 +9584,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ReadFileResponse); i { + switch v := v.(*DefaultBranchResponse); i { case 0: return &v.state case 1: @@ -9251,7 +9596,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DiskInfoRequest); i { + switch v := v.(*ReadFileRequest); i { case 0: return &v.state case 1: @@ -9263,7 +9608,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DiskInfoResponse); i { + switch v := v.(*ReadFileResponse); i { case 0: return &v.state case 1: @@ -9275,7 +9620,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PatchCommitInfo); i { + switch v := v.(*DiskInfoRequest); i { case 0: return &v.state case 1: @@ -9287,7 +9632,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PushConfig); i { + switch v := v.(*DiskInfoResponse); i { case 0: return &v.state case 1: @@ -9299,7 +9644,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CreateCommitFromPatchBinaryRequest); i { + switch v := v.(*PatchCommitInfo); i { case 0: return &v.state case 1: @@ -9311,7 +9656,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CreateCommitFromPatchError); i { + switch v := v.(*PushConfig); i { case 0: return &v.state case 1: @@ -9323,7 +9668,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CreateCommitFromPatchBinaryResponse); i { + switch v := v.(*CreateCommitFromPatchBinaryRequest); i { case 0: return &v.state case 1: @@ -9335,7 +9680,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ExecRequest); i { + switch v := v.(*CreateCommitFromPatchError); i { case 0: return &v.state case 1: @@ -9347,7 +9692,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ExecResponse); i { + switch v := v.(*CreateCommitFromPatchBinaryResponse); i { case 0: return &v.state case 1: @@ -9359,7 +9704,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*RepoNotFoundPayload); i { + switch v := v.(*ExecRequest); i { case 0: return &v.state case 1: @@ -9371,7 +9716,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*RevisionNotFoundPayload); i { + switch v := v.(*ExecResponse); i { case 0: return &v.state case 1: @@ -9383,7 +9728,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*FileNotFoundPayload); i { + switch v := v.(*RepoNotFoundPayload); i { case 0: return &v.state case 1: @@ -9395,7 +9740,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ExecStatusPayload); i { + switch v := v.(*RevisionNotFoundPayload); i { case 0: return &v.state case 1: @@ -9407,7 +9752,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SearchRequest); i { + switch v := v.(*FileNotFoundPayload); i { case 0: return &v.state case 1: @@ -9419,7 +9764,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*RevisionSpecifier); i { + switch v := v.(*ExecStatusPayload); i { case 0: return &v.state case 1: @@ -9431,7 +9776,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AuthorMatchesNode); i { + switch v := v.(*SearchRequest); i { case 0: return &v.state case 1: @@ -9443,7 +9788,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CommitterMatchesNode); i { + switch v := v.(*RevisionSpecifier); i { case 0: return &v.state case 1: @@ -9455,7 +9800,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CommitBeforeNode); i { + switch v := v.(*AuthorMatchesNode); i { case 0: return &v.state case 1: @@ -9467,7 +9812,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CommitAfterNode); i { + switch v := v.(*CommitterMatchesNode); i { case 0: return &v.state case 1: @@ -9479,7 +9824,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*MessageMatchesNode); i { + switch v := v.(*CommitBeforeNode); i { case 0: return &v.state case 1: @@ -9491,7 +9836,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DiffMatchesNode); i { + switch v := v.(*CommitAfterNode); i { case 0: return &v.state case 1: @@ -9503,7 +9848,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DiffModifiesFileNode); i { + switch v := v.(*MessageMatchesNode); i { case 0: return &v.state case 1: @@ -9515,7 +9860,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*BooleanNode); i { + switch v := v.(*DiffMatchesNode); i { case 0: return &v.state case 1: @@ -9527,7 +9872,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*OperatorNode); i { + switch v := v.(*DiffModifiesFileNode); i { case 0: return &v.state case 1: @@ -9539,7 +9884,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryNode); i { + switch v := v.(*BooleanNode); i { case 0: return &v.state case 1: @@ -9551,7 +9896,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SearchResponse); i { + switch v := v.(*OperatorNode); i { case 0: return &v.state case 1: @@ -9563,7 +9908,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CommitMatch); i { + switch v := v.(*QueryNode); i { case 0: return &v.state case 1: @@ -9575,7 +9920,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ArchiveRequest); i { + switch v := v.(*SearchResponse); i { case 0: return &v.state case 1: @@ -9587,7 +9932,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ArchiveResponse); i { + switch v := v.(*CommitMatch); i { case 0: return &v.state case 1: @@ -9599,7 +9944,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*IsRepoCloneableRequest); i { + switch v := v.(*ArchiveRequest); i { case 0: return &v.state case 1: @@ -9611,7 +9956,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*IsRepoCloneableResponse); i { + switch v := v.(*ArchiveResponse); i { case 0: return &v.state case 1: @@ -9623,7 +9968,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*RepoCloneProgressRequest); i { + switch v := v.(*IsRepoCloneableRequest); i { case 0: return &v.state case 1: @@ -9635,7 +9980,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[70].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*RepoCloneProgressResponse); i { + switch v := v.(*IsRepoCloneableResponse); i { case 0: return &v.state case 1: @@ -9647,7 +9992,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[71].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListGitoliteRequest); i { + switch v := v.(*RepoCloneProgressRequest); i { case 0: return &v.state case 1: @@ -9659,7 +10004,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[72].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GitoliteRepo); i { + switch v := v.(*RepoCloneProgressResponse); i { case 0: return &v.state case 1: @@ -9671,7 +10016,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[73].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListGitoliteResponse); i { + switch v := v.(*ListGitoliteRequest); i { case 0: return &v.state case 1: @@ -9683,7 +10028,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[74].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetObjectRequest); i { + switch v := v.(*GitoliteRepo); i { case 0: return &v.state case 1: @@ -9695,7 +10040,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[75].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetObjectResponse); i { + switch v := v.(*ListGitoliteResponse); i { case 0: return &v.state case 1: @@ -9707,7 +10052,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[76].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GitObject); i { + switch v := v.(*GetObjectRequest); i { case 0: return &v.state case 1: @@ -9719,7 +10064,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[77].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*IsPerforcePathCloneableRequest); i { + switch v := v.(*GetObjectResponse); i { case 0: return &v.state case 1: @@ -9731,7 +10076,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[78].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*IsPerforcePathCloneableResponse); i { + switch v := v.(*GitObject); i { case 0: return &v.state case 1: @@ -9743,7 +10088,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[79].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CheckPerforceCredentialsRequest); i { + switch v := v.(*IsPerforcePathCloneableRequest); i { case 0: return &v.state case 1: @@ -9755,7 +10100,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[80].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CheckPerforceCredentialsResponse); i { + switch v := v.(*IsPerforcePathCloneableResponse); i { case 0: return &v.state case 1: @@ -9767,7 +10112,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[81].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PerforceConnectionDetails); i { + switch v := v.(*CheckPerforceCredentialsRequest); i { case 0: return &v.state case 1: @@ -9779,7 +10124,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[82].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PerforceGetChangelistRequest); i { + switch v := v.(*CheckPerforceCredentialsResponse); i { case 0: return &v.state case 1: @@ -9791,7 +10136,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[83].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PerforceGetChangelistResponse); i { + switch v := v.(*PerforceConnectionDetails); i { case 0: return &v.state case 1: @@ -9803,7 +10148,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[84].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PerforceChangelist); i { + switch v := v.(*PerforceGetChangelistRequest); i { case 0: return &v.state case 1: @@ -9815,7 +10160,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[85].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*IsPerforceSuperUserRequest); i { + switch v := v.(*PerforceGetChangelistResponse); i { case 0: return &v.state case 1: @@ -9827,7 +10172,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[86].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*IsPerforceSuperUserResponse); i { + switch v := v.(*PerforceChangelist); i { case 0: return &v.state case 1: @@ -9839,7 +10184,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[87].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PerforceProtectsForDepotRequest); i { + switch v := v.(*IsPerforceSuperUserRequest); i { case 0: return &v.state case 1: @@ -9851,7 +10196,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[88].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PerforceProtectsForDepotResponse); i { + switch v := v.(*IsPerforceSuperUserResponse); i { case 0: return &v.state case 1: @@ -9863,7 +10208,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[89].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PerforceProtectsForUserRequest); i { + switch v := v.(*PerforceProtectsForDepotRequest); i { case 0: return &v.state case 1: @@ -9875,7 +10220,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[90].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PerforceProtectsForUserResponse); i { + switch v := v.(*PerforceProtectsForDepotResponse); i { case 0: return &v.state case 1: @@ -9887,7 +10232,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[91].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PerforceProtect); i { + switch v := v.(*PerforceProtectsForUserRequest); i { case 0: return &v.state case 1: @@ -9899,7 +10244,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[92].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PerforceGroupMembersRequest); i { + switch v := v.(*PerforceProtectsForUserResponse); i { case 0: return &v.state case 1: @@ -9911,7 +10256,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[93].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PerforceGroupMembersResponse); i { + switch v := v.(*PerforceProtect); i { case 0: return &v.state case 1: @@ -9923,7 +10268,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[94].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PerforceUsersRequest); i { + switch v := v.(*PerforceGroupMembersRequest); i { case 0: return &v.state case 1: @@ -9935,7 +10280,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[95].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PerforceUsersResponse); i { + switch v := v.(*PerforceGroupMembersResponse); i { case 0: return &v.state case 1: @@ -9947,7 +10292,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[96].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PerforceUser); i { + switch v := v.(*PerforceUsersRequest); i { case 0: return &v.state case 1: @@ -9959,7 +10304,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[97].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*MergeBaseRequest); i { + switch v := v.(*PerforceUsersResponse); i { case 0: return &v.state case 1: @@ -9971,7 +10316,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[98].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*MergeBaseResponse); i { + switch v := v.(*PerforceUser); i { case 0: return &v.state case 1: @@ -9983,7 +10328,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[99].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*FirstEverCommitRequest); i { + switch v := v.(*MergeBaseRequest); i { case 0: return &v.state case 1: @@ -9995,7 +10340,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[100].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*FirstEverCommitResponse); i { + switch v := v.(*MergeBaseResponse); i { case 0: return &v.state case 1: @@ -10007,7 +10352,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[101].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*BehindAheadRequest); i { + switch v := v.(*FirstEverCommitRequest); i { case 0: return &v.state case 1: @@ -10019,7 +10364,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[102].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*BehindAheadResponse); i { + switch v := v.(*FirstEverCommitResponse); i { case 0: return &v.state case 1: @@ -10031,7 +10376,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[103].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ChangedFilesRequest); i { + switch v := v.(*BehindAheadRequest); i { case 0: return &v.state case 1: @@ -10043,7 +10388,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[104].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ChangedFilesResponse); i { + switch v := v.(*BehindAheadResponse); i { case 0: return &v.state case 1: @@ -10055,7 +10400,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[105].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ChangedFile); i { + switch v := v.(*ChangedFilesRequest); i { case 0: return &v.state case 1: @@ -10067,7 +10412,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[106].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListRepositoriesResponse_GitRepository); i { + switch v := v.(*ChangedFilesResponse); i { case 0: return &v.state case 1: @@ -10079,7 +10424,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[107].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CreateCommitFromPatchBinaryRequest_Metadata); i { + switch v := v.(*ChangedFile); i { case 0: return &v.state case 1: @@ -10091,7 +10436,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[108].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CreateCommitFromPatchBinaryRequest_Patch); i { + switch v := v.(*ListRepositoriesResponse_GitRepository); i { case 0: return &v.state case 1: @@ -10103,7 +10448,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[109].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CommitMatch_Signature); i { + switch v := v.(*CreateCommitFromPatchBinaryRequest_Metadata); i { case 0: return &v.state case 1: @@ -10115,7 +10460,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[110].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CommitMatch_MatchedString); i { + switch v := v.(*CreateCommitFromPatchBinaryRequest_Patch); i { case 0: return &v.state case 1: @@ -10127,7 +10472,7 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[111].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CommitMatch_Range); i { + switch v := v.(*CommitMatch_Signature); i { case 0: return &v.state case 1: @@ -10139,6 +10484,30 @@ func file_gitserver_proto_init() { } } file_gitserver_proto_msgTypes[112].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[113].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[114].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CommitMatch_Location); i { case 0: return &v.state @@ -10151,17 +10520,17 @@ func file_gitserver_proto_init() { } } } - file_gitserver_proto_msgTypes[11].OneofWrappers = []interface{}{} - file_gitserver_proto_msgTypes[16].OneofWrappers = []interface{}{} - file_gitserver_proto_msgTypes[19].OneofWrappers = []interface{}{} - file_gitserver_proto_msgTypes[20].OneofWrappers = []interface{}{} - file_gitserver_proto_msgTypes[28].OneofWrappers = []interface{}{} - file_gitserver_proto_msgTypes[31].OneofWrappers = []interface{}{} - file_gitserver_proto_msgTypes[42].OneofWrappers = []interface{}{ + file_gitserver_proto_msgTypes[13].OneofWrappers = []interface{}{} + file_gitserver_proto_msgTypes[18].OneofWrappers = []interface{}{} + file_gitserver_proto_msgTypes[21].OneofWrappers = []interface{}{} + file_gitserver_proto_msgTypes[22].OneofWrappers = []interface{}{} + file_gitserver_proto_msgTypes[30].OneofWrappers = []interface{}{} + file_gitserver_proto_msgTypes[33].OneofWrappers = []interface{}{} + file_gitserver_proto_msgTypes[44].OneofWrappers = []interface{}{ (*CreateCommitFromPatchBinaryRequest_Metadata_)(nil), (*CreateCommitFromPatchBinaryRequest_Patch_)(nil), } - file_gitserver_proto_msgTypes[62].OneofWrappers = []interface{}{ + file_gitserver_proto_msgTypes[64].OneofWrappers = []interface{}{ (*QueryNode_AuthorMatches)(nil), (*QueryNode_CommitterMatches)(nil), (*QueryNode_CommitBefore)(nil), @@ -10172,19 +10541,19 @@ func file_gitserver_proto_init() { (*QueryNode_Boolean)(nil), (*QueryNode_Operator)(nil), } - file_gitserver_proto_msgTypes[63].OneofWrappers = []interface{}{ + file_gitserver_proto_msgTypes[65].OneofWrappers = []interface{}{ (*SearchResponse_Match)(nil), (*SearchResponse_LimitHit)(nil), } - file_gitserver_proto_msgTypes[103].OneofWrappers = []interface{}{} - file_gitserver_proto_msgTypes[107].OneofWrappers = []interface{}{} + file_gitserver_proto_msgTypes[105].OneofWrappers = []interface{}{} + file_gitserver_proto_msgTypes[109].OneofWrappers = []interface{}{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_gitserver_proto_rawDesc, - NumEnums: 7, - NumMessages: 113, + NumEnums: 8, + NumMessages: 115, NumExtensions: 0, NumServices: 2, }, diff --git a/internal/gitserver/v1/gitserver.proto b/internal/gitserver/v1/gitserver.proto index d84bbe0f44f8..8b42456fe81d 100644 --- a/internal/gitserver/v1/gitserver.proto +++ b/internal/gitserver/v1/gitserver.proto @@ -339,6 +339,73 @@ service GitserverService { rpc ReadDir(ReadDirRequest) returns (stream ReadDirResponse) { option idempotency_level = NO_SIDE_EFFECTS; } + // CommitLog returns all commits matching the options. The commits are gathered + // with `git-log`. + // If one of the given ranges doesn't exist, an error with a ReversionNotFoundPayload + // is returned. + rpc CommitLog(CommitLogRequest) returns (stream CommitLogResponse) { + option idempotency_level = NO_SIDE_EFFECTS; + } +} + +message CommitLogRequest { + // repo_name is the name of the repo to run the blame operation in. + // Note: We use field ID 2 here to reserve 1 for a future repo int32 field. + string repo_name = 2; + // Ranges to include in the git log (revspec, "A..B", "A...B", etc.). + // At least one range, or all_refs must be specified. + repeated bytes ranges = 3; + // If true, all refs are searched for commits. + // Must not be true when ranges are given. + bool all_refs = 4; + // After is an optional parameter to specify the earliest commit to consider + google.protobuf.Timestamp after = 5; + // Before is an optional parameter to specify the latest commit to consider + google.protobuf.Timestamp before = 6; + // MaxCommits is an optional parameter to specify the maximum number of commits + // to return. If max_commits is 0, all commits that match the criteria will be + // returned. + uint32 max_commits = 7; + // Skip is an optional parameter to specify the number of commits to skip. + // This can be used to implement a poor mans pagination. + uint32 skip = 8; + // When finding commits to include, follow only the first parent commit upon + // seeing a merge commit. This option can give a better overview when viewing + // the evolution of a particular topic branch, because merges into a topic + // branch tend to be only about adjusting to updated upstream from time to time, + // and this option allows you to ignore the individual commits brought in to + // your history by such a merge. + bool follow_only_first_parent = 9; + // If true, the modified_files field in the GetCommitResponse will be + // populated. + bool include_modified_files = 10; + enum CommitLogOrder { + // Uses the default ordering of git log: in reverse chronological order. + // See https://git-scm.com/docs/git-log#_commit_ordering for more details. + COMMIT_LOG_ORDER_UNSPECIFIED = 0; + // Show no parents before all of its children are shown, but otherwise show commits + // in the commit timestamp order. + // See https://git-scm.com/docs/git-log#_commit_ordering for more details. + COMMIT_LOG_ORDER_COMMIT_DATE = 1; + // Show no parents before all of its children are shown, and avoid showing commits + // on multiple lines of history intermixed. + // See https://git-scm.com/docs/git-log#_commit_ordering for more details. + COMMIT_LOG_ORDER_TOPO_DATE = 2; + }; + CommitLogOrder order = 11; + // Include only commits whose commit message contains this substring. + bytes message_query = 12; + // include only commits whose author matches this. + bytes author_query = 13; + // include only commits that touch this file path. + bytes path = 14; + // Follow the history of the path beyond renames, only effective when used with + // `path`. + bool follow_path_renames = 15; +} + +message CommitLogResponse { + repeated GetCommitResponse commits = 1; } message ContributorCountsRequest { diff --git a/internal/gitserver/v1/gitserver_grpc.pb.go b/internal/gitserver/v1/gitserver_grpc.pb.go index 149a7e3742d3..fc58ac7df424 100644 --- a/internal/gitserver/v1/gitserver_grpc.pb.go +++ b/internal/gitserver/v1/gitserver_grpc.pb.go @@ -226,6 +226,7 @@ const ( GitserverService_ChangedFiles_FullMethodName = "/gitserver.v1.GitserverService/ChangedFiles" GitserverService_Stat_FullMethodName = "/gitserver.v1.GitserverService/Stat" GitserverService_ReadDir_FullMethodName = "/gitserver.v1.GitserverService/ReadDir" + GitserverService_CommitLog_FullMethodName = "/gitserver.v1.GitserverService/CommitLog" ) // GitserverServiceClient is the client API for GitserverService service. @@ -435,6 +436,7 @@ 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. ReadDir(ctx context.Context, in *ReadDirRequest, opts ...grpc.CallOption) (GitserverService_ReadDirClient, error) + CommitLog(ctx context.Context, in *CommitLogRequest, opts ...grpc.CallOption) (GitserverService_CommitLogClient, error) } type gitserverServiceClient struct { @@ -965,6 +967,38 @@ func (x *gitserverServiceReadDirClient) Recv() (*ReadDirResponse, error) { return m, nil } +func (c *gitserverServiceClient) CommitLog(ctx context.Context, in *CommitLogRequest, opts ...grpc.CallOption) (GitserverService_CommitLogClient, error) { + stream, err := c.cc.NewStream(ctx, &GitserverService_ServiceDesc.Streams[10], GitserverService_CommitLog_FullMethodName, opts...) + if err != nil { + return nil, err + } + x := &gitserverServiceCommitLogClient{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_CommitLogClient interface { + Recv() (*CommitLogResponse, error) + grpc.ClientStream +} + +type gitserverServiceCommitLogClient struct { + grpc.ClientStream +} + +func (x *gitserverServiceCommitLogClient) Recv() (*CommitLogResponse, error) { + m := new(CommitLogResponse) + 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 @@ -1172,6 +1206,7 @@ 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. ReadDir(*ReadDirRequest, GitserverService_ReadDirServer) error + CommitLog(*CommitLogRequest, GitserverService_CommitLogServer) error mustEmbedUnimplementedGitserverServiceServer() } @@ -1275,6 +1310,9 @@ func (UnimplementedGitserverServiceServer) Stat(context.Context, *StatRequest) ( func (UnimplementedGitserverServiceServer) ReadDir(*ReadDirRequest, GitserverService_ReadDirServer) error { return status.Errorf(codes.Unimplemented, "method ReadDir not implemented") } +func (UnimplementedGitserverServiceServer) CommitLog(*CommitLogRequest, GitserverService_CommitLogServer) error { + return status.Errorf(codes.Unimplemented, "method CommitLog not implemented") +} func (UnimplementedGitserverServiceServer) mustEmbedUnimplementedGitserverServiceServer() {} // UnsafeGitserverServiceServer may be embedded to opt out of forward compatibility for this service. @@ -1899,6 +1937,27 @@ func (x *gitserverServiceReadDirServer) Send(m *ReadDirResponse) error { return x.ServerStream.SendMsg(m) } +func _GitserverService_CommitLog_Handler(srv interface{}, stream grpc.ServerStream) error { + m := new(CommitLogRequest) + if err := stream.RecvMsg(m); err != nil { + return err + } + return srv.(GitserverServiceServer).CommitLog(m, &gitserverServiceCommitLogServer{stream}) +} + +type GitserverService_CommitLogServer interface { + Send(*CommitLogResponse) error + grpc.ServerStream +} + +type gitserverServiceCommitLogServer struct { + grpc.ServerStream +} + +func (x *gitserverServiceCommitLogServer) Send(m *CommitLogResponse) 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) @@ -2046,6 +2105,11 @@ var GitserverService_ServiceDesc = grpc.ServiceDesc{ Handler: _GitserverService_ReadDir_Handler, ServerStreams: true, }, + { + StreamName: "CommitLog", + Handler: _GitserverService_CommitLog_Handler, + ServerStreams: true, + }, }, Metadata: "gitserver.proto", } diff --git a/internal/insights/gitserver/client.go b/internal/insights/gitserver/client.go index afbee3fe294d..3daf296fa5ff 100644 --- a/internal/insights/gitserver/client.go +++ b/internal/insights/gitserver/client.go @@ -25,7 +25,7 @@ func (g *GitCommitClient) FirstCommit(ctx context.Context, repoName api.RepoName return g.cachedFirstCommit.GitFirstEverCommit(ctx, g.gitserverClient, repoName) } func (g *GitCommitClient) RecentCommits(ctx context.Context, repoName api.RepoName, target time.Time, revision string) ([]*gitdomain.Commit, error) { - options := gitserver.CommitsOptions{N: 1, Before: target.Format(time.RFC3339), Order: gitserver.CommitsOrderCommitDate} + options := gitserver.CommitsOptions{N: 1, Before: target, Order: gitserver.CommitsOrderCommitDate} if len(revision) > 0 { options.Ranges = []string{revision} } diff --git a/internal/own/background/recent_contributors.go b/internal/own/background/recent_contributors.go index ad2795342c1a..28050e68b4a4 100644 --- a/internal/own/background/recent_contributors.go +++ b/internal/own/background/recent_contributors.go @@ -60,7 +60,7 @@ func (r *recentContributorsIndexer) indexRepo(ctx context.Context, repoId api.Re } commits, err := r.client.Commits(ctx, repo.Name, gitserver.CommitsOptions{ Order: gitserver.CommitsOrderTopoDate, - After: time.Now().AddDate(0, 0, -90).Format(time.RFC3339), + After: time.Now().AddDate(0, 0, -90), Ranges: []string{"HEAD"}, }) if err != nil { diff --git a/internal/search/commit/commit.go b/internal/search/commit/commit.go index 852bd71ac0ff..753df12af733 100644 --- a/internal/search/commit/commit.go +++ b/internal/search/commit/commit.go @@ -294,10 +294,10 @@ func queryParameterToPredicate(parameter query.Parameter, caseSensitive, diff bo case query.FieldCommitter: newPred = &gitprotocol.CommitterMatches{Expr: parameter.Value, IgnoreCase: !caseSensitive} case query.FieldBefore: - t, _ := query.ParseGitDate(parameter.Value, time.Now) // field already validated + t, _ := gitdomain.ParseGitDate(parameter.Value, time.Now) // field already validated newPred = &gitprotocol.CommitBefore{Time: t} case query.FieldAfter: - t, _ := query.ParseGitDate(parameter.Value, time.Now) // field already validated + t, _ := gitdomain.ParseGitDate(parameter.Value, time.Now) // field already validated newPred = &gitprotocol.CommitAfter{Time: t} case query.FieldMessage: newPred = &gitprotocol.MessageMatches{Expr: parameter.Value, IgnoreCase: !caseSensitive} diff --git a/internal/search/query/BUILD.bazel b/internal/search/query/BUILD.bazel index fd5cf02eaca5..17a17235a2a5 100644 --- a/internal/search/query/BUILD.bazel +++ b/internal/search/query/BUILD.bazel @@ -4,7 +4,6 @@ load("@io_bazel_rules_go//go:def.bzl", "go_library") go_library( name = "query", srcs = [ - "date_format.go", "fields.go", "helpers.go", "labels.go", @@ -25,7 +24,7 @@ go_library( tags = [TAG_PLATFORM_SEARCH], visibility = ["//:__subpackages__"], deps = [ - "//internal/lazyregexp", + "//internal/gitserver/gitdomain", "//internal/search/filter", "//internal/search/limits", "//lib/errors", @@ -33,7 +32,6 @@ go_library( "@com_github_go_enry_go_enry_v2//data", "@com_github_grafana_regexp//:regexp", "@com_github_grafana_regexp//syntax", - "@com_github_tj_go_naturaldate//:go-naturaldate", ], ) @@ -41,7 +39,6 @@ go_test( name = "query_test", timeout = "short", srcs = [ - "date_format_test.go", "helpers_test.go", "mapper_test.go", "parser_test.go", diff --git a/internal/search/query/predicate.go b/internal/search/query/predicate.go index baee75292272..bd8925bca2d1 100644 --- a/internal/search/query/predicate.go +++ b/internal/search/query/predicate.go @@ -8,6 +8,7 @@ import ( "github.com/grafana/regexp" "github.com/grafana/regexp/syntax" + "github.com/sourcegraph/sourcegraph/internal/gitserver/gitdomain" "github.com/sourcegraph/sourcegraph/lib/errors" ) @@ -626,7 +627,7 @@ type RevAtTimePredicate struct { func (f *RevAtTimePredicate) Unmarshal(params string, negated bool) error { elems := strings.Split(params, ",") if len(elems) == 1 { - t, err := ParseGitDate(strings.TrimSpace(elems[0]), time.Now) + t, err := gitdomain.ParseGitDate(strings.TrimSpace(elems[0]), time.Now) if err != nil { return err } @@ -634,7 +635,7 @@ func (f *RevAtTimePredicate) Unmarshal(params string, negated bool) error { f.RevSpec = "HEAD" return nil } else if len(elems) == 2 { - t, err := ParseGitDate(strings.TrimSpace(elems[0]), time.Now) + t, err := gitdomain.ParseGitDate(strings.TrimSpace(elems[0]), time.Now) if err != nil { return err } diff --git a/internal/search/query/validate.go b/internal/search/query/validate.go index a290970ca5ef..d69a49eab57d 100644 --- a/internal/search/query/validate.go +++ b/internal/search/query/validate.go @@ -8,6 +8,7 @@ import ( "github.com/go-enry/go-enry/v2" "github.com/grafana/regexp" + "github.com/sourcegraph/sourcegraph/internal/gitserver/gitdomain" "github.com/sourcegraph/sourcegraph/internal/search/filter" "github.com/sourcegraph/sourcegraph/lib/errors" ) @@ -223,7 +224,7 @@ func validateField(field, value string, negated bool, seen map[string]struct{}) } isValidGitDate := func() error { - _, err := ParseGitDate(value, time.Now) + _, err := gitdomain.ParseGitDate(value, time.Now) return err } diff --git a/internal/search/repos/repos.go b/internal/search/repos/repos.go index 5213224b502f..6e84da45c681 100644 --- a/internal/search/repos/repos.go +++ b/internal/search/repos/repos.go @@ -600,6 +600,11 @@ func (r *Resolver) filterHasCommitAfter( return repoRevs, nil } + timeRef, err := gitdomain.ParseGitDate(op.CommitAfter.TimeRef, time.Now) + if err != nil { + return nil, errors.Wrap(err, "invalid time ref") + } + p := pool.New().WithContext(ctx).WithMaxGoroutines(128) for _, repoRev := range repoRevs { @@ -613,7 +618,7 @@ func (r *Resolver) filterHasCommitAfter( for _, rev := range allRevs { rev := rev p.Go(func(ctx context.Context) error { - if hasCommitAfter, err := hasCommitAfter(ctx, r.gitserver, repoRev.Repo.Name, op.CommitAfter.TimeRef, rev); err != nil { + if hasCommitAfter, err := hasCommitAfter(ctx, r.gitserver, repoRev.Repo.Name, timeRef, rev); err != nil { if errors.HasType(err, &gitdomain.RevisionNotFoundError{}) || gitdomain.IsRepoNotExist(err) { // If the revision does not exist or the repo does not exist, // it certainly does not have any commits after some time. @@ -652,7 +657,7 @@ func (r *Resolver) filterHasCommitAfter( // hasCommitAfter indicates the staleness of a repository. It returns a boolean indicating if a repository // contains a commit past a specified date. -func hasCommitAfter(ctx context.Context, gitserverClient gitserver.Client, repoName api.RepoName, timeRef string, revspec string) (bool, error) { +func hasCommitAfter(ctx context.Context, gitserverClient gitserver.Client, repoName api.RepoName, timeRef time.Time, revspec string) (bool, error) { if revspec == "" { revspec = "HEAD" }