diff --git a/approvals/approvals.go b/approvals/approvals.go new file mode 100644 index 00000000..f85017c0 --- /dev/null +++ b/approvals/approvals.go @@ -0,0 +1,369 @@ +package approvals + +import ( + "context" + "errors" + "sync" + "sync/atomic" + "time" + + "github.com/rusenask/keel/cache" + "github.com/rusenask/keel/types" + "github.com/rusenask/keel/util/codecs" + + log "github.com/Sirupsen/logrus" +) + +// Manager is used to manage updates +type Manager interface { + // Subscribe for approval request events, subscriber should provide + // its name. Indented to be used by extensions that collect + // approvals + Subscribe(ctx context.Context) (<-chan *types.Approval, error) + + // SubscribeApproved - is used to get approved events by the manager + SubscribeApproved(ctx context.Context) (<-chan *types.Approval, error) + + // request approval for deployment/release/etc.. + Create(r *types.Approval) error + // Update whole approval object + Update(r *types.Approval) error + + // Increases Approval votes by 1 + Approve(identifier, voter string) (*types.Approval, error) + // Rejects Approval + Reject(identifier string) (*types.Approval, error) + + Get(identifier string) (*types.Approval, error) + List() ([]*types.Approval, error) + Delete(identifier string) error + + StartExpiryService(ctx context.Context) error +} + +// Approvals related errors +var ( + ErrApprovalAlreadyExists = errors.New("approval already exists") +) + +// Approvals cache prefix +const ( + ApprovalsPrefix = "approvals" +) + +// DefaultManager - default manager implementation +type DefaultManager struct { + // cache is used to store approvals, key example: + // approvals// + cache cache.Cache + serializer codecs.Serializer + + // subscriber channels + channels map[uint64]chan *types.Approval + index uint64 + + // approved channels + approvedCh map[uint64]chan *types.Approval + + mu *sync.Mutex + subMu *sync.RWMutex +} + +// New create new instance of default manager +func New(cache cache.Cache, serializer codecs.Serializer) *DefaultManager { + man := &DefaultManager{ + cache: cache, + serializer: serializer, + channels: make(map[uint64]chan *types.Approval), + approvedCh: make(map[uint64]chan *types.Approval), + index: 0, + mu: &sync.Mutex{}, + subMu: &sync.RWMutex{}, + } + + return man +} + +// StartExpiryService - starts approval expiry service which deletes approvals +// that already reached their deadline +func (m *DefaultManager) StartExpiryService(ctx context.Context) error { + ticker := time.NewTicker(60 * time.Minute) + + err := m.expireEntries() + if err != nil { + log.WithFields(log.Fields{ + "error": err, + }).Error("approvals.StartExpiryService: got error while performing initial expired approvals check") + } + + for { + select { + case <-ctx.Done(): + return nil + case <-ticker.C: + err := m.expireEntries() + if err != nil { + log.WithFields(log.Fields{ + "error": err, + }).Error("approvals.StartExpiryService: got error while performing routinely expired approvals check") + } + } + } +} + +func (m *DefaultManager) expireEntries() error { + approvals, err := m.cache.List(ApprovalsPrefix + "/") + if err != nil { + return err + } + + for k, v := range approvals { + var approval types.Approval + err = m.serializer.Decode(v, &approval) + if err != nil { + log.WithFields(log.Fields{ + "error": err, + "identifier": k, + }).Error("approvals.expireEntries: failed to decode approval into value") + continue + } + + if approval.Expired() { + err = m.Delete(approval.Identifier) + if err != nil { + log.WithFields(log.Fields{ + "error": err, + "identifier": k, + }).Error("approvals.expireEntries: failed to delete expired approval") + } + } + } + + return nil +} + +// Subscribe - subscribe for approval events +func (m *DefaultManager) Subscribe(ctx context.Context) (<-chan *types.Approval, error) { + m.subMu.Lock() + index := atomic.AddUint64(&m.index, 1) + approvalsCh := make(chan *types.Approval, 10) + m.channels[index] = approvalsCh + m.subMu.Unlock() + + go func() { + for { + select { + case <-ctx.Done(): + m.subMu.Lock() + + delete(m.channels, index) + + m.subMu.Unlock() + return + } + } + }() + + return approvalsCh, nil +} + +// SubscribeApproved - subscribe for approved update requests +func (m *DefaultManager) SubscribeApproved(ctx context.Context) (<-chan *types.Approval, error) { + m.subMu.Lock() + index := atomic.AddUint64(&m.index, 1) + approvedCh := make(chan *types.Approval, 10) + m.approvedCh[index] = approvedCh + m.subMu.Unlock() + + go func() { + for { + select { + case <-ctx.Done(): + m.subMu.Lock() + + delete(m.approvedCh, index) + + m.subMu.Unlock() + return + } + } + }() + + return approvedCh, nil +} + +func (m *DefaultManager) publishRequest(approval *types.Approval) error { + m.subMu.RLock() + defer m.subMu.RUnlock() + + for _, subscriber := range m.channels { + subscriber <- approval + } + return nil +} + +func (m *DefaultManager) publishApproved(approval *types.Approval) error { + m.subMu.RLock() + defer m.subMu.RUnlock() + + for _, subscriber := range m.approvedCh { + subscriber <- approval + } + return nil +} + +// Create - creates new approval request and publishes to all subscribers +func (m *DefaultManager) Create(r *types.Approval) error { + _, err := m.Get(r.Identifier) + if err == nil { + return ErrApprovalAlreadyExists + } + + r.CreatedAt = time.Now() + r.UpdatedAt = time.Now() + + bts, err := m.serializer.Encode(r) + if err != nil { + return err + } + + err = m.cache.Put(getKey(r.Identifier), bts) + if err != nil { + return err + } + + return m.publishRequest(r) +} + +// Update - update approval +func (m *DefaultManager) Update(r *types.Approval) error { + existing, err := m.Get(r.Identifier) + if err != nil { + return err + } + + r.CreatedAt = existing.CreatedAt + r.UpdatedAt = time.Now() + + bts, err := m.serializer.Encode(r) + if err != nil { + return err + } + + if r.Status() == types.ApprovalStatusApproved { + err = m.publishApproved(r) + if err != nil { + log.WithFields(log.Fields{ + "error": err, + "approval": r.Identifier, + "provider": r.Provider, + }).Error("approvals.manager: failed to re-submit event after approvals were collected") + } + } + + return m.cache.Put(getKey(r.Identifier), bts) +} + +// Approve - increase VotesReceived by 1 and returns updated version +func (m *DefaultManager) Approve(identifier, voter string) (*types.Approval, error) { + m.mu.Lock() + defer m.mu.Unlock() + + existing, err := m.Get(identifier) + if err != nil { + log.WithFields(log.Fields{ + "identifier": identifier, + "error": err, + }).Error("approvals.manager: failed to get") + return nil, err + } + + for _, v := range existing.Voters { + if v == voter { + // nothing to do, same voter + return existing, nil + } + } + + existing.Voters = append(existing.Voters, voter) + existing.VotesReceived++ + + err = m.Update(existing) + if err != nil { + log.WithFields(log.Fields{ + "identifier": identifier, + "error": err, + }).Error("approvals.manager: failed to update") + return nil, err + } + + log.WithFields(log.Fields{ + "identifier": identifier, + }).Info("approvals.manager: approved") + + return existing, nil +} + +// Reject - rejects approval (marks rejected=true), approval will not be valid even if it +// collects required votes +func (m *DefaultManager) Reject(identifier string) (*types.Approval, error) { + m.mu.Lock() + defer m.mu.Unlock() + + existing, err := m.Get(identifier) + if err != nil { + return nil, err + } + + existing.Rejected = true + + err = m.Update(existing) + if err != nil { + return nil, err + } + + return existing, nil +} + +// Get - get specified approval +func (m *DefaultManager) Get(identifier string) (*types.Approval, error) { + bts, err := m.cache.Get(getKey(identifier)) + if err != nil { + return nil, err + } + + var approval types.Approval + err = m.serializer.Decode(bts, &approval) + return &approval, err +} + +// List - list approvals +func (m *DefaultManager) List() ([]*types.Approval, error) { + bts, err := m.cache.List(ApprovalsPrefix) + if err != nil { + return nil, err + } + + var approvals []*types.Approval + for _, v := range bts { + var approval types.Approval + err = m.serializer.Decode(v, &approval) + if err != nil { + log.WithFields(log.Fields{ + "error": err, + }).Error("approvals.manager: failed to decode payload") + continue + } + approvals = append(approvals, &approval) + } + return approvals, nil +} + +// Delete - delete specified approval +func (m *DefaultManager) Delete(identifier string) error { + return m.cache.Delete(getKey(identifier)) +} + +func getKey(identifier string) string { + return ApprovalsPrefix + "/" + identifier +} diff --git a/approvals/approvals_test.go b/approvals/approvals_test.go new file mode 100644 index 00000000..c80ddf06 --- /dev/null +++ b/approvals/approvals_test.go @@ -0,0 +1,366 @@ +package approvals + +import ( + "context" + "testing" + "time" + + "github.com/rusenask/keel/cache/memory" + "github.com/rusenask/keel/types" + "github.com/rusenask/keel/util/codecs" +) + +func TestCreateApproval(t *testing.T) { + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + + am := New(mem, codecs.DefaultSerializer()) + + err := am.Create(&types.Approval{ + Provider: types.ProviderTypeKubernetes, + Identifier: "xxx/app-1", + CurrentVersion: "1.2.3", + NewVersion: "1.2.5", + Deadline: time.Now().Add(5 * time.Minute), + }) + + if err != nil { + t.Fatalf("failed to create approval: %s", err) + } + + stored, err := am.Get("xxx/app-1") + if err != nil { + t.Fatalf("failed to get approval: %s", err) + } + + if stored.CurrentVersion != "1.2.3" { + t.Errorf("unexpected version: %s", stored.CurrentVersion) + } +} + +func TestDeleteApproval(t *testing.T) { + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + + am := New(mem, codecs.DefaultSerializer()) + + err := am.Create(&types.Approval{ + Provider: types.ProviderTypeKubernetes, + Identifier: "xxx/app-1", + CurrentVersion: "1.2.3", + NewVersion: "1.2.5", + Deadline: time.Now().Add(5 * time.Minute), + }) + + if err != nil { + t.Fatalf("failed to create approval: %s", err) + } + + err = am.Delete("xxx/app-1") + if err != nil { + t.Errorf("failed to delete approval: %s", err) + } + + _, err = am.Get("xxx/app-1") + if err == nil { + t.Errorf("expected to get an error when retrieving deleted approval") + } + +} + +func TestUpdateApproval(t *testing.T) { + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + + am := New(mem, codecs.DefaultSerializer()) + + err := am.Create(&types.Approval{ + Provider: types.ProviderTypeKubernetes, + Identifier: "xxx/app-1", + CurrentVersion: "1.2.3", + NewVersion: "1.2.5", + VotesRequired: 1, + VotesReceived: 0, + Deadline: time.Now().Add(5 * time.Minute), + Event: &types.Event{ + Repository: types.Repository{ + Name: "very/repo", + Tag: "1.2.5", + }, + }, + }) + + if err != nil { + t.Fatalf("failed to create approval: %s", err) + } + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + ch, err := am.SubscribeApproved(ctx) + if err != nil { + t.Fatalf("failed to subscribe: %s", err) + } + + err = am.Update(&types.Approval{ + Provider: types.ProviderTypeKubernetes, + Identifier: "xxx/app-1", + CurrentVersion: "1.2.3", + NewVersion: "1.2.5", + VotesRequired: 1, + VotesReceived: 1, + Deadline: time.Now().Add(5 * time.Minute), + Event: &types.Event{ + Repository: types.Repository{ + Name: "very/repo", + Tag: "1.2.5", + }, + }, + }) + + approved := <-ch + + if approved.Event.Repository.Name != "very/repo" { + t.Errorf("unexpected repo name in re-submitted event: %s", approved.Event.Repository.Name) + } + if approved.Event.Repository.Tag != "1.2.5" { + t.Errorf("unexpected repo tag in re-submitted event: %s", approved.Event.Repository.Tag) + } +} + +func TestUpdateApprovalRejected(t *testing.T) { + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + + am := New(mem, codecs.DefaultSerializer()) + + err := am.Create(&types.Approval{ + Provider: types.ProviderTypeKubernetes, + Identifier: "xxx/app-1", + CurrentVersion: "1.2.3", + NewVersion: "1.2.5", + VotesRequired: 1, + VotesReceived: 0, + Deadline: time.Now().Add(5 * time.Minute), + Event: &types.Event{ + Repository: types.Repository{ + Name: "very/repo", + Tag: "1.2.5", + }, + }, + }) + + if err != nil { + t.Fatalf("failed to create approval: %s", err) + } + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + ch, err := am.SubscribeApproved(ctx) + if err != nil { + t.Fatalf("failed to subscribe: %s", err) + } + + // rejecting + err = am.Update(&types.Approval{ + Provider: types.ProviderTypeKubernetes, + Identifier: "xxx/app-1", + CurrentVersion: "1.2.3", + NewVersion: "1.2.5", + VotesRequired: 1, + VotesReceived: 0, + Rejected: true, + Deadline: time.Now().Add(5 * time.Minute), + Event: &types.Event{ + Repository: types.Repository{ + Name: "very/repo", + Tag: "1.2.5", + }, + }, + }) + if err != nil { + t.Fatalf("failed to update approval: %s", err) + } + + // sending vote + err = am.Update(&types.Approval{ + Provider: types.ProviderTypeKubernetes, + Identifier: "xxx/app-1", + CurrentVersion: "1.2.3", + NewVersion: "1.2.5", + VotesRequired: 1, + VotesReceived: 1, + Rejected: true, + Deadline: time.Now().Add(5 * time.Minute), + Event: &types.Event{ + Repository: types.Repository{ + Name: "very/repo", + Tag: "1.2.5", + }, + }, + }) + if err != nil { + t.Fatalf("failed to update approval: %s", err) + } + + select { + case <-time.After(500 * time.Millisecond): + // success + return + case approval := <-ch: + t.Errorf("unexpected approval got: %s", approval.Identifier) + } + +} + +func TestApprove(t *testing.T) { + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + + am := New(mem, codecs.DefaultSerializer()) + + err := am.Create(&types.Approval{ + Provider: types.ProviderTypeKubernetes, + Identifier: "xxx/app-1:1.2.5", + CurrentVersion: "1.2.3", + NewVersion: "1.2.5", + Deadline: time.Now().Add(5 * time.Minute), + VotesRequired: 2, + VotesReceived: 0, + }) + + if err != nil { + t.Fatalf("failed to create approval: %s", err) + } + + am.Approve("xxx/app-1:1.2.5", "warda") + + stored, err := am.Get("xxx/app-1:1.2.5") + if err != nil { + t.Fatalf("failed to get approval: %s", err) + } + + if stored.VotesReceived != 1 { + t.Errorf("unexpected number of received votes: %d", stored.VotesReceived) + } +} + +func TestApproveTwiceSameVoter(t *testing.T) { + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + + am := New(mem, codecs.DefaultSerializer()) + + err := am.Create(&types.Approval{ + Provider: types.ProviderTypeKubernetes, + Identifier: "xxx/app-1:1.2.5", + CurrentVersion: "1.2.3", + NewVersion: "1.2.5", + Deadline: time.Now().Add(5 * time.Minute), + VotesRequired: 2, + VotesReceived: 0, + }) + + if err != nil { + t.Fatalf("failed to create approval: %s", err) + } + + am.Approve("xxx/app-1:1.2.5", "warda") + am.Approve("xxx/app-1:1.2.5", "warda") + + stored, err := am.Get("xxx/app-1:1.2.5") + if err != nil { + t.Fatalf("failed to get approval: %s", err) + } + + // should still be the same + if stored.VotesReceived != 1 { + t.Errorf("unexpected number of received votes: %d", stored.VotesReceived) + } +} + +func TestApproveTwoVoters(t *testing.T) { + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + + am := New(mem, codecs.DefaultSerializer()) + + err := am.Create(&types.Approval{ + Provider: types.ProviderTypeKubernetes, + Identifier: "xxx/app-1:1.2.5", + CurrentVersion: "1.2.3", + NewVersion: "1.2.5", + Deadline: time.Now().Add(5 * time.Minute), + VotesRequired: 2, + VotesReceived: 0, + }) + + if err != nil { + t.Fatalf("failed to create approval: %s", err) + } + + am.Approve("xxx/app-1:1.2.5", "w") + am.Approve("xxx/app-1:1.2.5", "k") + + stored, err := am.Get("xxx/app-1:1.2.5") + if err != nil { + t.Fatalf("failed to get approval: %s", err) + } + + // should still be the same + if stored.VotesReceived != 2 { + t.Errorf("unexpected number of received votes: %d", stored.VotesReceived) + } +} + +func TestReject(t *testing.T) { + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + + am := New(mem, codecs.DefaultSerializer()) + + err := am.Create(&types.Approval{ + Provider: types.ProviderTypeKubernetes, + Identifier: "xxx/app-1", + CurrentVersion: "1.2.3", + NewVersion: "1.2.5", + Deadline: time.Now().Add(5 * time.Minute), + VotesRequired: 2, + VotesReceived: 0, + }) + + if err != nil { + t.Fatalf("failed to create approval: %s", err) + } + + am.Reject("xxx/app-1") + + stored, err := am.Get("xxx/app-1") + if err != nil { + t.Fatalf("failed to get approval: %s", err) + } + + if !stored.Rejected { + t.Errorf("unexpected approval to be rejected") + } +} + +func TestExpire(t *testing.T) { + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + + am := New(mem, codecs.DefaultSerializer()) + + err := am.Create(&types.Approval{ + Provider: types.ProviderTypeKubernetes, + Identifier: "xxx/app-1", + CurrentVersion: "1.2.3", + NewVersion: "1.2.5", + Deadline: time.Now().Add(-5 * time.Minute), + VotesRequired: 2, + VotesReceived: 0, + }) + + if err != nil { + t.Fatalf("failed to create approval: %s", err) + } + + err = am.expireEntries() + if err != nil { + t.Errorf("got error while expiring entries: %s", err) + } + + _, err = am.Get("xxx/app-1") + if err == nil { + t.Errorf("expected approval to be deleted but didn't get an error") + } +} diff --git a/bot/approvals.go b/bot/approvals.go new file mode 100644 index 00000000..4cb9e47c --- /dev/null +++ b/bot/approvals.go @@ -0,0 +1,286 @@ +package bot + +import ( + "bytes" + "fmt" + "strings" + + "github.com/nlopes/slack" + "github.com/rusenask/keel/bot/formatter" + "github.com/rusenask/keel/types" + + log "github.com/Sirupsen/logrus" +) + +func (b *Bot) subscribeForApprovals() error { + approvalsCh, err := b.approvalsManager.Subscribe(b.ctx) + if err != nil { + return err + } + + for { + select { + case <-b.ctx.Done(): + return nil + case a := <-approvalsCh: + err = b.requestApproval(a) + if err != nil { + log.WithFields(log.Fields{ + "error": err, + "approval": a.Identifier, + }).Error("bot.subscribeForApprovals: approval request failed") + } + + } + } +} + +// Request - request approval +func (b *Bot) requestApproval(req *types.Approval) error { + return b.postMessage( + "Approval required", + req.Message, + types.LevelSuccess.Color(), + []slack.AttachmentField{ + slack.AttachmentField{ + Title: "Approval required!", + Value: req.Message + "\n" + fmt.Sprintf("To vote for change type '%s approve %s' to reject it: '%s reject %s'.", b.name, req.Identifier, b.name, req.Identifier), + Short: false, + }, + slack.AttachmentField{ + Title: "Votes", + Value: fmt.Sprintf("%d/%d", req.VotesReceived, req.VotesRequired), + Short: true, + }, + slack.AttachmentField{ + Title: "Delta", + Value: req.Delta(), + Short: true, + }, + slack.AttachmentField{ + Title: "Identifier", + Value: req.Identifier, + Short: true, + }, + slack.AttachmentField{ + Title: "Provider", + Value: req.Provider.String(), + Short: true, + }, + }) + +} +func (b *Bot) processApprovalResponses() error { + + for { + select { + case <-b.ctx.Done(): + return nil + case resp := <-b.approvalsRespCh: + + switch resp.Status { + case types.ApprovalStatusApproved: + err := b.processApprovedResponse(resp) + if err != nil { + log.WithFields(log.Fields{ + "error": err, + }).Error("bot.processApprovalResponses: failed to process approval response message") + } + case types.ApprovalStatusRejected: + err := b.processRejectedResponse(resp) + if err != nil { + log.WithFields(log.Fields{ + "error": err, + }).Error("bot.processApprovalResponses: failed to process approval reject response message") + } + } + + } + } +} + +func (b *Bot) processApprovedResponse(approvalResponse *approvalResponse) error { + trimmed := strings.TrimPrefix(approvalResponse.Text, approvalResponseKeyword) + identifiers := strings.Split(trimmed, " ") + if len(identifiers) == 0 { + return nil + } + + for _, identifier := range identifiers { + if identifier == "" { + continue + } + approval, err := b.approvalsManager.Approve(identifier, approvalResponse.User) + if err != nil { + log.WithFields(log.Fields{ + "error": err, + "identifier": identifier, + }).Error("bot.processApprovedResponse: failed to approve") + continue + } + + err = b.replyToApproval(approval) + if err != nil { + log.WithFields(log.Fields{ + "error": err, + "identifier": identifier, + }).Error("bot.processApprovedResponse: got error while replying after processing approved approval") + } + + } + return nil +} + +func (b *Bot) processRejectedResponse(approvalResponse *approvalResponse) error { + trimmed := strings.TrimPrefix(approvalResponse.Text, rejectResponseKeyword) + identifiers := strings.Split(trimmed, " ") + if len(identifiers) == 0 { + return nil + } + + for _, identifier := range identifiers { + approval, err := b.approvalsManager.Reject(identifier) + if err != nil { + log.WithFields(log.Fields{ + "error": err, + "identifier": identifier, + }).Error("bot.processApprovedResponse: failed to reject") + continue + } + + err = b.replyToApproval(approval) + if err != nil { + log.WithFields(log.Fields{ + "error": err, + "identifier": identifier, + }).Error("bot.processApprovedResponse: got error while replying after processing rejected approval") + } + + } + return nil +} + +func (b *Bot) replyToApproval(approval *types.Approval) error { + switch approval.Status() { + case types.ApprovalStatusPending: + b.postMessage( + "Vote received", + "All approvals received, thanks for voting!", + types.LevelInfo.Color(), + []slack.AttachmentField{ + slack.AttachmentField{ + Title: "vote received!", + Value: "Waiting for remaining votes.", + Short: false, + }, + slack.AttachmentField{ + Title: "Votes", + Value: fmt.Sprintf("%d/%d", approval.VotesReceived, approval.VotesRequired), + Short: true, + }, + slack.AttachmentField{ + Title: "Delta", + Value: approval.Delta(), + Short: true, + }, + slack.AttachmentField{ + Title: "Identifier", + Value: approval.Identifier, + Short: true, + }, + }) + case types.ApprovalStatusRejected: + b.postMessage( + "Change rejected", + "Change was rejected", + types.LevelWarn.Color(), + []slack.AttachmentField{ + slack.AttachmentField{ + Title: "change rejected", + Value: "Change was rejected.", + Short: false, + }, + slack.AttachmentField{ + Title: "Status", + Value: approval.Status().String(), + Short: true, + }, + slack.AttachmentField{ + Title: "Votes", + Value: fmt.Sprintf("%d/%d", approval.VotesReceived, approval.VotesRequired), + Short: true, + }, + slack.AttachmentField{ + Title: "Delta", + Value: approval.Delta(), + Short: true, + }, + slack.AttachmentField{ + Title: "Identifier", + Value: approval.Identifier, + Short: true, + }, + }) + case types.ApprovalStatusApproved: + b.postMessage( + "approval received", + "All approvals received, thanks for voting!", + types.LevelSuccess.Color(), + []slack.AttachmentField{ + slack.AttachmentField{ + Title: "update approved!", + Value: "All approvals received, thanks for voting!", + Short: false, + }, + slack.AttachmentField{ + Title: "Votes", + Value: fmt.Sprintf("%d/%d", approval.VotesReceived, approval.VotesRequired), + Short: true, + }, + slack.AttachmentField{ + Title: "Delta", + Value: approval.Delta(), + Short: true, + }, + slack.AttachmentField{ + Title: "Identifier", + Value: approval.Identifier, + Short: true, + }, + }) + } + return nil +} + +func (b *Bot) approvalsResponse() string { + approvals, err := b.approvalsManager.List() + if err != nil { + return fmt.Sprintf("got error while fetching approvals: %s", err) + } + + if len(approvals) == 0 { + return fmt.Sprintf("there are currently no request waiting to be approved.") + } + + buf := &bytes.Buffer{} + + approvalCtx := formatter.Context{ + Output: buf, + Format: formatter.NewApprovalsFormat(formatter.TableFormatKey, false), + } + err = formatter.ApprovalWrite(approvalCtx, approvals) + + if err != nil { + return fmt.Sprintf("got error while formatting approvals: %s", err) + } + + return buf.String() +} + +func (b *Bot) removeApprovalHandler(identifier string) string { + err := b.approvalsManager.Delete(identifier) + if err != nil { + return fmt.Sprintf("failed to remove '%s' approval: %s.", identifier, err) + } + return fmt.Sprintf("approval '%s' removed.", identifier) +} diff --git a/bot/bot.go b/bot/bot.go index f4017595..fdea09fe 100644 --- a/bot/bot.go +++ b/bot/bot.go @@ -2,22 +2,35 @@ package bot import ( "context" + "encoding/json" "errors" "fmt" + "strconv" "strings" + "time" "github.com/nlopes/slack" + "github.com/rusenask/keel/approvals" "github.com/rusenask/keel/provider/kubernetes" + "github.com/rusenask/keel/types" log "github.com/Sirupsen/logrus" ) +const ( + removeApprovalPrefix = "rm approval" +) + var ( botEventTextToResponse = map[string][]string{ "help": { `Here's a list of supported commands`, `- "get deployments" -> get a list of all deployments`, + `- "get approvals" -> get a list of approvals`, + `- "rm approval " -> remove approval`, + `- "approve " -> approve update request`, + `- "reject " -> reject update request`, // `- "get deployments all" -> get a list of all deployments`, // `- "describe deployment " -> get details for specified deployment`, }, @@ -25,14 +38,30 @@ var ( // static bot commands can be used straight away staticBotCommands = map[string]bool{ - "get deployments": true, - "get deployments all": true, + "get deployments": true, + "get approvals": true, } // dynamic bot command prefixes have to be matched - dynamicBotCommandPrefixes = []string{"describe deployment"} + dynamicBotCommandPrefixes = []string{removeApprovalPrefix} + + approvalResponseKeyword = "approve" + rejectResponseKeyword = "reject" ) +// SlackImplementer - implementes slack HTTP functionality, used to +// send messages with attachments +type SlackImplementer interface { + PostMessage(channel, text string, params slack.PostMessageParameters) (string, string, error) +} + +// approvalResponse - used to track approvals once vote begins +type approvalResponse struct { + User string + Status types.ApprovalStatus + Text string +} + // Bot - main slack bot container type Bot struct { id string // bot id @@ -45,20 +74,31 @@ type Bot struct { slackClient *slack.Client slackRTM *slack.RTM + slackHTTPClient SlackImplementer + + approvalsRespCh chan *approvalResponse + + approvalsManager approvals.Manager + k8sImplementer kubernetes.Implementer ctx context.Context } // New - create new bot instance -func New(name, token string, k8sImplementer kubernetes.Implementer) *Bot { +func New(name, token string, k8sImplementer kubernetes.Implementer, approvalsManager approvals.Manager) *Bot { client := slack.New(token) - return &Bot{ - slackClient: client, - k8sImplementer: k8sImplementer, - name: name, + bot := &Bot{ + slackClient: client, + slackHTTPClient: client, + k8sImplementer: k8sImplementer, + name: name, + approvalsManager: approvalsManager, + approvalsRespCh: make(chan *approvalResponse), // don't add buffer to make it blocking } + + return bot } // Start - start bot @@ -90,8 +130,15 @@ func (b *Bot) Start(ctx context.Context) error { b.msgPrefix = strings.ToLower("<@" + b.id + ">") + // processing messages coming from slack RTM client go b.startInternal() + // processing slack approval responses + go b.processApprovalResponses() + + // subscribing for approval requests + go b.subscribeForApprovals() + return nil } @@ -140,6 +187,49 @@ func (b *Bot) startInternal() error { } } +func (b *Bot) postMessage(title, message, color string, fields []slack.AttachmentField) error { + params := slack.NewPostMessageParameters() + params.Username = b.name + + params.Attachments = []slack.Attachment{ + slack.Attachment{ + Fallback: message, + Color: color, + Fields: fields, + Footer: "https://keel.sh", + Ts: json.Number(strconv.Itoa(int(time.Now().Unix()))), + }, + } + + _, _, err := b.slackHTTPClient.PostMessage("general", "", params) + if err != nil { + log.WithFields(log.Fields{ + "error": err, + }).Error("bot.postMessage: failed to send message") + } + return err +} + +func (b *Bot) isApproval(event *slack.MessageEvent, eventText string) (resp *approvalResponse, ok bool) { + if strings.HasPrefix(strings.ToLower(eventText), approvalResponseKeyword) { + return &approvalResponse{ + User: event.User, + Status: types.ApprovalStatusApproved, + Text: eventText, + }, true + } + + if strings.HasPrefix(strings.ToLower(eventText), rejectResponseKeyword) { + return &approvalResponse{ + User: event.User, + Status: types.ApprovalStatusRejected, + Text: eventText, + }, true + } + + return nil, false +} + func (b *Bot) handleMessage(event *slack.MessageEvent) { if event.BotID != "" || event.User == "" || event.SubType == "bot_message" { log.WithFields(log.Fields{ @@ -152,12 +242,16 @@ func (b *Bot) handleMessage(event *slack.MessageEvent) { eventText := strings.Trim(strings.ToLower(event.Text), " \n\r") - // All messages past this point are directed to @gopher itself if !b.isBotMessage(event, eventText) { return } eventText = b.trimBot(eventText) + approval, ok := b.isApproval(event, eventText) + if ok { + b.approvalsRespCh <- approval + return + } // Responses that are just a canned string response if responseLines, ok := botEventTextToResponse[eventText]; ok { @@ -200,6 +294,16 @@ func (b *Bot) handleCommand(event *slack.MessageEvent, eventText string) { response := b.deploymentsResponse(Filter{}) b.respond(event, formatAsSnippet(response)) return + case "get approvals": + response := b.approvalsResponse() + b.respond(event, formatAsSnippet(response)) + return + } + + // handle dynamic commands + if strings.HasPrefix(eventText, removeApprovalPrefix) { + b.respond(event, formatAsSnippet(b.removeApprovalHandler(strings.TrimSpace(strings.TrimPrefix(eventText, removeApprovalPrefix))))) + return } log.Info("command not found") diff --git a/bot/bot_test.go b/bot/bot_test.go new file mode 100644 index 00000000..4f1bbbee --- /dev/null +++ b/bot/bot_test.go @@ -0,0 +1,315 @@ +package bot + +import ( + "context" + "fmt" + "os" + "time" + + "github.com/nlopes/slack" + + "github.com/rusenask/keel/approvals" + "github.com/rusenask/keel/cache/memory" + "github.com/rusenask/keel/constants" + "github.com/rusenask/keel/extension/approval" + "github.com/rusenask/keel/types" + "github.com/rusenask/keel/util/codecs" + + "testing" + + testutil "github.com/rusenask/keel/util/testing" +) + +type fakeProvider struct { + submitted []types.Event + images []*types.TrackedImage +} + +func (p *fakeProvider) Submit(event types.Event) error { + p.submitted = append(p.submitted, event) + return nil +} + +func (p *fakeProvider) TrackedImages() ([]*types.TrackedImage, error) { + return p.images, nil +} + +func (p *fakeProvider) List() []string { + return []string{"fakeprovider"} +} +func (p *fakeProvider) Stop() { + return +} +func (p *fakeProvider) GetName() string { + return "fp" +} + +type postedMessage struct { + channel string + text string + params slack.PostMessageParameters +} + +type fakeSlackImplementer struct { + postedMessages []postedMessage +} + +func (i *fakeSlackImplementer) PostMessage(channel, text string, params slack.PostMessageParameters) (string, string, error) { + i.postedMessages = append(i.postedMessages, postedMessage{ + channel: channel, + text: text, + params: params, + }) + return "", "", nil +} + +func TestBotRequest(t *testing.T) { + f8s := &testutil.FakeK8sImplementer{} + + fi := &fakeSlackImplementer{} + mem := memory.NewMemoryCache(100*time.Second, 100*time.Second, 10*time.Second) + + token := os.Getenv(constants.EnvSlackToken) + if token == "" { + t.Skip() + } + + am := approvals.New(mem, codecs.DefaultSerializer()) + + bot := New("keel", token, f8s, am) + // replacing slack client so we can receive webhooks + bot.slackHTTPClient = fi + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + err := bot.Start(ctx) + if err != nil { + t.Fatalf("failed to start bot: %s", err) + } + + time.Sleep(1 * time.Second) + + err = am.Create(&types.Approval{ + Identifier: "k8s/project/repo:1.2.3", + VotesRequired: 1, + CurrentVersion: "2.3.4", + NewVersion: "3.4.5", + Event: &types.Event{ + Repository: types.Repository{ + Name: "project/repo", + Tag: "2.3.4", + }, + }, + }) + + if err != nil { + t.Fatalf("unexpected error while creating : %s", err) + } + + time.Sleep(1 * time.Second) + + if len(fi.postedMessages) != 1 { + t.Errorf("expected to find one message, but got: %d", len(fi.postedMessages)) + } +} + +func TestProcessApprovedResponse(t *testing.T) { + f8s := &testutil.FakeK8sImplementer{} + fi := &fakeSlackImplementer{} + mem := memory.NewMemoryCache(100*time.Second, 100*time.Second, 10*time.Second) + + token := os.Getenv(constants.EnvSlackToken) + if token == "" { + t.Skip() + } + + am := approvals.New(mem, codecs.DefaultSerializer()) + + bot := New("keel", token, f8s, am) + // replacing slack client so we can receive webhooks + bot.slackHTTPClient = fi + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + err := bot.Start(ctx) + if err != nil { + t.Fatalf("failed to start bot: %s", err) + } + + time.Sleep(1 * time.Second) + + err = am.Create(&types.Approval{ + Identifier: "k8s/project/repo:1.2.3", + VotesRequired: 1, + CurrentVersion: "2.3.4", + NewVersion: "3.4.5", + Event: &types.Event{ + Repository: types.Repository{ + Name: "project/repo", + Tag: "2.3.4", + }, + }, + }) + + if err != nil { + t.Fatalf("unexpected error while creating : %s", err) + } + + time.Sleep(1 * time.Second) + + if len(fi.postedMessages) != 1 { + t.Errorf("expected to find one message") + } +} + +func TestProcessApprovalReply(t *testing.T) { + f8s := &testutil.FakeK8sImplementer{} + fi := &fakeSlackImplementer{} + mem := memory.NewMemoryCache(100*time.Second, 100*time.Second, 10*time.Second) + + token := os.Getenv(constants.EnvSlackToken) + if token == "" { + t.Skip() + } + + am := approvals.New(mem, codecs.DefaultSerializer()) + + identifier := "k8s/project/repo:1.2.3" + + // creating initial approve request + err := am.Create(&types.Approval{ + Identifier: identifier, + VotesRequired: 2, + CurrentVersion: "2.3.4", + NewVersion: "3.4.5", + Event: &types.Event{ + Repository: types.Repository{ + Name: "project/repo", + Tag: "2.3.4", + }, + }, + }) + + if err != nil { + t.Fatalf("unexpected error while creating : %s", err) + } + + bot := New("keel", token, f8s, am) + // replacing slack client so we can receive webhooks + bot.slackHTTPClient = fi + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + bot.ctx = ctx + + go bot.processApprovalResponses() + + time.Sleep(1 * time.Second) + + // approval resp + bot.approvalsRespCh <- &approvalResponse{ + User: "123", + Status: types.ApprovalStatusApproved, + Text: fmt.Sprintf("%s %s", approvalResponseKeyword, identifier), + } + + time.Sleep(1 * time.Second) + + updated, err := am.Get(identifier) + if err != nil { + t.Fatalf("failed to get approval, error: %s", err) + } + + if updated.VotesReceived != 1 { + t.Errorf("expected to find 1 received vote, found %d", updated.VotesReceived) + } + + if updated.Status() != types.ApprovalStatusPending { + t.Errorf("expected approval to be in status pending but got: %s", updated.Status()) + } + + if len(fi.postedMessages) != 1 { + t.Errorf("expected to find one message") + } + +} + +func TestProcessRejectedReply(t *testing.T) { + f8s := &testutil.FakeK8sImplementer{} + fi := &fakeSlackImplementer{} + mem := memory.NewMemoryCache(100*time.Hour, 100*time.Hour, 100*time.Hour) + + // token := os.Getenv(constants.EnvSlackToken) + // if token == "" { + // t.Skip() + // } + + identifier := "k8s/project/repo:1.2.3" + + am := approvals.New(mem, codecs.DefaultSerializer()) + // creating initial approve request + err := am.Create(&types.Approval{ + Identifier: identifier, + VotesRequired: 2, + CurrentVersion: "2.3.4", + NewVersion: "3.4.5", + Event: &types.Event{ + Repository: types.Repository{ + Name: "project/repo", + Tag: "2.3.4", + }, + }, + }) + + if err != nil { + t.Fatalf("unexpected error while creating : %s", err) + } + + bot := New("keel", "random", f8s, am) + + collector := approval.New() + collector.Configure(am) + + // replacing slack client so we can receive webhooks + bot.slackHTTPClient = fi + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + bot.ctx = ctx + + go bot.processApprovalResponses() + + time.Sleep(1 * time.Second) + + // approval resp + bot.approvalsRespCh <- &approvalResponse{ + User: "123", + Status: types.ApprovalStatusRejected, + Text: fmt.Sprintf("%s %s", rejectResponseKeyword, identifier), + } + + time.Sleep(1 * time.Second) + + updated, err := am.Get(identifier) + if err != nil { + t.Fatalf("failed to get approval, error: %s", err) + } + + if updated.VotesReceived != 0 { + t.Errorf("expected to find 0 received vote, found %d", updated.VotesReceived) + } + + // if updated.Status() != types.ApprovalStatusRejected { + if updated.Status() != types.ApprovalStatusRejected { + t.Errorf("expected approval to be in status rejected but got: %s", updated.Status()) + } + + fmt.Println(updated.Status()) + + if len(fi.postedMessages) != 1 { + t.Errorf("expected to find one message") + } + +} diff --git a/bot/formatter/approvals.go b/bot/formatter/approvals.go new file mode 100644 index 00000000..1f130e6b --- /dev/null +++ b/bot/formatter/approvals.go @@ -0,0 +1,93 @@ +package formatter + +import ( + "fmt" + "strconv" + + "github.com/rusenask/keel/types" +) + +// Formatter headers +const ( + defaultApprovalQuietFormat = "{{.Identifier}} {{.Delta}}" + defaultApprovalTableFormat = "table {{.Identifier}}\t{{.Delta}}\t{{.Votes}}\t{{.Rejected}}\t{{.Provider}}\t{{.Created}}" + + ApprovalIdentifierHeader = "Identifier" + ApprovalDeltaHeader = "Delta" + ApprovalVotesHeader = "Votes" + ApprovalRejectedHeader = "Rejected" + ApprovalProviderHeader = "Provider" + ApprovalCreatedHeader = "Created" +) + +// NewApprovalsFormat returns a format for use with a approval Context +func NewApprovalsFormat(source string, quiet bool) Format { + switch source { + case TableFormatKey: + if quiet { + return defaultApprovalQuietFormat + } + return defaultApprovalTableFormat + case RawFormatKey: + if quiet { + return `name: {{.Identifier}}` + } + return `name: {{.Identifier}}\n` + } + return Format(source) +} + +// ApprovalWrite writes formatted approvals using the Context +func ApprovalWrite(ctx Context, approvals []*types.Approval) error { + render := func(format func(subContext subContext) error) error { + for _, approval := range approvals { + if err := format(&ApprovalContext{v: *approval}); err != nil { + return err + } + } + return nil + } + return ctx.Write(&DeploymentContext{}, render) +} + +// ApprovalContext - approval context is a container for each line +type ApprovalContext struct { + HeaderContext + v types.Approval +} + +// MarshalJSON - marshal to json (inspect) +func (c *ApprovalContext) MarshalJSON() ([]byte, error) { + return marshalJSON(c) +} + +func (c *ApprovalContext) Identifier() string { + c.AddHeader(ApprovalIdentifierHeader) + return c.v.Identifier +} + +func (c *ApprovalContext) Delta() string { + c.AddHeader(ApprovalDeltaHeader) + return c.v.Delta() +} + +func (c *ApprovalContext) Votes() string { + c.AddHeader(ApprovalVotesHeader) + return fmt.Sprintf("%d/%d", c.v.VotesReceived, c.v.VotesRequired) +} + +func (c *ApprovalContext) Rejected() string { + c.AddHeader(ApprovalRejectedHeader) + return strconv.FormatBool(c.v.Rejected) +} + +func (c *ApprovalContext) Provider() string { + c.AddHeader(ApprovalProviderHeader) + return c.v.Provider.String() +} + +func (c *ApprovalContext) Created() string { + c.AddHeader(ApprovalCreatedHeader) + return c.v.CreatedAt.String() +} + diff --git a/cache/cache.go b/cache/cache.go new file mode 100644 index 00000000..a7d29af1 --- /dev/null +++ b/cache/cache.go @@ -0,0 +1,45 @@ +package cache + +import ( + "context" + "errors" + "time" +) + +// Cache - generic cache interface +// type Cache interface { +// Put(ctx context.Context, key string, value []byte) error +// Get(ctx context.Context, key string) (value []byte, err error) +// Delete(ctx context.Context, key string) error +// List(prefix string) ([][]byte, error) +// } +type Cache interface { + Put(key string, value []byte) error + Get(key string) (value []byte, err error) + Delete(key string) error + List(prefix string) (map[string][]byte, error) +} + +type expirationContextKeyType int + +const expirationContextKey expirationContextKeyType = 1 + +// SetContextExpiration - set cache expiration context +func SetContextExpiration(ctx context.Context, expiration time.Duration) context.Context { + return context.WithValue(ctx, expirationContextKey, expiration) +} + +// GetContextExpiration - gets expiration from context, returns it and also returns +// ok - true/false to indicate whether ctx value was found +func GetContextExpiration(ctx context.Context) (exp time.Duration, ok bool) { + expiration := ctx.Value(expirationContextKey) + if expiration != nil { + return expiration.(time.Duration), true + } + return 0, false +} + +var ( + ErrNotFound = errors.New("not found") + ErrExpired = errors.New("entry expired") +) diff --git a/cache/kubekv/kv.go b/cache/kubekv/kv.go new file mode 100644 index 00000000..a08bd45a --- /dev/null +++ b/cache/kubekv/kv.go @@ -0,0 +1,46 @@ +package kubekv + +import ( + "github.com/rusenask/keel/cache" + + "github.com/rusenask/k8s-kv/kv" +) + +type KubeKV struct { + kv *kv.KV +} + +func New(implementer kv.ConfigMapInterface, bucket string) (*KubeKV, error) { + + kvdb, err := kv.New(implementer, "keel", bucket) + if err != nil { + return nil, err + } + + return &KubeKV{ + kv: kvdb, + }, nil +} + +func (k *KubeKV) Put(key string, value []byte) error { + return k.kv.Put(key, value) +} + +func (k *KubeKV) Get(key string) (value []byte, err error) { + value, err = k.kv.Get(key) + if err != nil { + if err == kv.ErrNotFound { + return []byte(""), cache.ErrNotFound + } + + } + return +} + +func (k *KubeKV) Delete(key string) error { + return k.kv.Delete(key) +} + +func (k *KubeKV) List(prefix string) (map[string][]byte, error) { + return k.kv.List(prefix) +} diff --git a/cache/memory/memory.go b/cache/memory/memory.go new file mode 100644 index 00000000..0cb59c80 --- /dev/null +++ b/cache/memory/memory.go @@ -0,0 +1,209 @@ +package memory + +import ( + "fmt" + "strings" + "time" + + "github.com/rusenask/keel/cache" +) + +type requestType int + +// Request types +const ( + GET requestType = iota + SET + DELETE + EXPIRE + COPY +) + +type ( + // Value - value is stored together with access and creation time + Value struct { + ctime time.Time + atime time.Time + value []byte + } + + // Cache - cache container with a map of values and defaults + Cache struct { + cache map[string]*Value + ctimeExpiry time.Duration // creation time + atimeExpiry time.Duration // access time + expiryTick time.Duration + requestChannel chan *request + } + + request struct { + requestType + key string + value []byte + responseChannel chan *response + } + response struct { + error + existingValue []byte + mapCopy map[string][]byte + value []byte + } +) + +func (c *Cache) isOld(v *Value) bool { + if (c.ctimeExpiry != time.Duration(0)) && (time.Now().Sub(v.ctime) > c.ctimeExpiry) { + return true + } + + if (c.atimeExpiry != time.Duration(0)) && (time.Now().Sub(v.atime) > c.atimeExpiry) { + return true + } + + return false +} + +// NewMemoryCache - creates new cache +func NewMemoryCache(ctimeExpiry, atimeExpiry, expiryTick time.Duration) *Cache { + c := &Cache{ + cache: make(map[string]*Value), + ctimeExpiry: ctimeExpiry, + atimeExpiry: atimeExpiry, + expiryTick: expiryTick, + requestChannel: make(chan *request), + } + go c.service() + if ctimeExpiry != time.Duration(0) || atimeExpiry != time.Duration(0) { + go c.expiryService() + } + return c +} + +func (c *Cache) service() { + for { + req := <-c.requestChannel + resp := &response{} + switch req.requestType { + case GET: + val, ok := c.cache[req.key] + if !ok { + resp.error = cache.ErrNotFound + } else if c.isOld(val) { + resp.error = cache.ErrExpired + delete(c.cache, req.key) + } else { + // update atime + val.atime = time.Now() + c.cache[req.key] = val + resp.value = val.value + } + req.responseChannel <- resp + case SET: + c.cache[req.key] = &Value{ + value: req.value, + ctime: time.Now(), + atime: time.Now(), + } + req.responseChannel <- resp + case DELETE: + delete(c.cache, req.key) + req.responseChannel <- resp + case EXPIRE: + for k, v := range c.cache { + if c.isOld(v) { + delete(c.cache, k) + } + } + // no response + case COPY: + resp.mapCopy = make(map[string][]byte) + for k, v := range c.cache { + resp.mapCopy[k] = v.value + } + req.responseChannel <- resp + default: + resp.error = fmt.Errorf("invalid request type: %v", req.requestType) + req.responseChannel <- resp + } + } +} + +// Get - looks up value and returns it +func (c *Cache) Get(key string) ([]byte, error) { + respChannel := make(chan *response) + c.requestChannel <- &request{ + requestType: GET, + key: key, + responseChannel: respChannel, + } + resp := <-respChannel + return resp.value, resp.error +} + +// Put - sets key/string. Overwrites existing key +func (c *Cache) Put(key string, value []byte) error { + respChannel := make(chan *response) + c.requestChannel <- &request{ + requestType: SET, + key: key, + value: value, + responseChannel: respChannel, + } + resp := <-respChannel + return resp.error +} + +// Delete - deletes key +func (c *Cache) Delete(key string) error { + respChannel := make(chan *response) + c.requestChannel <- &request{ + requestType: DELETE, + key: key, + responseChannel: respChannel, + } + resp := <-respChannel + return resp.error +} + +// List all values for specified prefix +func (c *Cache) List(prefix string) (map[string][]byte, error) { + respChannel := make(chan *response) + c.requestChannel <- &request{ + requestType: COPY, + responseChannel: respChannel, + } + resp := <-respChannel + + list := make(map[string][]byte) + + for k, v := range resp.mapCopy { + if strings.HasPrefix(k, prefix) { + list[k] = v + } + } + return list, nil +} + +// Copy - makes a copy of inmemory map +func (c *Cache) Copy() map[string][]byte { + respChannel := make(chan *response) + c.requestChannel <- &request{ + requestType: COPY, + responseChannel: respChannel, + } + resp := <-respChannel + return resp.mapCopy +} + +func (c *Cache) expiryService() { + ticker := time.NewTicker(c.expiryTick) + defer ticker.Stop() + + for { + select { + case <-ticker.C: + c.requestChannel <- &request{ + requestType: EXPIRE, + } + } + } +} diff --git a/cache/memory/memory_test.go b/cache/memory/memory_test.go new file mode 100644 index 00000000..733e5dca --- /dev/null +++ b/cache/memory/memory_test.go @@ -0,0 +1,83 @@ +package memory + +import ( + "log" + "testing" + "time" +) + +func TestCacheSetGet(t *testing.T) { + c := NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + + err := c.Put("a", []byte("b")) + if err != nil { + t.Errorf("failed to SET a key, got error: %s", err) + } + + val, err := c.Get("a") + if err != nil { + t.Errorf("failed to GET a key, got error: %s", err) + } + + if string(val) != "b" { + log.Panicf("value %v", val) + } + + cc := c.Copy() + if len(cc) != 1 { + t.Errorf("expected 1 item, got: %d", len(cc)) + } +} + +func TestCacheDel(t *testing.T) { + c := NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + + err := c.Put("a", []byte("b")) + if err != nil { + t.Errorf("failed to SET a key, got error: %s", err) + } + + val, err := c.Get("a") + if err != nil { + t.Errorf("failed to GET a key, got error: %s", err) + } + + if string(val) != "b" { + log.Panicf("value %v", val) + } + + err = c.Delete("a") + if err != nil { + t.Errorf("faield to delete entry, got error: %s", err) + } + + _, err = c.Get("a") + if err == nil { + t.Errorf("expected to get an error after deletion, but got nil") + } +} + +func TestCacheExpiration(t *testing.T) { + c := NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + + err := c.Put("a", []byte("b")) + if err != nil { + t.Errorf("failed to SET a key, got error: %s", err) + } + + val, err := c.Get("a") + if err != nil { + t.Errorf("failed to GET a key, got error: %s", err) + } + + if string(val) != "b" { + log.Panicf("value %v", val) + } + + time.Sleep(200 * time.Millisecond) + + _, err = c.Get("a") + if err == nil { + t.Errorf("expected to get an error after deletion, but got nil") + } +} diff --git a/constants/constants.go b/constants/constants.go index 833c94a9..e18be1da 100644 --- a/constants/constants.go +++ b/constants/constants.go @@ -3,6 +3,9 @@ package constants // DefaultDockerRegistry - default docker registry const DefaultDockerRegistry = "https://index.docker.io" +// DefaultNamespace - default namespace to initialise configmaps based kv +const DefaultNamespace = "kube-system" + // WebhookEndpointEnv if set - enables webhook notifications const WebhookEndpointEnv = "WEBHOOK_ENDPOINT" diff --git a/extension/approval/approval_collector.go b/extension/approval/approval_collector.go new file mode 100644 index 00000000..db3f5648 --- /dev/null +++ b/extension/approval/approval_collector.go @@ -0,0 +1,96 @@ +package approval + +import ( + "sync" + + "github.com/rusenask/keel/approvals" + + log "github.com/Sirupsen/logrus" +) + +var ( + collectorsM sync.RWMutex + collectors = make(map[string]Collector) +) + +// Collector - generic interface for implementing approval mechanisms +type Collector interface { + Configure(approvalsManager approvals.Manager) (bool, error) +} + +func RegisterCollector(name string, c Collector) { + if name == "" { + panic("approval collector:: could not register a Sender with an empty name") + } + + if c == nil { + panic("approval collector:: could not register a nil Sender") + } + + collectorsM.Lock() + defer collectorsM.Unlock() + + if _, dup := collectors[name]; dup { + panic("approval collector: RegisterCollector called twice for " + name) + } + + log.WithFields(log.Fields{ + "name": name, + }).Info("approval.RegisterCollector: collector registered") + + collectors[name] = c +} + +// MainCollector holds all registered collectors +type MainCollector struct { + approvalsManager approvals.Manager +} + +// New - create new sender +func New() *MainCollector { + return &MainCollector{} +} + +// Configure - configure is used to register multiple notification senders +func (m *MainCollector) Configure(approvalsManager approvals.Manager) (bool, error) { + m.approvalsManager = approvalsManager + // Configure registered notifiers. + for collectorName, collector := range m.Collectors() { + if configured, err := collector.Configure(approvalsManager); configured { + log.WithFields(log.Fields{ + "name": collectorName, + }).Info("extension.approval.Configure: collector configured") + } else { + m.UnregisterCollector(collectorName) + if err != nil { + log.WithFields(log.Fields{ + "name": collectorName, + "error": err, + }).Error("extension.approval.Configure: could not configure collector") + } + } + } + + return true, nil +} + +// Collectors returns the list of the registered Collectors. +func (m *MainCollector) Collectors() map[string]Collector { + collectorsM.RLock() + defer collectorsM.RUnlock() + + ret := make(map[string]Collector) + for k, v := range collectors { + ret[k] = v + } + + return ret +} + +// UnregisterCollector removes a Collector with a particular name from the list. +func (m *MainCollector) UnregisterCollector(name string) { + collectorsM.Lock() + defer collectorsM.Unlock() + + delete(collectors, name) +} diff --git a/glide.lock b/glide.lock index ea76c9bf..9135287d 100644 --- a/glide.lock +++ b/glide.lock @@ -1,5 +1,5 @@ -hash: 4f5cf366af304cb50b974df8ea9c020057f1d3b2bf1d1f9bd462a1e436c4f13b -updated: 2017-08-04T22:06:13.059396344+01:00 +hash: 7745d67060c2a5cdcec48b6caad7fe970628b1a8cf19496cce7060f9ede1421a +updated: 2017-09-12T19:36:03.621062651+03:00 imports: - name: cloud.google.com/go version: b4e9a381a01e953e880e6d2cf7fd02d412977cae @@ -75,11 +75,11 @@ imports: - name: github.com/google/gofuzz version: 44d81051d367757e1c7c6a5a86423ece9afcf63c - name: github.com/googleapis/gax-go - version: 84ed26760e7f6f80887a2fbfb50db3cc415d2cea + version: 8c160ca1523d8eea3932fbaa494c8964b7724aa8 - name: github.com/gorilla/context version: 08b5f424b9271eedf6f9f0ce86cb9396ed337a42 - name: github.com/gorilla/mux - version: bcd8bc72b08df0f70df986b97f95590779502d31 + version: 24fca303ac6da784b9e8269f724ddeb0b2eea5e7 - name: github.com/howeyc/gopass version: 3ca23474a7c7203e0a0a070fd33508f6efdb9b3d - name: github.com/imdario/mergo @@ -108,8 +108,16 @@ imports: version: 315973e9173738626b8c81cb39ba247f8cb190e5 subpackages: - registry +- name: github.com/rusenask/k8s-kv + version: 5a87a1fe426104552279cfe8e8de6b48e537a2d9 + subpackages: + - kv - name: github.com/Sirupsen/logrus - version: 181d419aa9e2223811b824e8f0b4af96f9ba9302 + version: 89742aefa4b206dcf400792f3bd35b542998eb3b + repo: https://github.com/sirupsen/logrus.git + vcs: git +- name: github.com/sirupsen/logrus + version: 89742aefa4b206dcf400792f3bd35b542998eb3b - name: github.com/spf13/pflag version: 9ff6c6923cfffbcd502984b8e0c80539a94968b7 - name: github.com/ugorji/go @@ -119,7 +127,7 @@ imports: - name: github.com/urfave/negroni version: fde5e16d32adc7ad637e9cd9ad21d4ebc6192535 - name: golang.org/x/crypto - version: 42ff06aea7c329876e5a0fe94acc96902accf0ad + version: 88e95fbb56610f02dbc78ebc3b207bec8cf56b86 subpackages: - ssh/terminal - name: golang.org/x/net @@ -191,7 +199,7 @@ imports: - socket - urlfetch - name: google.golang.org/genproto - version: 09f6ed296fc66555a25fe4ce95173148778dfa85 + version: 595979c8a7bf586b2d293fb42246bf91a0b893d9 subpackages: - googleapis/api/annotations - googleapis/iam/v1 @@ -345,7 +353,7 @@ imports: - util/homedir - util/integer - name: k8s.io/helm - version: 7cf31e8d9a026287041bae077b09165be247ae66 + version: bbc1f71dc03afc5f00c6ac84b9308f8ecb4f39ac subpackages: - pkg/chartutil - pkg/helm diff --git a/glide.yaml b/glide.yaml index 115128e8..333237c8 100644 --- a/glide.yaml +++ b/glide.yaml @@ -12,7 +12,12 @@ import: - internal - package: github.com/Masterminds/semver version: ^1.3.1 +- package: github.com/sirupsen/logrus + version: master - package: github.com/Sirupsen/logrus + repo: https://github.com/sirupsen/logrus.git + vcs: git + version: master - package: github.com/docker/distribution version: ^2.6.2 subpackages: diff --git a/main.go b/main.go index 02a8b8c4..cf89196e 100644 --- a/main.go +++ b/main.go @@ -9,7 +9,10 @@ import ( netContext "golang.org/x/net/context" + "github.com/rusenask/keel/approvals" "github.com/rusenask/keel/bot" + "github.com/rusenask/keel/cache/kubekv" + "github.com/rusenask/keel/constants" "github.com/rusenask/keel/extension/notification" "github.com/rusenask/keel/provider" @@ -21,6 +24,7 @@ import ( "github.com/rusenask/keel/trigger/poll" "github.com/rusenask/keel/trigger/pubsub" "github.com/rusenask/keel/types" + "github.com/rusenask/keel/util/codecs" "github.com/rusenask/keel/version" // extensions @@ -36,6 +40,8 @@ const ( EnvTriggerPoll = "POLL" // set to 1 or something to enable poll trigger EnvProjectID = "PROJECT_ID" + EnvNamespace = "NAMESPACE" // Keel's namespace + EnvHelmProvider = "HELM_PROVIDER" // helm provider EnvHelmTillerAddress = "TILLER_ADDRESS" // helm provider ) @@ -58,7 +64,7 @@ func main() { "version": ver.Version, "go_version": ver.GoVersion, "arch": ver.Arch, - }).Info("keel starting..") + }).Info("keel starting...") if os.Getenv(EnvDebug) != "" { log.SetLevel(log.DebugLevel) @@ -95,14 +101,33 @@ func main() { }).Fatal("main: failed to create kubernetes implementer") } + keelsNamespace := constants.DefaultNamespace + if os.Getenv(EnvNamespace) != "" { + keelsNamespace = os.Getenv(EnvNamespace) + } + + kkv, err := kubekv.New(implementer.ConfigMaps(keelsNamespace), "approvals") + if err != nil { + log.WithFields(log.Fields{ + "error": err, + "namespace": keelsNamespace, + }).Fatal("main: failed to initialise kube-kv") + } + + serializer := codecs.DefaultSerializer() + // mem := memory.NewMemoryCache(24*time.Hour, 24*time.Hour, 1*time.Minute) + approvalsManager := approvals.New(kkv, serializer) + + go approvalsManager.StartExpiryService(ctx) + // setting up providers - providers := setupProviders(implementer, sender) + providers := setupProviders(implementer, sender, approvalsManager) secretsGetter := secrets.NewGetter(implementer) - teardownTriggers := setupTriggers(ctx, providers, secretsGetter) + teardownTriggers := setupTriggers(ctx, providers, secretsGetter, approvalsManager) - teardownBot, err := setupBot(implementer) + teardownBot, err := setupBot(implementer, approvalsManager) if err != nil { log.WithFields(log.Fields{ "error": err, @@ -141,10 +166,10 @@ func main() { // setupProviders - setting up available providers. New providers should be initialised here and added to // provider map -func setupProviders(k8sImplementer kubernetes.Implementer, sender notification.Sender) (providers provider.Providers) { +func setupProviders(k8sImplementer kubernetes.Implementer, sender notification.Sender, approvalsManager approvals.Manager) (providers provider.Providers) { var enabledProviders []provider.Provider - k8sProvider, err := kubernetes.NewProvider(k8sImplementer, sender) + k8sProvider, err := kubernetes.NewProvider(k8sImplementer, sender, approvalsManager) if err != nil { log.WithFields(log.Fields{ "error": err, @@ -156,18 +181,18 @@ func setupProviders(k8sImplementer kubernetes.Implementer, sender notification.S if os.Getenv(EnvHelmProvider) == "1" { tillerAddr := os.Getenv(EnvHelmTillerAddress) helmImplementer := helm.NewHelmImplementer(tillerAddr) - helmProvider := helm.NewProvider(helmImplementer, sender) + helmProvider := helm.NewProvider(helmImplementer, sender, approvalsManager) go helmProvider.Start() enabledProviders = append(enabledProviders, helmProvider) } - providers = provider.New(enabledProviders) + providers = provider.New(enabledProviders, approvalsManager) return providers } -func setupBot(k8sImplementer kubernetes.Implementer) (teardown func(), err error) { +func setupBot(k8sImplementer kubernetes.Implementer, approvalsManager approvals.Manager) (teardown func(), err error) { if os.Getenv(constants.EnvSlackToken) != "" { botName := "keel" @@ -177,7 +202,7 @@ func setupBot(k8sImplementer kubernetes.Implementer) (teardown func(), err error } token := os.Getenv(constants.EnvSlackToken) - slackBot := bot.New(botName, token, k8sImplementer) + slackBot := bot.New(botName, token, k8sImplementer, approvalsManager) ctx, cancel := context.WithCancel(context.Background()) @@ -200,12 +225,13 @@ func setupBot(k8sImplementer kubernetes.Implementer) (teardown func(), err error // setupTriggers - setting up triggers. New triggers should be added to this function. Each trigger // should go through all providers (or not if there is a reason) and submit events) -func setupTriggers(ctx context.Context, providers provider.Providers, secretsGetter secrets.Getter) (teardown func()) { +func setupTriggers(ctx context.Context, providers provider.Providers, secretsGetter secrets.Getter, approvalsManager approvals.Manager) (teardown func()) { // setting up generic http webhook server whs := http.NewTriggerServer(&http.Opts{ - Port: types.KeelDefaultPort, - Providers: providers, + Port: types.KeelDefaultPort, + Providers: providers, + ApprovalManager: approvalsManager, }) go whs.Start() diff --git a/provider/helm/approvals.go b/provider/helm/approvals.go new file mode 100644 index 00000000..701cac6f --- /dev/null +++ b/provider/helm/approvals.go @@ -0,0 +1,75 @@ +package helm + +import ( + "fmt" + "time" + + "github.com/rusenask/keel/cache" + "github.com/rusenask/keel/types" + + log "github.com/Sirupsen/logrus" +) + +// namespace/release name/version +func getIdentifier(namespace, name, version string) string { + return namespace + "/" + name + ":" + version +} + +func (p *Provider) checkForApprovals(event *types.Event, plans []*UpdatePlan) (approvedPlans []*UpdatePlan) { + approvedPlans = []*UpdatePlan{} + for _, plan := range plans { + approved, err := p.isApproved(event, plan) + if err != nil { + log.WithFields(log.Fields{ + "error": err, + "release_name": plan.Name, + "namespace": plan.Namespace, + }).Error("provider.helm: failed to check approval status for deployment") + continue + } + if approved { + approvedPlans = append(approvedPlans, plan) + } + } + return approvedPlans +} + +func (p *Provider) isApproved(event *types.Event, plan *UpdatePlan) (bool, error) { + if plan.Config.Approvals == 0 { + return true, nil + } + + identifier := getIdentifier(plan.Namespace, plan.Name, plan.NewVersion) + + // checking for existing approval + existing, err := p.approvalManager.Get(identifier) + if err != nil { + if err == cache.ErrNotFound { + + // creating new one + approval := &types.Approval{ + Provider: types.ProviderTypeHelm, + Identifier: identifier, + Event: event, + CurrentVersion: plan.CurrentVersion, + NewVersion: plan.NewVersion, + VotesRequired: plan.Config.Approvals, + VotesReceived: 0, + Rejected: false, + Deadline: time.Now().Add(time.Duration(plan.Config.ApprovalDeadline) * time.Hour), + } + + approval.Message = fmt.Sprintf("New image is available for release %s/%s (%s).", + plan.Namespace, + plan.Name, + approval.Delta(), + ) + + return false, p.approvalManager.Create(approval) + } + + return false, err + } + + return existing.Status() == types.ApprovalStatusApproved, nil +} diff --git a/provider/helm/helm.go b/provider/helm/helm.go index 5db58b00..c1285ce1 100644 --- a/provider/helm/helm.go +++ b/provider/helm/helm.go @@ -5,6 +5,7 @@ import ( "strings" "time" + "github.com/rusenask/keel/approvals" "github.com/rusenask/keel/types" "github.com/rusenask/keel/util/image" "github.com/rusenask/keel/util/version" @@ -37,11 +38,18 @@ type UpdatePlan struct { Namespace string Name string + Config *KeelChartConfig + // chart Chart *hapi_chart.Chart // values to update path=value Values map[string]string + + // Current (last seen cluster version) + CurrentVersion string + // New version that's already in the deployment + NewVersion string } // keel: @@ -62,10 +70,12 @@ type Root struct { // KeelChartConfig - keel related configuration taken from values.yaml type KeelChartConfig struct { - Policy types.PolicyType `json:"policy"` - Trigger types.TriggerType `json:"trigger"` - PollSchedule string `json:"pollSchedule"` - Images []ImageDetails `json:"images"` + Policy types.PolicyType `json:"policy"` + Trigger types.TriggerType `json:"trigger"` + PollSchedule string `json:"pollSchedule"` + Approvals int `json:"approvals"` // Minimum required approvals + ApprovalDeadline int `json:"approvalDeadline"` // Deadline in hours + Images []ImageDetails `json:"images"` } // ImageDetails - image details @@ -80,17 +90,20 @@ type Provider struct { sender notification.Sender + approvalManager approvals.Manager + events chan *types.Event stop chan struct{} } // NewProvider - create new Helm provider -func NewProvider(implementer Implementer, sender notification.Sender) *Provider { +func NewProvider(implementer Implementer, sender notification.Sender, approvalManager approvals.Manager) *Provider { return &Provider{ - implementer: implementer, - sender: sender, - events: make(chan *types.Event, 100), - stop: make(chan struct{}), + implementer: implementer, + approvalManager: approvalManager, + sender: sender, + events: make(chan *types.Event, 100), + stop: make(chan struct{}), } } @@ -206,7 +219,9 @@ func (p *Provider) processEvent(event *types.Event) (err error) { return err } - return p.applyPlans(plans) + approved := p.checkForApprovals(event, plans) + + return p.applyPlans(approved) } func (p *Provider) createUpdatePlans(event *types.Event) ([]*UpdatePlan, error) { @@ -228,7 +243,7 @@ func (p *Provider) createUpdatePlans(event *types.Event) ([]*UpdatePlan, error) "error": err, "deployment": release.Name, "namespace": release.Namespace, - }).Error("provider.kubernetes: got error while checking unversioned release") + }).Error("provider.helm: got error while checking unversioned release") continue } @@ -266,7 +281,7 @@ func (p *Provider) applyPlans(plans []*UpdatePlan) error { p.sender.Send(types.EventNotification{ Name: "update release", - Message: fmt.Sprintf("Preparing to update release %s/%s (%s)", plan.Namespace, plan.Name, strings.Join(mapToSlice(plan.Values), ", ")), + Message: fmt.Sprintf("Preparing to update release %s/%s %s->%s (%s)", plan.Namespace, plan.Name, plan.CurrentVersion, plan.NewVersion, strings.Join(mapToSlice(plan.Values), ", ")), CreatedAt: time.Now(), Type: types.NotificationPreReleaseUpdate, Level: types.LevelDebug, @@ -282,7 +297,7 @@ func (p *Provider) applyPlans(plans []*UpdatePlan) error { p.sender.Send(types.EventNotification{ Name: "update release", - Message: fmt.Sprintf("Release update feailed %s/%s (%s), error: %s", plan.Namespace, plan.Name, strings.Join(mapToSlice(plan.Values), ", "), err), + Message: fmt.Sprintf("Release update feailed %s/%s %s->%s (%s), error: %s", plan.Namespace, plan.Name, plan.CurrentVersion, plan.NewVersion, strings.Join(mapToSlice(plan.Values), ", "), err), CreatedAt: time.Now(), Type: types.NotificationReleaseUpdate, Level: types.LevelError, @@ -292,7 +307,7 @@ func (p *Provider) applyPlans(plans []*UpdatePlan) error { p.sender.Send(types.EventNotification{ Name: "update release", - Message: fmt.Sprintf("Successfully updated release %s/%s (%s)", plan.Namespace, plan.Name, strings.Join(mapToSlice(plan.Values), ", ")), + Message: fmt.Sprintf("Successfully updated release %s/%s %s->%s (%s)", plan.Namespace, plan.Name, plan.CurrentVersion, plan.NewVersion, strings.Join(mapToSlice(plan.Values), ", ")), CreatedAt: time.Now(), Type: types.NotificationReleaseUpdate, Level: types.LevelSuccess, diff --git a/provider/helm/helm_test.go b/provider/helm/helm_test.go index aff1a0bb..7cd6cfb5 100644 --- a/provider/helm/helm_test.go +++ b/provider/helm/helm_test.go @@ -3,10 +3,14 @@ package helm import ( "reflect" "testing" + "time" "github.com/ghodss/yaml" + "github.com/rusenask/keel/approvals" + "github.com/rusenask/keel/cache/memory" "github.com/rusenask/keel/extension/notification" "github.com/rusenask/keel/types" + "github.com/rusenask/keel/util/codecs" "k8s.io/helm/pkg/chartutil" "k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/proto/hapi/chart" @@ -14,6 +18,12 @@ import ( rls "k8s.io/helm/pkg/proto/hapi/services" ) +func approver() *approvals.DefaultManager { + cache := memory.NewMemoryCache(10*time.Minute, 10*time.Minute, 10*time.Minute) + + return approvals.New(cache, codecs.DefaultSerializer()) +} + type fakeSender struct { sentEvent types.EventNotification } @@ -166,7 +176,7 @@ keel: }, } - prov := NewProvider(fakeImpl, &fakeSender{}) + prov := NewProvider(fakeImpl, &fakeSender{}, approver()) tracked, _ := prov.TrackedImages() @@ -214,7 +224,7 @@ keel: }, } - prov := NewProvider(fakeImpl, &fakeSender{}) + prov := NewProvider(fakeImpl, &fakeSender{}, approver()) tracked, _ := prov.TrackedImages() @@ -316,7 +326,7 @@ keel: }, } - provider := NewProvider(fakeImpl, &fakeSender{}) + provider := NewProvider(fakeImpl, &fakeSender{}, approver()) err := provider.processEvent(&types.Event{ Repository: types.Repository{ diff --git a/provider/helm/implementer.go b/provider/helm/implementer.go index 88ae41c3..50476316 100644 --- a/provider/helm/implementer.go +++ b/provider/helm/implementer.go @@ -4,6 +4,8 @@ import ( "k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/proto/hapi/chart" rls "k8s.io/helm/pkg/proto/hapi/services" + + log "github.com/Sirupsen/logrus" ) // TillerAddress - default tiller address @@ -26,6 +28,8 @@ type HelmImplementer struct { func NewHelmImplementer(address string) *HelmImplementer { if address == "" { address = TillerAddress + } else { + log.Infof("provider.helm: tiller address '%s' supplied", address) } return &HelmImplementer{ diff --git a/provider/helm/unversioned_updates.go b/provider/helm/unversioned_updates.go index 49db5089..52fe5e82 100644 --- a/provider/helm/unversioned_updates.go +++ b/provider/helm/unversioned_updates.go @@ -73,6 +73,9 @@ func checkUnversionedRelease(repo *types.Repository, namespace, name string, cha path, value := getUnversionedPlanValues(repo.Tag, imageRef, &imageDetails) plan.Values[path] = value + plan.NewVersion = repo.Tag + plan.CurrentVersion = imageRef.Tag() + plan.Config = keelCfg shouldUpdateRelease = true } diff --git a/provider/helm/unversioned_updates_test.go b/provider/helm/unversioned_updates_test.go index f56cdf18..2f5923cd 100644 --- a/provider/helm/unversioned_updates_test.go +++ b/provider/helm/unversioned_updates_test.go @@ -77,10 +77,23 @@ keel: config: &hapi_chart.Config{Raw: ""}, }, wantPlan: &UpdatePlan{ - Namespace: "default", - Name: "release-1", - Chart: helloWorldChart, - Values: map[string]string{"image.tag": "latest"}}, + Namespace: "default", + Name: "release-1", + Chart: helloWorldChart, + Values: map[string]string{"image.tag": "latest"}, + CurrentVersion: "1.1.0", + NewVersion: "latest", + Config: &KeelChartConfig{ + Policy: types.PolicyTypeForce, + Trigger: types.TriggerTypePoll, + Images: []ImageDetails{ + ImageDetails{ + RepositoryPath: "image.repository", + TagPath: "image.tag", + }, + }, + }, + }, wantShouldUpdateRelease: true, wantErr: false, }, diff --git a/provider/helm/versioned_updates.go b/provider/helm/versioned_updates.go index aa2c7f8b..1aaee5d4 100644 --- a/provider/helm/versioned_updates.go +++ b/provider/helm/versioned_updates.go @@ -69,7 +69,9 @@ func checkVersionedRelease(newVersion *types.Version, repo *types.Repository, na if keelCfg.Policy == types.PolicyTypeForce || imageRef.Tag() == "latest" { path, value := getPlanValues(newVersion, imageRef, &imageDetails) plan.Values[path] = value - + plan.NewVersion = newVersion.String() + plan.CurrentVersion = imageRef.Tag() + plan.Config = keelCfg shouldUpdateRelease = true log.WithFields(log.Fields{ @@ -125,7 +127,9 @@ func checkVersionedRelease(newVersion *types.Version, repo *types.Repository, na if shouldUpdate { path, value := getPlanValues(newVersion, imageRef, &imageDetails) plan.Values[path] = value - + plan.NewVersion = newVersion.String() + plan.CurrentVersion = currentVersion.String() + plan.Config = keelCfg shouldUpdateRelease = true log.WithFields(log.Fields{ diff --git a/provider/helm/versioned_updates_test.go b/provider/helm/versioned_updates_test.go index f8ea471e..883fb132 100644 --- a/provider/helm/versioned_updates_test.go +++ b/provider/helm/versioned_updates_test.go @@ -139,7 +139,21 @@ image: chart: helloWorldChart, config: &hapi_chart.Config{Raw: ""}, }, - wantPlan: &UpdatePlan{Namespace: "default", Name: "release-1", Chart: helloWorldChart, Values: map[string]string{"image.tag": "1.1.2"}}, + wantPlan: &UpdatePlan{ + Namespace: "default", + Name: "release-1", + Chart: helloWorldChart, + Values: map[string]string{"image.tag": "1.1.2"}, + NewVersion: "1.1.2", + CurrentVersion: "1.1.0", + Config: &KeelChartConfig{ + Policy: types.PolicyTypeAll, + Trigger: types.TriggerTypePoll, + Images: []ImageDetails{ + ImageDetails{RepositoryPath: "image.repository", TagPath: "image.tag"}, + }, + }, + }, wantShouldUpdateRelease: true, wantErr: false, }, @@ -181,7 +195,21 @@ image: chart: helloWorldNonSemverChart, config: &hapi_chart.Config{Raw: ""}, }, - wantPlan: &UpdatePlan{Namespace: "default", Name: "release-1", Chart: helloWorldNonSemverChart, Values: map[string]string{"image.tag": "1.1.0"}}, + wantPlan: &UpdatePlan{ + Namespace: "default", + Name: "release-1", + Chart: helloWorldNonSemverChart, + Values: map[string]string{"image.tag": "1.1.0"}, + NewVersion: "1.1.0", + CurrentVersion: "alpha", + Config: &KeelChartConfig{ + Policy: types.PolicyTypeForce, + Trigger: types.TriggerTypePoll, + Images: []ImageDetails{ + ImageDetails{RepositoryPath: "image.repository", TagPath: "image.tag"}, + }, + }, + }, wantShouldUpdateRelease: true, wantErr: false, }, @@ -209,7 +237,21 @@ image: chart: helloWorldNoTagChart, config: &hapi_chart.Config{Raw: ""}, }, - wantPlan: &UpdatePlan{Namespace: "default", Name: "release-1-no-tag", Chart: helloWorldNoTagChart, Values: map[string]string{"image.repository": "gcr.io/v2-namespace/hello-world:1.1.0"}}, + wantPlan: &UpdatePlan{ + Namespace: "default", + Name: "release-1-no-tag", + Chart: helloWorldNoTagChart, + Values: map[string]string{"image.repository": "gcr.io/v2-namespace/hello-world:1.1.0"}, + NewVersion: "1.1.0", + CurrentVersion: "1.0.0", + Config: &KeelChartConfig{ + Policy: types.PolicyTypeMajor, + Trigger: types.TriggerTypePoll, + Images: []ImageDetails{ + ImageDetails{RepositoryPath: "image.repository"}, + }, + }, + }, wantShouldUpdateRelease: true, wantErr: false, }, diff --git a/provider/kubernetes/approvals.go b/provider/kubernetes/approvals.go new file mode 100644 index 00000000..cc53f160 --- /dev/null +++ b/provider/kubernetes/approvals.go @@ -0,0 +1,102 @@ +package kubernetes + +import ( + "fmt" + "strconv" + "time" + + "github.com/rusenask/keel/cache" + "github.com/rusenask/keel/types" + + log "github.com/Sirupsen/logrus" +) + +func getIdentifier(namespace, name, version string) string { + return namespace + "/" + name + ":" + version +} + +// checkForApprovals - filters out deployments and only passes forward approved ones +func (p *Provider) checkForApprovals(event *types.Event, plans []*UpdatePlan) (approvedPlans []*UpdatePlan) { + approvedPlans = []*UpdatePlan{} + for _, plan := range plans { + approved, err := p.isApproved(event, plan) + if err != nil { + log.WithFields(log.Fields{ + "error": err, + "deployment": plan.Deployment.Name, + "namespace": plan.Deployment.Namespace, + }).Error("provider.kubernetes: failed to check approval status for deployment") + continue + } + if approved { + approvedPlans = append(approvedPlans, plan) + } + } + return approvedPlans +} + +func (p *Provider) isApproved(event *types.Event, plan *UpdatePlan) (bool, error) { + labels := plan.Deployment.GetLabels() + + minApprovalsStr, ok := labels[types.KeelMinimumApprovalsLabel] + if !ok { + // no approvals required - passing + return true, nil + } + + minApprovals, err := strconv.Atoi(minApprovalsStr) + if err != nil { + return false, err + } + + if minApprovals == 0 { + return true, nil + } + + deadline := types.KeelApprovalDeadlineDefault + + // deadline + deadlineStr, ok := labels[types.KeelApprovalDeadlineLabel] + if ok { + d, err := strconv.Atoi(deadlineStr) + if err == nil { + deadline = d + } + } + + identifier := getIdentifier(plan.Deployment.Namespace, plan.Deployment.Name, plan.NewVersion) + + // checking for existing approval + existing, err := p.approvalManager.Get(identifier) + if err != nil { + if err == cache.ErrNotFound { + + // creating new one + approval := &types.Approval{ + Provider: types.ProviderTypeKubernetes, + Identifier: identifier, + Event: event, + CurrentVersion: plan.CurrentVersion, + NewVersion: plan.NewVersion, + VotesRequired: minApprovals, + VotesReceived: 0, + Rejected: false, + Deadline: time.Now().Add(time.Duration(deadline) * time.Hour), + } + + approval.Message = fmt.Sprintf("New image is available for deployment %s/%s (%s).", + plan.Deployment.Namespace, + plan.Deployment.Name, + approval.Delta(), + ) + + fmt.Println("requesting approval, ns: ", plan.Deployment.Namespace) + + return false, p.approvalManager.Create(approval) + } + + return false, err + } + + return existing.Status() == types.ApprovalStatusApproved, nil +} diff --git a/provider/kubernetes/approvals_test.go b/provider/kubernetes/approvals_test.go new file mode 100644 index 00000000..5dd5fc9c --- /dev/null +++ b/provider/kubernetes/approvals_test.go @@ -0,0 +1,153 @@ +package kubernetes + +import ( + "testing" + "time" + + "github.com/rusenask/keel/types" + + meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/pkg/api/v1" + "k8s.io/client-go/pkg/apis/extensions/v1beta1" +) + +func TestCheckRequestedApproval(t *testing.T) { + fp := &fakeImplementer{} + fp.namespaces = &v1.NamespaceList{ + Items: []v1.Namespace{ + v1.Namespace{ + meta_v1.TypeMeta{}, + meta_v1.ObjectMeta{Name: "xxxx"}, + v1.NamespaceSpec{}, + v1.NamespaceStatus{}, + }, + }, + } + fp.deploymentList = &v1beta1.DeploymentList{ + Items: []v1beta1.Deployment{ + v1beta1.Deployment{ + meta_v1.TypeMeta{}, + meta_v1.ObjectMeta{ + Name: "dep-1", + Namespace: "xxxx", + Labels: map[string]string{types.KeelPolicyLabel: "all", types.KeelMinimumApprovalsLabel: "1"}, + }, + v1beta1.DeploymentSpec{ + Template: v1.PodTemplateSpec{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + v1.Container{ + Image: "gcr.io/v2-namespace/hello-world:1.1.1", + }, + }, + }, + }, + }, + v1beta1.DeploymentStatus{}, + }, + }, + } + approver := approver() + provider, err := NewProvider(fp, &fakeSender{}, approver) + if err != nil { + t.Fatalf("failed to get provider: %s", err) + } + // creating "new version" event + repo := types.Repository{ + Name: "gcr.io/v2-namespace/hello-world", + Tag: "1.1.2", + } + + deps, err := provider.processEvent(&types.Event{Repository: repo}) + if err != nil { + t.Errorf("failed to get deployments: %s", err) + } + + if len(deps) != 0 { + t.Errorf("expected to find 0 updated deployment but found %d", len(deps)) + } + + // checking approvals + approval, err := provider.approvalManager.Get("xxxx/dep-1:1.1.2") + if err != nil { + t.Fatalf("failed to find approval, err: %s", err) + } + + if approval.Provider != types.ProviderTypeKubernetes { + t.Errorf("wrong provider: %s", approval.Provider) + } +} + +func TestApprovedCheck(t *testing.T) { + fp := &fakeImplementer{} + fp.namespaces = &v1.NamespaceList{ + Items: []v1.Namespace{ + v1.Namespace{ + meta_v1.TypeMeta{}, + meta_v1.ObjectMeta{Name: "xxxx"}, + v1.NamespaceSpec{}, + v1.NamespaceStatus{}, + }, + }, + } + fp.deploymentList = &v1beta1.DeploymentList{ + Items: []v1beta1.Deployment{ + v1beta1.Deployment{ + meta_v1.TypeMeta{}, + meta_v1.ObjectMeta{ + Name: "dep-1", + Namespace: "xxxx", + Labels: map[string]string{types.KeelPolicyLabel: "all", types.KeelMinimumApprovalsLabel: "1"}, + }, + v1beta1.DeploymentSpec{ + Template: v1.PodTemplateSpec{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + v1.Container{ + Image: "gcr.io/v2-namespace/hello-world:1.1.1", + }, + }, + }, + }, + }, + v1beta1.DeploymentStatus{}, + }, + }, + } + approver := approver() + provider, err := NewProvider(fp, &fakeSender{}, approver) + if err != nil { + t.Fatalf("failed to get provider: %s", err) + } + + // approving event + err = provider.approvalManager.Create(&types.Approval{ + Identifier: "xxxx/dep-1:1.1.2", + VotesReceived: 2, + VotesRequired: 2, + Deadline: time.Now().Add(10 * time.Second), + }) + if err != nil { + t.Fatalf("failed to create approval: %s", err) + } + + appr, _ := provider.approvalManager.Get("xxxx/dep-1:1.1.2") + if appr.Status() != types.ApprovalStatusApproved { + t.Fatalf("approval not approved") + } + + // creating "new version" event + repo := types.Repository{ + Name: "gcr.io/v2-namespace/hello-world", + Tag: "1.1.2", + } + + deps, err := provider.processEvent(&types.Event{Repository: repo}) + if err != nil { + t.Errorf("failed to get deployments: %s", err) + } + + if len(deps) != 1 { + t.Errorf("expected to find 1 updated deployment but found %d", len(deps)) + } +} diff --git a/provider/kubernetes/implementer.go b/provider/kubernetes/implementer.go index 0ed6d403..6543edee 100644 --- a/provider/kubernetes/implementer.go +++ b/provider/kubernetes/implementer.go @@ -5,6 +5,7 @@ import ( meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/client-go/kubernetes" + core_v1 "k8s.io/client-go/kubernetes/typed/core/v1" "k8s.io/client-go/pkg/api/v1" "k8s.io/client-go/pkg/apis/extensions/v1beta1" "k8s.io/client-go/rest" @@ -21,6 +22,7 @@ type Implementer interface { Update(deployment *v1beta1.Deployment) error Secret(namespace, name string) (*v1.Secret, error) Pods(namespace, labelSelector string) (*v1.PodList, error) + ConfigMaps(namespace string) core_v1.ConfigMapInterface } // KubernetesImplementer - default kubernetes client implementer, uses @@ -112,3 +114,8 @@ func (i *KubernetesImplementer) Secret(namespace, name string) (*v1.Secret, erro func (i *KubernetesImplementer) Pods(namespace, labelSelector string) (*v1.PodList, error) { return i.client.Pods(namespace).List(meta_v1.ListOptions{LabelSelector: labelSelector}) } + +// ConfigMaps - returns an interface to config maps for a specified namespace +func (i *KubernetesImplementer) ConfigMaps(namespace string) core_v1.ConfigMapInterface { + return i.client.ConfigMaps(namespace) +} diff --git a/provider/kubernetes/kubernetes.go b/provider/kubernetes/kubernetes.go index 19a0ee36..e911f03b 100644 --- a/provider/kubernetes/kubernetes.go +++ b/provider/kubernetes/kubernetes.go @@ -11,6 +11,7 @@ import ( "k8s.io/client-go/pkg/api/v1" "k8s.io/client-go/pkg/apis/extensions/v1beta1" + "github.com/rusenask/keel/approvals" "github.com/rusenask/keel/extension/notification" "github.com/rusenask/keel/types" "github.com/rusenask/keel/util/image" @@ -31,23 +32,36 @@ const forceUpdateImageAnnotation = "keel.sh/update-image" // forceUpdateResetTag - tag used to reset container to force pull image const forceUpdateResetTag = "0.0.0" +// UpdatePlan - deployment update plan +type UpdatePlan struct { + // Updated deployment version + Deployment v1beta1.Deployment + // Current (last seen cluster version) + CurrentVersion string + // New version that's already in the deployment + NewVersion string +} + // Provider - kubernetes provider for auto update type Provider struct { implementer Implementer sender notification.Sender + approvalManager approvals.Manager + events chan *types.Event stop chan struct{} } // NewProvider - create new kubernetes based provider -func NewProvider(implementer Implementer, sender notification.Sender) (*Provider, error) { +func NewProvider(implementer Implementer, sender notification.Sender, approvalManager approvals.Manager) (*Provider, error) { return &Provider{ - implementer: implementer, - events: make(chan *types.Event, 100), - stop: make(chan struct{}), - sender: sender, + implementer: implementer, + approvalManager: approvalManager, + events: make(chan *types.Event, 100), + stop: make(chan struct{}), + sender: sender, }, nil } @@ -101,7 +115,7 @@ func (p *Provider) TrackedImages() ([]*types.TrackedImage, error) { "schedule": schedule, "deployment": deployment.Name, "namespace": deployment.Namespace, - }).Error("trigger.poll.manager: failed to parse poll schedule, setting default schedule") + }).Error("provider.kubernetes: failed to parse poll schedule, setting default schedule") schedule = types.KeelPollDefaultSchedule } } else { @@ -165,24 +179,30 @@ func (p *Provider) startInternal() error { } func (p *Provider) processEvent(event *types.Event) (updated []*v1beta1.Deployment, err error) { - impacted, err := p.impactedDeployments(&event.Repository) + plans, err := p.createUpdatePlans(&event.Repository) if err != nil { return nil, err } - if len(impacted) == 0 { + if len(plans) == 0 { log.WithFields(log.Fields{ "image": event.Repository.Name, "tag": event.Repository.Tag, - }).Info("provider.kubernetes: no impacted deployments found for this event") + }).Info("provider.kubernetes: no plans for deployment updates found for this event") return } - return p.updateDeployments(impacted) + approvedPlans := p.checkForApprovals(event, plans) + + return p.updateDeployments(approvedPlans) } -func (p *Provider) updateDeployments(deployments []v1beta1.Deployment) (updated []*v1beta1.Deployment, err error) { - for _, deployment := range deployments { +// func (p *Provider) updateDeployments(deployments []v1beta1.Deployment) (updated []*v1beta1.Deployment, err error) { +func (p *Provider) updateDeployments(plans []*UpdatePlan) (updated []*v1beta1.Deployment, err error) { + // for _, deployment := range plans { + for _, plan := range plans { + + deployment := plan.Deployment reset, delta, err := checkForReset(deployment, p.implementer) if err != nil { @@ -227,7 +247,7 @@ func (p *Provider) updateDeployments(deployments []v1beta1.Deployment) (updated p.sender.Send(types.EventNotification{ Name: "preparing to update deployment after reset", - Message: fmt.Sprintf("Preparing to update deployment %s/%s (%s)", deployment.Namespace, deployment.Name, strings.Join(getImages(&refresh), ", ")), + Message: fmt.Sprintf("Preparing to update deployment %s/%s %s->%s (%s)", deployment.Namespace, deployment.Name, plan.CurrentVersion, plan.NewVersion, strings.Join(getImages(&refresh), ", ")), CreatedAt: time.Now(), Type: types.NotificationPreDeploymentUpdate, Level: types.LevelDebug, @@ -243,7 +263,7 @@ func (p *Provider) updateDeployments(deployments []v1beta1.Deployment) (updated p.sender.Send(types.EventNotification{ Name: "update deployment after", - Message: fmt.Sprintf("Deployment %s/%s update failed, error: %s", refresh.Namespace, refresh.Name, err), + Message: fmt.Sprintf("Deployment %s/%s update %s->%s failed, error: %s", refresh.Namespace, refresh.Name, plan.CurrentVersion, plan.NewVersion, err), CreatedAt: time.Now(), Type: types.NotificationDeploymentUpdate, Level: types.LevelError, @@ -253,7 +273,7 @@ func (p *Provider) updateDeployments(deployments []v1beta1.Deployment) (updated p.sender.Send(types.EventNotification{ Name: "update deployment after reset", - Message: fmt.Sprintf("Successfully updated deployment %s/%s (%s)", refresh.Namespace, refresh.Name, strings.Join(getImages(&refresh), ", ")), + Message: fmt.Sprintf("Successfully updated deployment %s/%s %s->%s (%s)", refresh.Namespace, refresh.Name, plan.CurrentVersion, plan.NewVersion, strings.Join(getImages(&refresh), ", ")), CreatedAt: time.Now(), Type: types.NotificationDeploymentUpdate, Level: types.LevelSuccess, @@ -267,7 +287,7 @@ func (p *Provider) updateDeployments(deployments []v1beta1.Deployment) (updated p.sender.Send(types.EventNotification{ Name: "preparing to update deployment", - Message: fmt.Sprintf("Preparing to update deployment %s/%s (%s)", deployment.Namespace, deployment.Name, strings.Join(getImages(&deployment), ", ")), + Message: fmt.Sprintf("Preparing to update deployment %s/%s %s->%s (%s)", deployment.Namespace, deployment.Name, plan.CurrentVersion, plan.NewVersion, strings.Join(getImages(&deployment), ", ")), CreatedAt: time.Now(), Type: types.NotificationPreDeploymentUpdate, Level: types.LevelDebug, @@ -283,7 +303,7 @@ func (p *Provider) updateDeployments(deployments []v1beta1.Deployment) (updated p.sender.Send(types.EventNotification{ Name: "update deployment", - Message: fmt.Sprintf("Deployment %s/%s update failed, error: %s", deployment.Namespace, deployment.Name, err), + Message: fmt.Sprintf("Deployment %s/%s update %s->%s failed, error: %s", deployment.Namespace, deployment.Name, plan.CurrentVersion, plan.NewVersion, err), CreatedAt: time.Now(), Type: types.NotificationDeploymentUpdate, Level: types.LevelError, @@ -294,7 +314,7 @@ func (p *Provider) updateDeployments(deployments []v1beta1.Deployment) (updated p.sender.Send(types.EventNotification{ Name: "update deployment", - Message: fmt.Sprintf("Successfully updated deployment %s/%s (%s)", deployment.Namespace, deployment.Name, strings.Join(getImages(&deployment), ", ")), + Message: fmt.Sprintf("Successfully updated deployment %s/%s %s->%s (%s)", deployment.Namespace, deployment.Name, plan.CurrentVersion, plan.NewVersion, strings.Join(getImages(&deployment), ", ")), CreatedAt: time.Now(), Type: types.NotificationDeploymentUpdate, Level: types.LevelSuccess, @@ -402,8 +422,9 @@ func (p *Provider) getDeployment(namespace, name string) (*v1beta1.Deployment, e return p.implementer.Deployment(namespace, name) } -// gets impacted deployments by changed repository -func (p *Provider) impactedDeployments(repo *types.Repository) ([]v1beta1.Deployment, error) { +// createUpdatePlans - impacted deployments by changed repository +// func (p *Provider) impactedDeployments(repo *types.Repository) ([]v1beta1.Deployment, error) { +func (p *Provider) createUpdatePlans(repo *types.Repository) ([]*UpdatePlan, error) { deploymentLists, err := p.deployments() if err != nil { @@ -413,7 +434,8 @@ func (p *Provider) impactedDeployments(repo *types.Repository) ([]v1beta1.Deploy return nil, err } - impacted := []v1beta1.Deployment{} + // impacted := []v1beta1.Deployment{} + impacted := []*UpdatePlan{} for _, deploymentList := range deploymentLists { for _, deployment := range deploymentList.Items { diff --git a/provider/kubernetes/kubernetes_test.go b/provider/kubernetes/kubernetes_test.go index f8725c01..1a2c6dd0 100644 --- a/provider/kubernetes/kubernetes_test.go +++ b/provider/kubernetes/kubernetes_test.go @@ -2,15 +2,43 @@ package kubernetes import ( "testing" + "time" + "github.com/rusenask/keel/approvals" + "github.com/rusenask/keel/cache/memory" "github.com/rusenask/keel/extension/notification" "github.com/rusenask/keel/types" + "github.com/rusenask/keel/util/codecs" meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + core_v1 "k8s.io/client-go/kubernetes/typed/core/v1" "k8s.io/client-go/pkg/api/v1" "k8s.io/client-go/pkg/apis/extensions/v1beta1" ) +type fakeProvider struct { + submitted []types.Event + images []*types.TrackedImage +} + +func (p *fakeProvider) Submit(event types.Event) error { + p.submitted = append(p.submitted, event) + return nil +} + +func (p *fakeProvider) TrackedImages() ([]*types.TrackedImage, error) { + return p.images, nil +} +func (p *fakeProvider) List() []string { + return []string{"fakeprovider"} +} +func (p *fakeProvider) Stop() { + return +} +func (p *fakeProvider) GetName() string { + return "fp" +} + type fakeImplementer struct { namespaces *v1.NamespaceList deployment *v1beta1.Deployment @@ -49,6 +77,10 @@ func (i *fakeImplementer) Pods(namespace, labelSelector string) (*v1.PodList, er return i.podList, nil } +func (i *fakeImplementer) ConfigMaps(namespace string) core_v1.ConfigMapInterface { + return nil +} + type fakeSender struct { sentEvent types.EventNotification } @@ -62,6 +94,12 @@ func (s *fakeSender) Send(event types.EventNotification) error { return nil } +func approver() *approvals.DefaultManager { + cache := memory.NewMemoryCache(10*time.Minute, 10*time.Minute, 10*time.Minute) + + return approvals.New(cache, codecs.DefaultSerializer()) +} + func TestGetNamespaces(t *testing.T) { fi := &fakeImplementer{ namespaces: &v1.NamespaceList{ @@ -76,7 +114,7 @@ func TestGetNamespaces(t *testing.T) { }, } - provider, err := NewProvider(fi, &fakeSender{}) + provider, err := NewProvider(fi, &fakeSender{}, approver()) if err != nil { t.Fatalf("failed to get provider: %s", err) } @@ -135,7 +173,7 @@ func TestGetDeployments(t *testing.T) { }, } - provider, err := NewProvider(fp, &fakeSender{}) + provider, err := NewProvider(fp, &fakeSender{}, approver()) if err != nil { t.Fatalf("failed to get provider: %s", err) } @@ -210,7 +248,7 @@ func TestGetImpacted(t *testing.T) { }, } - provider, err := NewProvider(fp, &fakeSender{}) + provider, err := NewProvider(fp, &fakeSender{}, approver()) if err != nil { t.Fatalf("failed to get provider: %s", err) } @@ -221,17 +259,17 @@ func TestGetImpacted(t *testing.T) { Tag: "1.1.2", } - deps, err := provider.impactedDeployments(repo) + plans, err := provider.createUpdatePlans(repo) if err != nil { t.Errorf("failed to get deployments: %s", err) } - if len(deps) != 1 { - t.Errorf("expected to find 1 deployment but found %d", len(deps)) + if len(plans) != 1 { + t.Errorf("expected to find 1 deployment update plan but found %d", len(plans)) } found := false - for _, c := range deps[0].Spec.Template.Spec.Containers { + for _, c := range plans[0].Deployment.Spec.Template.Spec.Containers { containerImageName := versionreg.ReplaceAllString(c.Image, "") @@ -303,7 +341,7 @@ func TestProcessEvent(t *testing.T) { }, } - provider, err := NewProvider(fp, &fakeSender{}) + provider, err := NewProvider(fp, &fakeSender{}, approver()) if err != nil { t.Fatalf("failed to get provider: %s", err) } @@ -361,7 +399,7 @@ func TestProcessEventBuildNumber(t *testing.T) { }, } - provider, err := NewProvider(fp, &fakeSender{}) + provider, err := NewProvider(fp, &fakeSender{}, approver()) if err != nil { t.Fatalf("failed to get provider: %s", err) } @@ -443,7 +481,7 @@ func TestGetImpactedTwoContainersInSameDeployment(t *testing.T) { }, } - provider, err := NewProvider(fp, &fakeSender{}) + provider, err := NewProvider(fp, &fakeSender{}, approver()) if err != nil { t.Fatalf("failed to get provider: %s", err) } @@ -454,17 +492,17 @@ func TestGetImpactedTwoContainersInSameDeployment(t *testing.T) { Tag: "1.1.2", } - deps, err := provider.impactedDeployments(repo) + plans, err := provider.createUpdatePlans(repo) if err != nil { t.Errorf("failed to get deployments: %s", err) } - if len(deps) != 1 { - t.Errorf("expected to find 1 deployment but found %d", len(deps)) + if len(plans) != 1 { + t.Errorf("expected to find 1 deployment but found %d", len(plans)) } found := false - for _, c := range deps[0].Spec.Template.Spec.Containers { + for _, c := range plans[0].Deployment.Spec.Template.Spec.Containers { containerImageName := versionreg.ReplaceAllString(c.Image, "") @@ -540,7 +578,7 @@ func TestGetImpactedTwoSameContainersInSameDeployment(t *testing.T) { }, } - provider, err := NewProvider(fp, &fakeSender{}) + provider, err := NewProvider(fp, &fakeSender{}, approver()) if err != nil { t.Fatalf("failed to get provider: %s", err) } @@ -551,17 +589,17 @@ func TestGetImpactedTwoSameContainersInSameDeployment(t *testing.T) { Tag: "1.1.2", } - deps, err := provider.impactedDeployments(repo) + plans, err := provider.createUpdatePlans(repo) if err != nil { t.Errorf("failed to get deployments: %s", err) } - if len(deps) != 1 { - t.Errorf("expected to find 1 deployment but found %d", len(deps)) + if len(plans) != 1 { + t.Errorf("expected to find 1 deployment but found %d", len(plans)) } found := false - for _, c := range deps[0].Spec.Template.Spec.Containers { + for _, c := range plans[0].Deployment.Spec.Template.Spec.Containers { containerImageName := versionreg.ReplaceAllString(c.Image, "") @@ -635,7 +673,7 @@ func TestGetImpactedUntaggedImage(t *testing.T) { }, } - provider, err := NewProvider(fp, &fakeSender{}) + provider, err := NewProvider(fp, &fakeSender{}, approver()) if err != nil { t.Fatalf("failed to get provider: %s", err) } @@ -646,17 +684,17 @@ func TestGetImpactedUntaggedImage(t *testing.T) { Tag: "1.1.2", } - deps, err := provider.impactedDeployments(repo) + plans, err := provider.createUpdatePlans(repo) if err != nil { t.Errorf("failed to get deployments: %s", err) } - if len(deps) != 1 { - t.Errorf("expected to find 1 deployment but found %d", len(deps)) + if len(plans) != 1 { + t.Errorf("expected to find 1 deployment but found %d", len(plans)) } found := false - for _, c := range deps[0].Spec.Template.Spec.Containers { + for _, c := range plans[0].Deployment.Spec.Template.Spec.Containers { containerImageName := versionreg.ReplaceAllString(c.Image, "") @@ -731,7 +769,7 @@ func TestGetImpactedUntaggedOneImage(t *testing.T) { }, } - provider, err := NewProvider(fp, &fakeSender{}) + provider, err := NewProvider(fp, &fakeSender{}, approver()) if err != nil { t.Fatalf("failed to get provider: %s", err) } @@ -742,22 +780,24 @@ func TestGetImpactedUntaggedOneImage(t *testing.T) { Tag: "1.1.2", } - deps, err := provider.impactedDeployments(repo) + plans, err := provider.createUpdatePlans(repo) if err != nil { t.Errorf("failed to get deployments: %s", err) } - if len(deps) != 2 { - t.Errorf("expected to find 2 deployment but found %d", len(deps)) + if len(plans) != 2 { + t.Fatalf("expected to find 2 deployment but found %d", len(plans)) } found := false - for _, c := range deps[0].Spec.Template.Spec.Containers { + for _, plan := range plans { + for _, c := range plan.Deployment.Spec.Template.Spec.Containers { - containerImageName := versionreg.ReplaceAllString(c.Image, "") + containerImageName := versionreg.ReplaceAllString(c.Image, "") - if containerImageName == repo.Name { - found = true + if containerImageName == repo.Name { + found = true + } } } @@ -809,7 +849,7 @@ func TestTrackedImages(t *testing.T) { }, } - provider, err := NewProvider(fp, &fakeSender{}) + provider, err := NewProvider(fp, &fakeSender{}, approver()) if err != nil { t.Fatalf("failed to get provider: %s", err) } diff --git a/provider/kubernetes/unversioned_updates.go b/provider/kubernetes/unversioned_updates.go index 384d885c..db9ef141 100644 --- a/provider/kubernetes/unversioned_updates.go +++ b/provider/kubernetes/unversioned_updates.go @@ -11,7 +11,10 @@ import ( log "github.com/Sirupsen/logrus" ) -func (p *Provider) checkUnversionedDeployment(policy types.PolicyType, repo *types.Repository, deployment v1beta1.Deployment) (updated v1beta1.Deployment, shouldUpdateDeployment bool, err error) { +// func (p *Provider) checkUnversionedDeployment(policy types.PolicyType, repo *types.Repository, deployment v1beta1.Deployment) (updated v1beta1.Deployment, shouldUpdateDeployment bool, err error) { +func (p *Provider) checkUnversionedDeployment(policy types.PolicyType, repo *types.Repository, deployment v1beta1.Deployment) (updatePlan *UpdatePlan, shouldUpdateDeployment bool, err error) { + updatePlan = &UpdatePlan{} + eventRepoRef, err := image.Parse(repo.Name) if err != nil { return @@ -82,6 +85,10 @@ func (p *Provider) checkUnversionedDeployment(policy types.PolicyType, repo *typ deployment.SetAnnotations(annotations) + updatePlan.CurrentVersion = containerImageRef.Tag() + updatePlan.NewVersion = repo.Tag + updatePlan.Deployment = deployment + log.WithFields(log.Fields{ "parsed_image": containerImageRef.Remote(), "raw_image_name": c.Image, @@ -92,5 +99,5 @@ func (p *Provider) checkUnversionedDeployment(policy types.PolicyType, repo *typ } - return deployment, shouldUpdateDeployment, nil + return updatePlan, shouldUpdateDeployment, nil } diff --git a/provider/kubernetes/unversioned_updates_test.go b/provider/kubernetes/unversioned_updates_test.go index 3b1a160d..44b4f52d 100644 --- a/provider/kubernetes/unversioned_updates_test.go +++ b/provider/kubernetes/unversioned_updates_test.go @@ -4,6 +4,8 @@ import ( "reflect" "testing" + "github.com/rusenask/keel/approvals" + "github.com/rusenask/keel/extension/notification" "github.com/rusenask/keel/types" meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/client-go/pkg/api/v1" @@ -12,9 +14,11 @@ import ( func TestProvider_checkUnversionedDeployment(t *testing.T) { type fields struct { - implementer Implementer - events chan *types.Event - stop chan struct{} + implementer Implementer + sender notification.Sender + approvalManager approvals.Manager + events chan *types.Event + stop chan struct{} } type args struct { policy types.PolicyType @@ -25,7 +29,7 @@ func TestProvider_checkUnversionedDeployment(t *testing.T) { name string fields fields args args - wantUpdated v1beta1.Deployment + wantUpdatePlan *UpdatePlan wantShouldUpdateDeployment bool wantErr bool }{ @@ -56,26 +60,30 @@ func TestProvider_checkUnversionedDeployment(t *testing.T) { v1beta1.DeploymentStatus{}, }, }, - wantUpdated: v1beta1.Deployment{ - meta_v1.TypeMeta{}, - meta_v1.ObjectMeta{ - Name: "dep-1", - Namespace: "xxxx", - Annotations: map[string]string{forceUpdateImageAnnotation: "gcr.io/v2-namespace/hello-world:latest"}, - Labels: map[string]string{types.KeelPolicyLabel: "all"}, - }, - v1beta1.DeploymentSpec{ - Template: v1.PodTemplateSpec{ - Spec: v1.PodSpec{ - Containers: []v1.Container{ - v1.Container{ - Image: "gcr.io/v2-namespace/hello-world:latest", + wantUpdatePlan: &UpdatePlan{ + Deployment: v1beta1.Deployment{ + meta_v1.TypeMeta{}, + meta_v1.ObjectMeta{ + Name: "dep-1", + Namespace: "xxxx", + Annotations: map[string]string{forceUpdateImageAnnotation: "gcr.io/v2-namespace/hello-world:latest"}, + Labels: map[string]string{types.KeelPolicyLabel: "all"}, + }, + v1beta1.DeploymentSpec{ + Template: v1.PodTemplateSpec{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + v1.Container{ + Image: "gcr.io/v2-namespace/hello-world:latest", + }, }, }, }, }, + v1beta1.DeploymentStatus{}, }, - v1beta1.DeploymentStatus{}, + NewVersion: "latest", + CurrentVersion: "latest", }, wantShouldUpdateDeployment: true, wantErr: false, @@ -107,26 +115,8 @@ func TestProvider_checkUnversionedDeployment(t *testing.T) { v1beta1.DeploymentStatus{}, }, }, - wantUpdated: v1beta1.Deployment{ - meta_v1.TypeMeta{}, - meta_v1.ObjectMeta{ - Name: "dep-1", - Namespace: "xxxx", - Annotations: map[string]string{}, - Labels: map[string]string{types.KeelPolicyLabel: "all"}, - }, - v1beta1.DeploymentSpec{ - Template: v1.PodTemplateSpec{ - Spec: v1.PodSpec{ - Containers: []v1.Container{ - v1.Container{ - Image: "gcr.io/v2-namespace/goodbye-world:earliest", - }, - }, - }, - }, - }, - v1beta1.DeploymentStatus{}, + wantUpdatePlan: &UpdatePlan{ + Deployment: v1beta1.Deployment{}, }, wantShouldUpdateDeployment: false, wantErr: false, @@ -158,26 +148,30 @@ func TestProvider_checkUnversionedDeployment(t *testing.T) { v1beta1.DeploymentStatus{}, }, }, - wantUpdated: v1beta1.Deployment{ - meta_v1.TypeMeta{}, - meta_v1.ObjectMeta{ - Name: "dep-1", - Namespace: "xxxx", - Annotations: map[string]string{forceUpdateImageAnnotation: "karolisr/keel:0.2.0"}, - Labels: map[string]string{types.KeelPolicyLabel: "force"}, - }, - v1beta1.DeploymentSpec{ - Template: v1.PodTemplateSpec{ - Spec: v1.PodSpec{ - Containers: []v1.Container{ - v1.Container{ - Image: "karolisr/keel:0.2.0", + wantUpdatePlan: &UpdatePlan{ + Deployment: v1beta1.Deployment{ + meta_v1.TypeMeta{}, + meta_v1.ObjectMeta{ + Name: "dep-1", + Namespace: "xxxx", + Annotations: map[string]string{forceUpdateImageAnnotation: "karolisr/keel:0.2.0"}, + Labels: map[string]string{types.KeelPolicyLabel: "force"}, + }, + v1beta1.DeploymentSpec{ + Template: v1.PodTemplateSpec{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + v1.Container{ + Image: "karolisr/keel:0.2.0", + }, }, }, }, }, + v1beta1.DeploymentStatus{}, }, - v1beta1.DeploymentStatus{}, + NewVersion: "0.2.0", + CurrentVersion: "latest", }, wantShouldUpdateDeployment: true, wantErr: false, @@ -186,17 +180,19 @@ func TestProvider_checkUnversionedDeployment(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &Provider{ - implementer: tt.fields.implementer, - events: tt.fields.events, - stop: tt.fields.stop, + implementer: tt.fields.implementer, + sender: tt.fields.sender, + approvalManager: tt.fields.approvalManager, + events: tt.fields.events, + stop: tt.fields.stop, } - gotUpdated, gotShouldUpdateDeployment, err := p.checkUnversionedDeployment(tt.args.policy, tt.args.repo, tt.args.deployment) + gotUpdatePlan, gotShouldUpdateDeployment, err := p.checkUnversionedDeployment(tt.args.policy, tt.args.repo, tt.args.deployment) if (err != nil) != tt.wantErr { t.Errorf("Provider.checkUnversionedDeployment() error = %v, wantErr %v", err, tt.wantErr) return } - if !reflect.DeepEqual(gotUpdated, tt.wantUpdated) { - t.Errorf("Provider.checkUnversionedDeployment() gotUpdated = %v, want %v", gotUpdated, tt.wantUpdated) + if !reflect.DeepEqual(gotUpdatePlan, tt.wantUpdatePlan) { + t.Errorf("Provider.checkUnversionedDeployment() gotUpdatePlan = %v, want %v", gotUpdatePlan, tt.wantUpdatePlan) } if gotShouldUpdateDeployment != tt.wantShouldUpdateDeployment { t.Errorf("Provider.checkUnversionedDeployment() gotShouldUpdateDeployment = %v, want %v", gotShouldUpdateDeployment, tt.wantShouldUpdateDeployment) diff --git a/provider/kubernetes/versioned_updates.go b/provider/kubernetes/versioned_updates.go index 40eb8f6d..d5e6fdd1 100644 --- a/provider/kubernetes/versioned_updates.go +++ b/provider/kubernetes/versioned_updates.go @@ -14,7 +14,10 @@ import ( log "github.com/Sirupsen/logrus" ) -func (p *Provider) checkVersionedDeployment(newVersion *types.Version, policy types.PolicyType, repo *types.Repository, deployment v1beta1.Deployment) (updated v1beta1.Deployment, shouldUpdateDeployment bool, err error) { +// func (p *Provider) checkVersionedDeployment(newVersion *types.Version, policy types.PolicyType, repo *types.Repository, deployment v1beta1.Deployment) (updated v1beta1.Deployment, shouldUpdateDeployment bool, err error) { +func (p *Provider) checkVersionedDeployment(newVersion *types.Version, policy types.PolicyType, repo *types.Repository, deployment v1beta1.Deployment) (updatePlan *UpdatePlan, shouldUpdateDeployment bool, err error) { + updatePlan = &UpdatePlan{} + eventRepoRef, err := image.Parse(repo.Name) if err != nil { return @@ -88,6 +91,10 @@ func (p *Provider) checkVersionedDeployment(newVersion *types.Version, policy ty "policy": policy, }).Info("provider.kubernetes: impacted deployment container found") + updatePlan.CurrentVersion = conatinerImageRef.Tag() + updatePlan.NewVersion = newVersion.Original + updatePlan.Deployment = deployment + // success, moving to next container continue } @@ -148,6 +155,10 @@ func (p *Provider) checkVersionedDeployment(newVersion *types.Version, policy ty } deployment.SetAnnotations(annotations) + updatePlan.CurrentVersion = currentVersion.Original + updatePlan.NewVersion = newVersion.Original + updatePlan.Deployment = deployment + log.WithFields(log.Fields{ "parsed_image": conatinerImageRef.Remote(), "raw_image_name": c.Image, @@ -158,7 +169,7 @@ func (p *Provider) checkVersionedDeployment(newVersion *types.Version, policy ty } } - return deployment, shouldUpdateDeployment, nil + return updatePlan, shouldUpdateDeployment, nil } func updateContainer(container v1.Container, ref *image.Reference, version string) v1.Container { diff --git a/provider/kubernetes/versioned_updates_test.go b/provider/kubernetes/versioned_updates_test.go index 8e87ee69..6278804c 100644 --- a/provider/kubernetes/versioned_updates_test.go +++ b/provider/kubernetes/versioned_updates_test.go @@ -4,10 +4,13 @@ import ( "reflect" "testing" + "github.com/rusenask/keel/approvals" + "github.com/rusenask/keel/extension/notification" "github.com/rusenask/keel/types" "github.com/rusenask/keel/util/version" meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/pkg/api/v1" "k8s.io/client-go/pkg/apis/extensions/v1beta1" ) @@ -22,9 +25,11 @@ func unsafeGetVersion(ver string) *types.Version { func TestProvider_checkVersionedDeployment(t *testing.T) { type fields struct { - implementer Implementer - events chan *types.Event - stop chan struct{} + implementer Implementer + sender notification.Sender + approvalManager approvals.Manager + events chan *types.Event + stop chan struct{} } type args struct { newVersion *types.Version @@ -36,7 +41,7 @@ func TestProvider_checkVersionedDeployment(t *testing.T) { name string fields fields args args - wantUpdated v1beta1.Deployment + wantUpdatePlan *UpdatePlan wantShouldUpdateDeployment bool wantErr bool }{ @@ -68,26 +73,30 @@ func TestProvider_checkVersionedDeployment(t *testing.T) { v1beta1.DeploymentStatus{}, }, }, - wantUpdated: v1beta1.Deployment{ - meta_v1.TypeMeta{}, - meta_v1.ObjectMeta{ - Name: "dep-1", - Namespace: "xxxx", - Annotations: map[string]string{}, - Labels: map[string]string{types.KeelPolicyLabel: "all"}, - }, - v1beta1.DeploymentSpec{ - Template: v1.PodTemplateSpec{ - Spec: v1.PodSpec{ - Containers: []v1.Container{ - v1.Container{ - Image: "gcr.io/v2-namespace/hello-world:1.1.2", + wantUpdatePlan: &UpdatePlan{ + Deployment: v1beta1.Deployment{ + meta_v1.TypeMeta{}, + meta_v1.ObjectMeta{ + Name: "dep-1", + Namespace: "xxxx", + Annotations: map[string]string{}, + Labels: map[string]string{types.KeelPolicyLabel: "all"}, + }, + v1beta1.DeploymentSpec{ + Template: v1.PodTemplateSpec{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + v1.Container{ + Image: "gcr.io/v2-namespace/hello-world:1.1.2", + }, }, }, }, }, + v1beta1.DeploymentStatus{}, }, - v1beta1.DeploymentStatus{}, + NewVersion: "1.1.2", + CurrentVersion: "1.1.1", }, wantShouldUpdateDeployment: true, wantErr: false, @@ -120,26 +129,10 @@ func TestProvider_checkVersionedDeployment(t *testing.T) { v1beta1.DeploymentStatus{}, }, }, - wantUpdated: v1beta1.Deployment{ - meta_v1.TypeMeta{}, - meta_v1.ObjectMeta{ - Name: "dep-1", - Namespace: "xxxx", - Annotations: map[string]string{}, - Labels: map[string]string{types.KeelPolicyLabel: "all"}, - }, - v1beta1.DeploymentSpec{ - Template: v1.PodTemplateSpec{ - Spec: v1.PodSpec{ - Containers: []v1.Container{ - v1.Container{ - Image: "gcr.io/v2-namespace/hello-world:1.1.1", - }, - }, - }, - }, - }, - v1beta1.DeploymentStatus{}, + wantUpdatePlan: &UpdatePlan{ + Deployment: v1beta1.Deployment{}, + NewVersion: "", + CurrentVersion: "", }, wantShouldUpdateDeployment: false, wantErr: false, @@ -175,29 +168,33 @@ func TestProvider_checkVersionedDeployment(t *testing.T) { v1beta1.DeploymentStatus{}, }, }, - wantUpdated: v1beta1.Deployment{ - meta_v1.TypeMeta{}, - meta_v1.ObjectMeta{ - Name: "dep-1", - Namespace: "xxxx", - Annotations: map[string]string{}, - Labels: map[string]string{types.KeelPolicyLabel: "all"}, - }, - v1beta1.DeploymentSpec{ - Template: v1.PodTemplateSpec{ - Spec: v1.PodSpec{ - Containers: []v1.Container{ - v1.Container{ - Image: "gcr.io/v2-namespace/hello-world:1.1.2", - }, - v1.Container{ - Image: "yo-world:1.1.1", + wantUpdatePlan: &UpdatePlan{ + Deployment: v1beta1.Deployment{ + meta_v1.TypeMeta{}, + meta_v1.ObjectMeta{ + Name: "dep-1", + Namespace: "xxxx", + Annotations: map[string]string{}, + Labels: map[string]string{types.KeelPolicyLabel: "all"}, + }, + v1beta1.DeploymentSpec{ + Template: v1.PodTemplateSpec{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + v1.Container{ + Image: "gcr.io/v2-namespace/hello-world:1.1.2", + }, + v1.Container{ + Image: "yo-world:1.1.1", + }, }, }, }, }, + v1beta1.DeploymentStatus{}, }, - v1beta1.DeploymentStatus{}, + NewVersion: "1.1.2", + CurrentVersion: "1.1.1", }, wantShouldUpdateDeployment: true, wantErr: false, @@ -233,29 +230,33 @@ func TestProvider_checkVersionedDeployment(t *testing.T) { v1beta1.DeploymentStatus{}, }, }, - wantUpdated: v1beta1.Deployment{ - meta_v1.TypeMeta{}, - meta_v1.ObjectMeta{ - Name: "dep-1", - Namespace: "xxxx", - Annotations: map[string]string{forceUpdateImageAnnotation: "gcr.io/v2-namespace/hello-world:1.1.2"}, - Labels: map[string]string{types.KeelPolicyLabel: "force"}, - }, - v1beta1.DeploymentSpec{ - Template: v1.PodTemplateSpec{ - Spec: v1.PodSpec{ - Containers: []v1.Container{ - v1.Container{ - Image: "gcr.io/v2-namespace/hello-world:1.1.2", - }, - v1.Container{ - Image: "yo-world:1.1.1", + wantUpdatePlan: &UpdatePlan{ + Deployment: v1beta1.Deployment{ + meta_v1.TypeMeta{}, + meta_v1.ObjectMeta{ + Name: "dep-1", + Namespace: "xxxx", + Annotations: map[string]string{forceUpdateImageAnnotation: "gcr.io/v2-namespace/hello-world:1.1.2"}, + Labels: map[string]string{types.KeelPolicyLabel: "force"}, + }, + v1beta1.DeploymentSpec{ + Template: v1.PodTemplateSpec{ + Spec: v1.PodSpec{ + Containers: []v1.Container{ + v1.Container{ + Image: "gcr.io/v2-namespace/hello-world:1.1.2", + }, + v1.Container{ + Image: "yo-world:1.1.1", + }, }, }, }, }, + v1beta1.DeploymentStatus{}, }, - v1beta1.DeploymentStatus{}, + NewVersion: "1.1.2", + CurrentVersion: "latest", }, wantShouldUpdateDeployment: true, wantErr: false, @@ -264,17 +265,19 @@ func TestProvider_checkVersionedDeployment(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { p := &Provider{ - implementer: tt.fields.implementer, - events: tt.fields.events, - stop: tt.fields.stop, + implementer: tt.fields.implementer, + sender: tt.fields.sender, + approvalManager: tt.fields.approvalManager, + events: tt.fields.events, + stop: tt.fields.stop, } - gotUpdated, gotShouldUpdateDeployment, err := p.checkVersionedDeployment(tt.args.newVersion, tt.args.policy, tt.args.repo, tt.args.deployment) + gotUpdatePlan, gotShouldUpdateDeployment, err := p.checkVersionedDeployment(tt.args.newVersion, tt.args.policy, tt.args.repo, tt.args.deployment) if (err != nil) != tt.wantErr { t.Errorf("Provider.checkVersionedDeployment() error = %v, wantErr %v", err, tt.wantErr) return } - if !reflect.DeepEqual(gotUpdated, tt.wantUpdated) { - t.Errorf("Provider.checkVersionedDeployment() gotUpdated = %v, want %v", gotUpdated, tt.wantUpdated) + if !reflect.DeepEqual(gotUpdatePlan, tt.wantUpdatePlan) { + t.Errorf("Provider.checkVersionedDeployment() gotUpdatePlan = %v, want %v", gotUpdatePlan, tt.wantUpdatePlan) } if gotShouldUpdateDeployment != tt.wantShouldUpdateDeployment { t.Errorf("Provider.checkVersionedDeployment() gotShouldUpdateDeployment = %v, want %v", gotShouldUpdateDeployment, tt.wantShouldUpdateDeployment) diff --git a/provider/provider.go b/provider/provider.go index 848596d8..447b5e7e 100644 --- a/provider/provider.go +++ b/provider/provider.go @@ -1,6 +1,9 @@ package provider import ( + "context" + + "github.com/rusenask/keel/approvals" "github.com/rusenask/keel/types" log "github.com/Sirupsen/logrus" @@ -23,7 +26,7 @@ type Providers interface { } // New - new providers registry -func New(providers []Provider) *DefaultProviders { +func New(providers []Provider, approvalsManager approvals.Manager) *DefaultProviders { pvs := make(map[string]Provider) for _, p := range providers { @@ -31,14 +34,46 @@ func New(providers []Provider) *DefaultProviders { log.Infof("provider.defaultProviders: provider '%s' registered", p.GetName()) } - return &DefaultProviders{ - providers: pvs, + dp := &DefaultProviders{ + providers: pvs, + approvalsManager: approvalsManager, + stopCh: make(chan struct{}), } + + // subscribing to approved events + // TODO: create Start() function for DefaultProviders + go dp.subscribeToApproved() + + return dp } // DefaultProviders - default providers container type DefaultProviders struct { - providers map[string]Provider + providers map[string]Provider + approvalsManager approvals.Manager + stopCh chan struct{} +} + +func (p *DefaultProviders) subscribeToApproved() { + ctx, cancel := context.WithCancel(context.Background()) + + approvedCh, err := p.approvalsManager.SubscribeApproved(ctx) + if err != nil { + log.WithFields(log.Fields{ + "error": err, + }).Fatal("provider.subscribeToApproved: failed to subscribe for approved reqs") + } + + for { + select { + case approval := <-approvedCh: + p.Submit(*approval.Event) + case <-p.stopCh: + cancel() + return + } + } + } // Submit - submit event to all providers @@ -51,7 +86,7 @@ func (p *DefaultProviders) Submit(event types.Event) error { "provider": provider.GetName(), "event": event.Repository, "trigger": event.TriggerName, - }).Error("provider.defaultProviders: submit event failed") + }).Error("provider.Submit: submit event failed") } } diff --git a/secrets/secrets.go b/secrets/secrets.go index 53e6184e..573c95bf 100644 --- a/secrets/secrets.go +++ b/secrets/secrets.go @@ -87,7 +87,7 @@ func (g *DefaultGetter) lookupSecrets(image *types.TrackedImage) ([]string, erro "image": image.Image.Repository(), "pod_selector": selector, "secrets": podSecrets, - }).Info("secrets.defaultGetter.lookupSecrets: pod secrets found") + }).Debug("secrets.defaultGetter.lookupSecrets: pod secrets found") secrets = append(secrets, podSecrets...) } @@ -99,7 +99,7 @@ func (g *DefaultGetter) lookupSecrets(image *types.TrackedImage) ([]string, erro "image": image.Image.Repository(), "pod_selector": selector, "pods_checked": len(podList.Items), - }).Info("secrets.defaultGetter.lookupSecrets: no secrets for image found") + }).Warn("secrets.defaultGetter.lookupSecrets: no secrets for image found") } return secrets, nil @@ -210,7 +210,7 @@ func (g *DefaultGetter) getCredentialsFromSecret(image *types.TrackedImage) (*ty "provider": image.Provider, "registry": image.Image.Registry(), "image": image.Image.Repository(), - }).Info("secrets.defaultGetter: secret looked up successfully") + }).Debug("secrets.defaultGetter: secret looked up successfully") return credentials, nil } diff --git a/trigger/http/approvals_endpoint.go b/trigger/http/approvals_endpoint.go new file mode 100644 index 00000000..66c24261 --- /dev/null +++ b/trigger/http/approvals_endpoint.go @@ -0,0 +1,46 @@ +package http + +import ( + "encoding/json" + "fmt" + "net/http" + + "github.com/rusenask/keel/types" +) + +func (s *TriggerServer) approvalsHandler(resp http.ResponseWriter, req *http.Request) { + // unknown lists all + approvals, err := s.approvalsManager.List() + if err != nil { + fmt.Fprintf(resp, "%s", err) + resp.WriteHeader(http.StatusInternalServerError) + return + } + + if len(approvals) == 0 { + approvals = make([]*types.Approval, 0) + } + + bts, err := json.Marshal(&approvals) + if err != nil { + fmt.Fprintf(resp, "%s", err) + resp.WriteHeader(http.StatusInternalServerError) + return + } + + resp.Write(bts) +} + +func (s *TriggerServer) approvalDeleteHandler(resp http.ResponseWriter, req *http.Request) { + identifier := getID(req) + + err := s.approvalsManager.Delete(identifier) + if err != nil { + fmt.Fprintf(resp, "%s", err) + resp.WriteHeader(http.StatusInternalServerError) + return + } + + resp.WriteHeader(http.StatusOK) + fmt.Fprintf(resp, identifier) +} diff --git a/trigger/http/approvals_endpoint_test.go b/trigger/http/approvals_endpoint_test.go new file mode 100644 index 00000000..bc859e57 --- /dev/null +++ b/trigger/http/approvals_endpoint_test.go @@ -0,0 +1,113 @@ +package http + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "testing" + "time" + + "github.com/rusenask/keel/approvals" + "github.com/rusenask/keel/cache/memory" + "github.com/rusenask/keel/provider" + "github.com/rusenask/keel/types" + "github.com/rusenask/keel/util/codecs" +) + +func TestListApprovals(t *testing.T) { + + fp := &fakeProvider{} + mem := memory.NewMemoryCache(100*time.Second, 100*time.Second, 10*time.Second) + am := approvals.New(mem, codecs.DefaultSerializer()) + providers := provider.New([]provider.Provider{fp}, am) + srv := NewTriggerServer(&Opts{Providers: providers, ApprovalManager: am}) + srv.registerRoutes(srv.router) + + err := am.Create(&types.Approval{ + Identifier: "123", + VotesRequired: 5, + NewVersion: "2.0.0", + CurrentVersion: "1.0.0", + }) + + if err != nil { + t.Fatalf("failed to create approval: %s", err) + } + + // listing + req, err := http.NewRequest("GET", "/v1/approvals", nil) + if err != nil { + t.Fatalf("failed to create req: %s", err) + } + + rec := httptest.NewRecorder() + + srv.router.ServeHTTP(rec, req) + if rec.Code != 200 { + t.Errorf("unexpected status code: %d", rec.Code) + + t.Log(rec.Body.String()) + } + + var approvals []*types.Approval + + err = json.Unmarshal(rec.Body.Bytes(), &approvals) + if err != nil { + t.Fatalf("failed to unmarshal response into approvals: %s", err) + } + + if len(approvals) != 1 { + t.Fatalf("expected to find 1 approval but found: %d", len(approvals)) + } + + if approvals[0].VotesRequired != 5 { + t.Errorf("unexpected votes required") + } + if approvals[0].NewVersion != "2.0.0" { + t.Errorf("unexpected new version: %s", approvals[0].NewVersion) + } + if approvals[0].CurrentVersion != "1.0.0" { + t.Errorf("unexpected current version: %s", approvals[0].CurrentVersion) + } +} + +func TestDeleteApproval(t *testing.T) { + fp := &fakeProvider{} + mem := memory.NewMemoryCache(100*time.Second, 100*time.Second, 10*time.Second) + am := approvals.New(mem, codecs.DefaultSerializer()) + providers := provider.New([]provider.Provider{fp}, am) + srv := NewTriggerServer(&Opts{Providers: providers, ApprovalManager: am}) + srv.registerRoutes(srv.router) + + err := am.Create(&types.Approval{ + Identifier: "12345", + VotesRequired: 5, + NewVersion: "2.0.0", + CurrentVersion: "1.0.0", + }) + + if err != nil { + t.Fatalf("failed to create approval: %s", err) + } + + // listing + req, err := http.NewRequest("DELETE", "/v1/approvals/12345", nil) + if err != nil { + t.Fatalf("failed to create req: %s", err) + } + + rec := httptest.NewRecorder() + + srv.router.ServeHTTP(rec, req) + if rec.Code != 200 { + t.Errorf("unexpected status code: %d", rec.Code) + + t.Log(rec.Body.String()) + } + + _, err = am.Get("12345") + if err == nil { + t.Errorf("expected approval to be deleted") + } + +} diff --git a/trigger/http/dockerhub_webhook_trigger_test.go b/trigger/http/dockerhub_webhook_trigger_test.go index 3daaa686..0481d7b6 100644 --- a/trigger/http/dockerhub_webhook_trigger_test.go +++ b/trigger/http/dockerhub_webhook_trigger_test.go @@ -3,9 +3,12 @@ package http import ( "bytes" "net/http" + "time" + "github.com/rusenask/keel/approvals" + "github.com/rusenask/keel/cache/memory" "github.com/rusenask/keel/provider" - // "github.com/rusenask/keel/types" + "github.com/rusenask/keel/util/codecs" "net/http/httptest" "testing" @@ -41,7 +44,9 @@ var fakeRequest = `{ func TestDockerhubWebhookHandler(t *testing.T) { fp := &fakeProvider{} - providers := provider.New([]provider.Provider{fp}) + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + am := approvals.New(mem, codecs.DefaultSerializer()) + providers := provider.New([]provider.Provider{fp}, am) srv := NewTriggerServer(&Opts{Providers: providers}) srv.registerRoutes(srv.router) diff --git a/trigger/http/http.go b/trigger/http/http.go index e53d636b..0ae9acb9 100644 --- a/trigger/http/http.go +++ b/trigger/http/http.go @@ -10,6 +10,7 @@ import ( "github.com/gorilla/mux" "github.com/urfave/negroni" + "github.com/rusenask/keel/approvals" "github.com/rusenask/keel/provider" "github.com/rusenask/keel/types" "github.com/rusenask/keel/version" @@ -23,22 +24,26 @@ type Opts struct { // available providers Providers provider.Providers + + ApprovalManager approvals.Manager } // TriggerServer - webhook trigger & healthcheck server type TriggerServer struct { - providers provider.Providers - port int - server *http.Server - router *mux.Router + providers provider.Providers + approvalsManager approvals.Manager + port int + server *http.Server + router *mux.Router } // NewTriggerServer - create new HTTP trigger based server func NewTriggerServer(opts *Opts) *TriggerServer { return &TriggerServer{ - port: opts.Port, - providers: opts.Providers, - router: mux.NewRouter(), + port: opts.Port, + providers: opts.Providers, + approvalsManager: opts.ApprovalManager, + router: mux.NewRouter(), } } @@ -66,7 +71,10 @@ func (s *TriggerServer) Stop() { ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() s.server.Shutdown(ctx) +} +func getID(req *http.Request) string { + return mux.Vars(req)["id"] } func (s *TriggerServer) registerRoutes(mux *mux.Router) { @@ -74,6 +82,11 @@ func (s *TriggerServer) registerRoutes(mux *mux.Router) { mux.HandleFunc("/healthz", s.healthHandler).Methods("GET", "OPTIONS") // version handler mux.HandleFunc("/version", s.versionHandler).Methods("GET", "OPTIONS") + + // approvals + mux.HandleFunc("/v1/approvals", s.approvalsHandler).Methods("GET", "OPTIONS") + mux.HandleFunc("/v1/approvals/{id}", s.approvalDeleteHandler).Methods("DELETE", "OPTIONS") + // native webhooks handler mux.HandleFunc("/v1/webhooks/native", s.nativeHandler).Methods("POST", "OPTIONS") diff --git a/trigger/http/native_webhook_trigger_test.go b/trigger/http/native_webhook_trigger_test.go index 962602a4..6c519a3d 100644 --- a/trigger/http/native_webhook_trigger_test.go +++ b/trigger/http/native_webhook_trigger_test.go @@ -3,9 +3,13 @@ package http import ( "bytes" "net/http" + "time" + "github.com/rusenask/keel/approvals" + "github.com/rusenask/keel/cache/memory" "github.com/rusenask/keel/provider" "github.com/rusenask/keel/types" + "github.com/rusenask/keel/util/codecs" "net/http/httptest" "testing" @@ -37,7 +41,9 @@ func TestNativeWebhookHandler(t *testing.T) { fp := &fakeProvider{} - providers := provider.New([]provider.Provider{fp}) + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + am := approvals.New(mem, codecs.DefaultSerializer()) + providers := provider.New([]provider.Provider{fp}, am) srv := NewTriggerServer(&Opts{Providers: providers}) srv.registerRoutes(srv.router) @@ -64,7 +70,9 @@ func TestNativeWebhookHandler(t *testing.T) { func TestNativeWebhookHandlerNoRepoName(t *testing.T) { fp := &fakeProvider{} - providers := provider.New([]provider.Provider{fp}) + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + am := approvals.New(mem, codecs.DefaultSerializer()) + providers := provider.New([]provider.Provider{fp}, am) srv := NewTriggerServer(&Opts{Providers: providers}) srv.registerRoutes(srv.router) diff --git a/trigger/http/quay_webhook_trigger_test.go b/trigger/http/quay_webhook_trigger_test.go index 8890084c..066f0047 100644 --- a/trigger/http/quay_webhook_trigger_test.go +++ b/trigger/http/quay_webhook_trigger_test.go @@ -3,8 +3,12 @@ package http import ( "bytes" "net/http" + "time" + "github.com/rusenask/keel/approvals" + "github.com/rusenask/keel/cache/memory" "github.com/rusenask/keel/provider" + "github.com/rusenask/keel/util/codecs" "net/http/httptest" "testing" @@ -25,7 +29,9 @@ var fakeQuayWebhook = `{ func TestQuayWebhookHandler(t *testing.T) { fp := &fakeProvider{} - providers := provider.New([]provider.Provider{fp}) + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + am := approvals.New(mem, codecs.DefaultSerializer()) + providers := provider.New([]provider.Provider{fp}, am) srv := NewTriggerServer(&Opts{Providers: providers}) srv.registerRoutes(srv.router) diff --git a/trigger/poll/manager_test.go b/trigger/poll/manager_test.go index fb3d2bed..cb2b02de 100644 --- a/trigger/poll/manager_test.go +++ b/trigger/poll/manager_test.go @@ -2,9 +2,13 @@ package poll import ( "context" + "time" + "github.com/rusenask/keel/approvals" + "github.com/rusenask/keel/cache/memory" "github.com/rusenask/keel/provider" "github.com/rusenask/keel/types" + "github.com/rusenask/keel/util/codecs" "github.com/rusenask/keel/util/image" "testing" @@ -39,7 +43,9 @@ func TestCheckDeployment(t *testing.T) { }, }, } - providers := provider.New([]provider.Provider{fp}) + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + am := approvals.New(mem, codecs.DefaultSerializer()) + providers := provider.New([]provider.Provider{fp}, am) // returning some sha frc := &fakeRegistryClient{ diff --git a/trigger/poll/watcher_test.go b/trigger/poll/watcher_test.go index c74aefcf..51717753 100644 --- a/trigger/poll/watcher_test.go +++ b/trigger/poll/watcher_test.go @@ -2,10 +2,14 @@ package poll import ( "testing" + "time" + "github.com/rusenask/keel/approvals" + "github.com/rusenask/keel/cache/memory" "github.com/rusenask/keel/provider" "github.com/rusenask/keel/registry" "github.com/rusenask/keel/types" + "github.com/rusenask/keel/util/codecs" "github.com/rusenask/keel/util/image" ) @@ -53,7 +57,9 @@ func (p *fakeProvider) TrackedImages() ([]*types.TrackedImage, error) { func TestWatchTagJob(t *testing.T) { fp := &fakeProvider{} - providers := provider.New([]provider.Provider{fp}) + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + am := approvals.New(mem, codecs.DefaultSerializer()) + providers := provider.New([]provider.Provider{fp}, am) frc := &fakeRegistryClient{ digestToReturn: "sha256:0604af35299dd37ff23937d115d103532948b568a9dd8197d14c256a8ab8b0bb", @@ -96,7 +102,9 @@ func TestWatchTagJob(t *testing.T) { func TestWatchTagJobLatest(t *testing.T) { fp := &fakeProvider{} - providers := provider.New([]provider.Provider{fp}) + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + am := approvals.New(mem, codecs.DefaultSerializer()) + providers := provider.New([]provider.Provider{fp}, am) frc := &fakeRegistryClient{ digestToReturn: "sha256:0604af35299dd37ff23937d115d103532948b568a9dd8197d14c256a8ab8b0bb", @@ -139,7 +147,9 @@ func TestWatchTagJobLatest(t *testing.T) { func TestWatchAllTagsJob(t *testing.T) { fp := &fakeProvider{} - providers := provider.New([]provider.Provider{fp}) + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + am := approvals.New(mem, codecs.DefaultSerializer()) + providers := provider.New([]provider.Provider{fp}, am) frc := &fakeRegistryClient{ tagsToReturn: []string{"1.1.2", "1.1.3", "0.9.1"}, @@ -171,7 +181,9 @@ func TestWatchAllTagsJob(t *testing.T) { func TestWatchAllTagsJobCurrentLatest(t *testing.T) { fp := &fakeProvider{} - providers := provider.New([]provider.Provider{fp}) + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + am := approvals.New(mem, codecs.DefaultSerializer()) + providers := provider.New([]provider.Provider{fp}, am) frc := &fakeRegistryClient{ tagsToReturn: []string{"1.1.2", "1.1.3", "0.9.1"}, diff --git a/trigger/pubsub/manager_test.go b/trigger/pubsub/manager_test.go index f53f50ba..dc87aea2 100644 --- a/trigger/pubsub/manager_test.go +++ b/trigger/pubsub/manager_test.go @@ -1,12 +1,16 @@ package pubsub import ( - "golang.org/x/net/context" "sync" "time" + "golang.org/x/net/context" + + "github.com/rusenask/keel/approvals" + "github.com/rusenask/keel/cache/memory" "github.com/rusenask/keel/provider" "github.com/rusenask/keel/types" + "github.com/rusenask/keel/util/codecs" "github.com/rusenask/keel/util/image" "testing" @@ -62,7 +66,10 @@ func TestCheckDeployment(t *testing.T) { }, }, } - providers := provider.New([]provider.Provider{fp}) + + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + am := approvals.New(mem, codecs.DefaultSerializer()) + providers := provider.New([]provider.Provider{fp}, am) fs := &fakeSubscriber{} mng := &DefaultManager{ diff --git a/trigger/pubsub/pubsub_test.go b/trigger/pubsub/pubsub_test.go index 7394d656..5a9c95cf 100644 --- a/trigger/pubsub/pubsub_test.go +++ b/trigger/pubsub/pubsub_test.go @@ -2,11 +2,15 @@ package pubsub import ( "encoding/json" + "time" "cloud.google.com/go/pubsub" "golang.org/x/net/context" + "github.com/rusenask/keel/approvals" + "github.com/rusenask/keel/cache/memory" "github.com/rusenask/keel/provider" + "github.com/rusenask/keel/util/codecs" "testing" ) @@ -21,7 +25,9 @@ func fakeDoneFunc(id string, done bool) { func TestCallback(t *testing.T) { fp := &fakeProvider{} - providers := provider.New([]provider.Provider{fp}) + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + am := approvals.New(mem, codecs.DefaultSerializer()) + providers := provider.New([]provider.Provider{fp}, am) sub := &PubsubSubscriber{disableAck: true, providers: providers} dataMsg := &Message{Action: "INSERT", Tag: "gcr.io/v2-namespace/hello-world:1.1.1"} @@ -46,7 +52,9 @@ func TestCallback(t *testing.T) { func TestCallbackTagNotSemver(t *testing.T) { fp := &fakeProvider{} - providers := provider.New([]provider.Provider{fp}) + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + am := approvals.New(mem, codecs.DefaultSerializer()) + providers := provider.New([]provider.Provider{fp}, am) sub := &PubsubSubscriber{disableAck: true, providers: providers} dataMsg := &Message{Action: "INSERT", Tag: "gcr.io/stemnapp/alpine-website:latest"} @@ -72,7 +80,9 @@ func TestCallbackTagNotSemver(t *testing.T) { func TestCallbackNoTag(t *testing.T) { fp := &fakeProvider{} - providers := provider.New([]provider.Provider{fp}) + mem := memory.NewMemoryCache(100*time.Millisecond, 100*time.Millisecond, 10*time.Millisecond) + am := approvals.New(mem, codecs.DefaultSerializer()) + providers := provider.New([]provider.Provider{fp}, am) sub := &PubsubSubscriber{disableAck: true, providers: providers} dataMsg := &Message{Action: "INSERT", Tag: "gcr.io/stemnapp/alpine-website"} @@ -92,5 +102,4 @@ func TestCallbackNoTag(t *testing.T) { if fp.submitted[0].Repository.Tag != "latest" { t.Errorf("expected repo tag %s but got %s", "latest", fp.submitted[0].Repository.Tag) } - } diff --git a/types/notification_jsonenums.go b/types/notification_jsonenums.go index ea0f39d6..4f6350a0 100644 --- a/types/notification_jsonenums.go +++ b/types/notification_jsonenums.go @@ -13,6 +13,8 @@ var ( "PostProviderSubmitNotification": PostProviderSubmitNotification, "NotificationPreDeploymentUpdate": NotificationPreDeploymentUpdate, "NotificationDeploymentUpdate": NotificationDeploymentUpdate, + "NotificationPreReleaseUpdate": NotificationPreReleaseUpdate, + "NotificationReleaseUpdate": NotificationReleaseUpdate, } _NotificationValueToName = map[Notification]string{ @@ -20,6 +22,8 @@ var ( PostProviderSubmitNotification: "PostProviderSubmitNotification", NotificationPreDeploymentUpdate: "NotificationPreDeploymentUpdate", NotificationDeploymentUpdate: "NotificationDeploymentUpdate", + NotificationPreReleaseUpdate: "NotificationPreReleaseUpdate", + NotificationReleaseUpdate: "NotificationReleaseUpdate", } ) @@ -31,6 +35,8 @@ func init() { interface{}(PostProviderSubmitNotification).(fmt.Stringer).String(): PostProviderSubmitNotification, interface{}(NotificationPreDeploymentUpdate).(fmt.Stringer).String(): NotificationPreDeploymentUpdate, interface{}(NotificationDeploymentUpdate).(fmt.Stringer).String(): NotificationDeploymentUpdate, + interface{}(NotificationPreReleaseUpdate).(fmt.Stringer).String(): NotificationPreReleaseUpdate, + interface{}(NotificationReleaseUpdate).(fmt.Stringer).String(): NotificationReleaseUpdate, } } } diff --git a/types/providertype_jsonenums.go b/types/providertype_jsonenums.go new file mode 100644 index 00000000..55319561 --- /dev/null +++ b/types/providertype_jsonenums.go @@ -0,0 +1,59 @@ +// generated by jsonenums -type=ProviderType; DO NOT EDIT + +package types + +import ( + "encoding/json" + "fmt" +) + +var ( + _ProviderTypeNameToValue = map[string]ProviderType{ + "ProviderTypeUnknown": ProviderTypeUnknown, + "ProviderTypeKubernetes": ProviderTypeKubernetes, + "ProviderTypeHelm": ProviderTypeHelm, + } + + _ProviderTypeValueToName = map[ProviderType]string{ + ProviderTypeUnknown: "ProviderTypeUnknown", + ProviderTypeKubernetes: "ProviderTypeKubernetes", + ProviderTypeHelm: "ProviderTypeHelm", + } +) + +func init() { + var v ProviderType + if _, ok := interface{}(v).(fmt.Stringer); ok { + _ProviderTypeNameToValue = map[string]ProviderType{ + interface{}(ProviderTypeUnknown).(fmt.Stringer).String(): ProviderTypeUnknown, + interface{}(ProviderTypeKubernetes).(fmt.Stringer).String(): ProviderTypeKubernetes, + interface{}(ProviderTypeHelm).(fmt.Stringer).String(): ProviderTypeHelm, + } + } +} + +// MarshalJSON is generated so ProviderType satisfies json.Marshaler. +func (r ProviderType) MarshalJSON() ([]byte, error) { + if s, ok := interface{}(r).(fmt.Stringer); ok { + return json.Marshal(s.String()) + } + s, ok := _ProviderTypeValueToName[r] + if !ok { + return nil, fmt.Errorf("invalid ProviderType: %d", r) + } + return json.Marshal(s) +} + +// UnmarshalJSON is generated so ProviderType satisfies json.Unmarshaler. +func (r *ProviderType) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return fmt.Errorf("ProviderType should be a string, got %s", data) + } + v, ok := _ProviderTypeNameToValue[s] + if !ok { + return fmt.Errorf("invalid ProviderType %q", s) + } + *r = v + return nil +} diff --git a/types/types.go b/types/types.go index 1c53ecb7..46ca34f9 100644 --- a/types/types.go +++ b/types/types.go @@ -1,7 +1,9 @@ +// Package types holds most of the types used across Keel //go:generate jsonenums -type=Notification //go:generate jsonenums -type=Level //go:generate jsonenums -type=PolicyType //go:generate jsonenums -type=TriggerType +//go:generate jsonenums -type=ProviderType package types import ( @@ -30,6 +32,15 @@ const KeelPollDefaultSchedule = "@every 1m" // KeelDigestAnnotation - digest annotation const KeelDigestAnnotation = "keel.sh/digest" +// KeelMinimumApprovalsLabel - min approvals +const KeelMinimumApprovalsLabel = "keel.sh/approvals" + +// KeelApprovalDeadlineLabel - approval deadline +const KeelApprovalDeadlineLabel = "keel.sh/approvalDeadline" + +// KeelApprovalDeadlineDefault - default deadline in hours +const KeelApprovalDeadlineDefault = 24 + // Repository - represents main docker repository fields that // keel cares about type Repository struct { @@ -230,3 +241,119 @@ func (l Level) Color() string { return "#9E9E9E" } } + +// ProviderType - provider type used to differentiate different providers +// when used with plugins +type ProviderType int + +// Known provider types +const ( + ProviderTypeUnknown ProviderType = iota + ProviderTypeKubernetes + ProviderTypeHelm +) + +func (t ProviderType) String() string { + switch t { + case ProviderTypeUnknown: + return "unknown" + case ProviderTypeKubernetes: + return "kubernetes" + case ProviderTypeHelm: + return "helm" + default: + return "" + } +} + +// Approval used to store and track updates +type Approval struct { + // Provider name - Kubernetes/Helm + Provider ProviderType `json:"provider,omitempty"` + + // Identifier is used to inform user about specific + // Helm release or k8s deployment + // ie: k8s / + // helm: / + Identifier string `json:"identifier,omitempty"` + + // Event that triggered evaluation + Event *Event `json:"event,omitempty"` + + Message string `json:"message,omitempty"` + + CurrentVersion string `json:"currentVersion,omitempty"` + NewVersion string `json:"newVersion,omitempty"` + + // Requirements for the update such as number of votes + // and deadline + VotesRequired int `json:"votesRequired,omitempty"` + VotesReceived int `json:"votesReceived,omitempty"` + + // Voters is a list of voter + // IDs for audit + Voters []string `json:"voters,omitempty"` + + // Explicitly rejected approval + // can be set directly by user + // so even if deadline is not reached approval + // could be turned down + Rejected bool `json:"rejected,omitempty"` + + // Deadline for this request + Deadline time.Time `json:"deadline,omitempty"` + + // When this approval was created + CreatedAt time.Time `json:"createdAt,omitempty"` + // WHen this approval was updated + UpdatedAt time.Time `json:"updatedAt,omitempty"` +} + +// ApprovalStatus - approval status type used in approvals +// to determine whether it was rejected/approved or still pending +type ApprovalStatus int + +// Available approval status types +const ( + ApprovalStatusUnknown ApprovalStatus = iota + ApprovalStatusPending + ApprovalStatusApproved + ApprovalStatusRejected +) + +func (s ApprovalStatus) String() string { + switch s { + case ApprovalStatusPending: + return "pending" + case ApprovalStatusApproved: + return "approved" + case ApprovalStatusRejected: + return "rejected" + default: + return "unknown" + } +} + +// Status - returns current approval status +func (a *Approval) Status() ApprovalStatus { + if a.Rejected { + return ApprovalStatusRejected + } + + if a.VotesReceived >= a.VotesRequired { + return ApprovalStatusApproved + } + + return ApprovalStatusPending +} + +// Expired - checks if approval is already expired +func (a *Approval) Expired() bool { + return a.Deadline.Before(time.Now()) +} + +// Delta of what's changed +// ie: webhookrelay/webhook-demo:0.15.0 -> webhookrelay/webhook-demo:0.16.0 +func (a *Approval) Delta() string { + return fmt.Sprintf("%s -> %s", a.CurrentVersion, a.NewVersion) +} diff --git a/types/types_test.go b/types/types_test.go index a5ce2490..a9ce3c5a 100644 --- a/types/types_test.go +++ b/types/types_test.go @@ -2,6 +2,7 @@ package types import ( "testing" + "time" ) func TestParsePolicy(t *testing.T) { @@ -104,3 +105,24 @@ func TestVersion_String(t *testing.T) { }) } } + +func TestExpired(t *testing.T) { + aprv := Approval{ + Deadline: time.Now().Add(-5 * time.Second), + } + + if !aprv.Expired() { + t.Errorf("expected approval to be expired") + } +} + +func TestNotExpired(t *testing.T) { + aprv := Approval{ + Deadline: time.Now().Add(5 * time.Second), + } + + if aprv.Expired() { + t.Errorf("expected approval to be not expired") + + } +} diff --git a/util/codecs/codecs.go b/util/codecs/codecs.go new file mode 100644 index 00000000..ab6890c5 --- /dev/null +++ b/util/codecs/codecs.go @@ -0,0 +1,84 @@ +package codecs + +import ( + "bytes" + "encoding/gob" + "encoding/json" + "sync" +) + +var bufferPool = sync.Pool{New: allocBuffer} + +func allocBuffer() interface{} { + return &bytes.Buffer{} +} + +func getBuffer() *bytes.Buffer { + return bufferPool.Get().(*bytes.Buffer) +} + +func releaseBuffer(v *bytes.Buffer) { + v.Reset() + v.Grow(0) + bufferPool.Put(v) +} + +// Serializer - generic serializer interface +type Serializer interface { + Encode(source interface{}) ([]byte, error) + Decode(data []byte, target interface{}) error +} + +// DefaultSerializer - returns default serializer +func DefaultSerializer() Serializer { + return &GobSerializer{} +} + +// GobSerializer - gob based serializer +type GobSerializer struct{} + +// Encode - encodes source into bytes using Gob encoder +func (s *GobSerializer) Encode(source interface{}) ([]byte, error) { + buf := getBuffer() + defer releaseBuffer(buf) + enc := gob.NewEncoder(buf) + err := enc.Encode(source) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} + +// Decode - decodes given bytes into target struct +func (s *GobSerializer) Decode(data []byte, target interface{}) error { + buf := bytes.NewBuffer(data) + dec := gob.NewDecoder(buf) + return dec.Decode(target) +} + +// JSONSerializer - JSON based serializer +type JSONSerializer struct{} + +// Encode - encodes source into bytes using JSON encoder +func (s *JSONSerializer) Encode(source interface{}) ([]byte, error) { + buf := getBuffer() + defer releaseBuffer(buf) + enc := json.NewEncoder(buf) + err := enc.Encode(source) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} + +// Decode - decodes given bytes into target struct +func (s *JSONSerializer) Decode(data []byte, target interface{}) error { + buf := bytes.NewBuffer(data) + dec := json.NewDecoder(buf) + return dec.Decode(target) +} + +// Type - shows serializer type +func (s *JSONSerializer) Type() string { + return "JSON" +} diff --git a/util/testing/testing.go b/util/testing/testing.go index 5f669eed..1a42d28c 100644 --- a/util/testing/testing.go +++ b/util/testing/testing.go @@ -1,6 +1,7 @@ package testing import ( + core_v1 "k8s.io/client-go/kubernetes/typed/core/v1" "k8s.io/client-go/pkg/api/v1" "k8s.io/client-go/pkg/apis/extensions/v1beta1" ) @@ -55,3 +56,9 @@ func (i *FakeK8sImplementer) Secret(namespace, name string) (*v1.Secret, error) func (i *FakeK8sImplementer) Pods(namespace, labelSelector string) (*v1.PodList, error) { return i.AvailablePods, nil } + +// ConfigMaps - returns nothing (not implemented) +func (i *FakeK8sImplementer) ConfigMaps(namespace string) core_v1.ConfigMapInterface { + panic("not implemented") + return nil +} diff --git a/vendor/github.com/Sirupsen/logrus/CHANGELOG.md b/vendor/github.com/Sirupsen/logrus/CHANGELOG.md index c443aed0..8236d8b6 100644 --- a/vendor/github.com/Sirupsen/logrus/CHANGELOG.md +++ b/vendor/github.com/Sirupsen/logrus/CHANGELOG.md @@ -1,3 +1,7 @@ +# 1.0.3 + +* Replace example files with testable examples + # 1.0.2 * bug: quote non-string values in text formatter (#583) diff --git a/vendor/github.com/Sirupsen/logrus/README.md b/vendor/github.com/Sirupsen/logrus/README.md index 4f5ce576..5f656c3e 100644 --- a/vendor/github.com/Sirupsen/logrus/README.md +++ b/vendor/github.com/Sirupsen/logrus/README.md @@ -247,6 +247,7 @@ Note: Syslog hook also support connecting to local syslog (Ex. "/dev/log" or "/v | [Airbrake](https://github.com/gemnasium/logrus-airbrake-hook) | Send errors to the Airbrake API V3. Uses the official [`gobrake`](https://github.com/airbrake/gobrake) behind the scenes. | | [Amazon Kinesis](https://github.com/evalphobia/logrus_kinesis) | Hook for logging to [Amazon Kinesis](https://aws.amazon.com/kinesis/) | | [Amqp-Hook](https://github.com/vladoatanasov/logrus_amqp) | Hook for logging to Amqp broker (Like RabbitMQ) | +| [AzureTableHook](https://github.com/kpfaulkner/azuretablehook/) | Hook for logging to Azure Table Storage| | [Bugsnag](https://github.com/Shopify/logrus-bugsnag/blob/master/bugsnag.go) | Send errors to the Bugsnag exception tracking service. | | [DeferPanic](https://github.com/deferpanic/dp-logrus) | Hook for logging to DeferPanic | | [Discordrus](https://github.com/kz/discordrus) | Hook for logging to [Discord](https://discordapp.com/) | @@ -260,7 +261,7 @@ Note: Syslog hook also support connecting to local syslog (Ex. "/dev/log" or "/v | [InfluxDB](https://github.com/Abramovic/logrus_influxdb) | Hook for logging to influxdb | | [Influxus](http://github.com/vlad-doru/influxus) | Hook for concurrently logging to [InfluxDB](http://influxdata.com/) | | [Journalhook](https://github.com/wercker/journalhook) | Hook for logging to `systemd-journald` | -| [KafkaLogrus](https://github.com/goibibo/KafkaLogrus) | Hook for logging to kafka | +| [KafkaLogrus](https://github.com/tracer0tong/kafkalogrus) | Hook for logging to Kafka | | [LFShook](https://github.com/rifflock/lfshook) | Hook for logging to the local filesystem | | [Logentries](https://github.com/jcftang/logentriesrus) | Hook for logging to [Logentries](https://logentries.com/) | | [Logentrus](https://github.com/puddingfactory/logentrus) | Hook for logging to [Logentries](https://logentries.com/) | @@ -285,6 +286,7 @@ Note: Syslog hook also support connecting to local syslog (Ex. "/dev/log" or "/v | [Sumorus](https://github.com/doublefree/sumorus) | Hook for logging to [SumoLogic](https://www.sumologic.com/)| | [Syslog](https://github.com/sirupsen/logrus/blob/master/hooks/syslog/syslog.go) | Send errors to remote syslog server. Uses standard library `log/syslog` behind the scenes. | | [Syslog TLS](https://github.com/shinji62/logrus-syslog-ng) | Send errors to remote syslog server with TLS support. | +| [Telegram](https://github.com/rossmcdonald/telegram_hook) | Hook for logging errors to [Telegram](https://telegram.org/) | | [TraceView](https://github.com/evalphobia/logrus_appneta) | Hook for logging to [AppNeta TraceView](https://www.appneta.com/products/traceview/) | | [Typetalk](https://github.com/dragon3/logrus-typetalk-hook) | Hook for logging to [Typetalk](https://www.typetalk.in/) | | [logz.io](https://github.com/ripcurld00d/logrus-logzio-hook) | Hook for logging to [logz.io](https://logz.io), a Log as a Service using Logstash | diff --git a/vendor/github.com/Sirupsen/logrus/entry.go b/vendor/github.com/Sirupsen/logrus/entry.go index 5bf582ef..1fad45e0 100644 --- a/vendor/github.com/Sirupsen/logrus/entry.go +++ b/vendor/github.com/Sirupsen/logrus/entry.go @@ -94,7 +94,10 @@ func (entry Entry) log(level Level, msg string) { entry.Level = level entry.Message = msg - if err := entry.Logger.Hooks.Fire(level, &entry); err != nil { + entry.Logger.mu.Lock() + err := entry.Logger.Hooks.Fire(level, &entry) + entry.Logger.mu.Unlock() + if err != nil { entry.Logger.mu.Lock() fmt.Fprintf(os.Stderr, "Failed to fire hook: %v\n", err) entry.Logger.mu.Unlock() diff --git a/vendor/github.com/Sirupsen/logrus/examples/basic/basic.go b/vendor/github.com/Sirupsen/logrus/examples/basic/basic.go deleted file mode 100644 index 3e112b4e..00000000 --- a/vendor/github.com/Sirupsen/logrus/examples/basic/basic.go +++ /dev/null @@ -1,59 +0,0 @@ -package main - -import ( - "github.com/sirupsen/logrus" - // "os" -) - -var log = logrus.New() - -func init() { - log.Formatter = new(logrus.JSONFormatter) - log.Formatter = new(logrus.TextFormatter) // default - - // file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY, 0666) - // if err == nil { - // log.Out = file - // } else { - // log.Info("Failed to log to file, using default stderr") - // } - - log.Level = logrus.DebugLevel -} - -func main() { - defer func() { - err := recover() - if err != nil { - log.WithFields(logrus.Fields{ - "omg": true, - "err": err, - "number": 100, - }).Fatal("The ice breaks!") - } - }() - - log.WithFields(logrus.Fields{ - "animal": "walrus", - "number": 8, - }).Debug("Started observing beach") - - log.WithFields(logrus.Fields{ - "animal": "walrus", - "size": 10, - }).Info("A group of walrus emerges from the ocean") - - log.WithFields(logrus.Fields{ - "omg": true, - "number": 122, - }).Warn("The group's number increased tremendously!") - - log.WithFields(logrus.Fields{ - "temperature": -4, - }).Debug("Temperature changes") - - log.WithFields(logrus.Fields{ - "animal": "orca", - "size": 9009, - }).Panic("It's over 9000!") -} diff --git a/vendor/github.com/Sirupsen/logrus/examples/hook/hook.go b/vendor/github.com/Sirupsen/logrus/examples/hook/hook.go deleted file mode 100644 index c8470c38..00000000 --- a/vendor/github.com/Sirupsen/logrus/examples/hook/hook.go +++ /dev/null @@ -1,30 +0,0 @@ -package main - -import ( - "github.com/sirupsen/logrus" - "gopkg.in/gemnasium/logrus-airbrake-hook.v2" -) - -var log = logrus.New() - -func init() { - log.Formatter = new(logrus.TextFormatter) // default - log.Hooks.Add(airbrake.NewHook(123, "xyz", "development")) -} - -func main() { - log.WithFields(logrus.Fields{ - "animal": "walrus", - "size": 10, - }).Info("A group of walrus emerges from the ocean") - - log.WithFields(logrus.Fields{ - "omg": true, - "number": 122, - }).Warn("The group's number increased tremendously!") - - log.WithFields(logrus.Fields{ - "omg": true, - "number": 100, - }).Fatal("The ice breaks!") -} diff --git a/vendor/github.com/Sirupsen/logrus/hook_test.go b/vendor/github.com/Sirupsen/logrus/hook_test.go index 13f34cb6..4fea7514 100644 --- a/vendor/github.com/Sirupsen/logrus/hook_test.go +++ b/vendor/github.com/Sirupsen/logrus/hook_test.go @@ -1,6 +1,7 @@ package logrus import ( + "sync" "testing" "github.com/stretchr/testify/assert" @@ -120,3 +121,24 @@ func TestErrorHookShouldFireOnError(t *testing.T) { assert.Equal(t, hook.Fired, true) }) } + +func TestAddHookRace(t *testing.T) { + var wg sync.WaitGroup + wg.Add(2) + hook := new(ErrorHook) + LogAndAssertJSON(t, func(log *Logger) { + go func() { + defer wg.Done() + log.AddHook(hook) + }() + go func() { + defer wg.Done() + log.Error("test") + }() + wg.Wait() + }, func(fields Fields) { + // the line may have been logged + // before the hook was added, so we can't + // actually assert on the hook + }) +} diff --git a/vendor/github.com/Sirupsen/logrus/logger.go b/vendor/github.com/Sirupsen/logrus/logger.go index 2acab050..fdaf8a65 100644 --- a/vendor/github.com/Sirupsen/logrus/logger.go +++ b/vendor/github.com/Sirupsen/logrus/logger.go @@ -315,3 +315,9 @@ func (logger *Logger) level() Level { func (logger *Logger) SetLevel(level Level) { atomic.StoreUint32((*uint32)(&logger.Level), uint32(level)) } + +func (logger *Logger) AddHook(hook Hook) { + logger.mu.Lock() + defer logger.mu.Unlock() + logger.Hooks.Add(hook) +} diff --git a/vendor/github.com/gorilla/mux/README.md b/vendor/github.com/gorilla/mux/README.md index 56c67134..8dcd7188 100644 --- a/vendor/github.com/gorilla/mux/README.md +++ b/vendor/github.com/gorilla/mux/README.md @@ -15,7 +15,7 @@ The name mux stands for "HTTP request multiplexer". Like the standard `http.Serv * It implements the `http.Handler` interface so it is compatible with the standard `http.ServeMux`. * Requests can be matched based on URL host, path, path prefix, schemes, header and query values, HTTP methods or using custom matchers. -* URL hosts and paths can have variables with an optional regular expression. +* URL hosts, paths and query values can have variables with an optional regular expression. * Registered URLs can be built, or "reversed", which helps maintaining references to resources. * Routes can be used as subrouters: nested routes are only tested if the parent route matches. This is useful to define groups of routes that share common conditions like a host, a path prefix or other repeated attributes. As a bonus, this optimizes request matching. @@ -24,9 +24,9 @@ The name mux stands for "HTTP request multiplexer". Like the standard `http.Serv * [Install](#install) * [Examples](#examples) * [Matching Routes](#matching-routes) -* [Listing Routes](#listing-routes) * [Static Files](#static-files) * [Registered URLs](#registered-urls) +* [Walking Routes](#walking-routes) * [Full Example](#full-example) --- @@ -168,7 +168,6 @@ s.HandleFunc("/{key}/", ProductHandler) // "/products/{key}/details" s.HandleFunc("/{key}/details", ProductDetailsHandler) ``` - ### Listing Routes Routes on a mux can be listed using the Router.Walk method—useful for generating documentation: @@ -191,9 +190,9 @@ func handler(w http.ResponseWriter, r *http.Request) { func main() { r := mux.NewRouter() r.HandleFunc("/", handler) - r.Methods("POST").HandleFunc("/products", handler) - r.Methods("GET").HandleFunc("/articles", handler) - r.Methods("GET", "PUT").HandleFunc("/articles/{id}", handler) + r.HandleFunc("/products", handler).Methods("POST") + r.HandleFunc("/articles", handler).Methods("GET") + r.HandleFunc("/articles/{id}", handler).Methods("GET", "PUT") r.Walk(func(route *mux.Route, router *mux.Router, ancestors []*mux.Route) error { t, err := route.GetPathTemplate() if err != nil { @@ -269,19 +268,21 @@ url, err := r.Get("article").URL("category", "technology", "id", "42") "/articles/technology/42" ``` -This also works for host variables: +This also works for host and query value variables: ```go r := mux.NewRouter() r.Host("{subdomain}.domain.com"). Path("/articles/{category}/{id:[0-9]+}"). + Queries("filter", "{filter}"). HandlerFunc(ArticleHandler). Name("article") -// url.String() will be "http://news.domain.com/articles/technology/42" +// url.String() will be "http://news.domain.com/articles/technology/42?filter=gorilla" url, err := r.Get("article").URL("subdomain", "news", "category", "technology", - "id", "42") + "id", "42", + "filter", "gorilla") ``` All variables defined in the route are required, and their values must conform to the corresponding patterns. These requirements guarantee that a generated URL will always match a registered route -- the only exception is for explicitly defined "build-only" routes which never match. @@ -319,6 +320,37 @@ url, err := r.Get("article").URL("subdomain", "news", "id", "42") ``` +### Walking Routes + +The `Walk` function on `mux.Router` can be used to visit all of the routes that are registered on a router. For example, +the following prints all of the registered routes: + +```go +r := mux.NewRouter() +r.HandleFunc("/", handler) +r.HandleFunc("/products", handler).Methods("POST") +r.HandleFunc("/articles", handler).Methods("GET") +r.HandleFunc("/articles/{id}", handler).Methods("GET", "PUT") +r.Walk(func(route *mux.Route, router *mux.Router, ancestors []*mux.Route) error { + t, err := route.GetPathTemplate() + if err != nil { + return err + } + // p will contain a regular expression that is compatible with regular expressions in Perl, Python, and other languages. + // For example, the regular expression for path '/articles/{id}' will be '^/articles/(?P[^/]+)$'. + p, err := route.GetPathRegexp() + if err != nil { + return err + } + m, err := route.GetMethods() + if err != nil { + return err + } + fmt.Println(strings.Join(m, ","), t, p) + return nil +}) +``` + ## Full Example Here's a complete, runnable example of a small `mux` based server: diff --git a/vendor/github.com/gorilla/mux/doc.go b/vendor/github.com/gorilla/mux/doc.go index 00daf4a7..cce30b2f 100644 --- a/vendor/github.com/gorilla/mux/doc.go +++ b/vendor/github.com/gorilla/mux/doc.go @@ -12,8 +12,8 @@ or other conditions. The main features are: * Requests can be matched based on URL host, path, path prefix, schemes, header and query values, HTTP methods or using custom matchers. - * URL hosts and paths can have variables with an optional regular - expression. + * URL hosts, paths and query values can have variables with an optional + regular expression. * Registered URLs can be built, or "reversed", which helps maintaining references to resources. * Routes can be used as subrouters: nested routes are only tested if the @@ -188,18 +188,20 @@ key/value pairs for the route variables. For the previous route, we would do: "/articles/technology/42" -This also works for host variables: +This also works for host and query value variables: r := mux.NewRouter() r.Host("{subdomain}.domain.com"). Path("/articles/{category}/{id:[0-9]+}"). + Queries("filter", "{filter}"). HandlerFunc(ArticleHandler). Name("article") - // url.String() will be "http://news.domain.com/articles/technology/42" + // url.String() will be "http://news.domain.com/articles/technology/42?filter=gorilla" url, err := r.Get("article").URL("subdomain", "news", "category", "technology", - "id", "42") + "id", "42", + "filter", "gorilla") All variables defined in the route are required, and their values must conform to the corresponding patterns. These requirements guarantee that a diff --git a/vendor/github.com/gorilla/mux/mux.go b/vendor/github.com/gorilla/mux/mux.go index d66ec384..fb69196d 100644 --- a/vendor/github.com/gorilla/mux/mux.go +++ b/vendor/github.com/gorilla/mux/mux.go @@ -13,6 +13,10 @@ import ( "strings" ) +var ( + ErrMethodMismatch = errors.New("method is not allowed") +) + // NewRouter returns a new router instance. func NewRouter() *Router { return &Router{namedRoutes: make(map[string]*Route), KeepContext: false} @@ -39,6 +43,10 @@ func NewRouter() *Router { type Router struct { // Configurable Handler to be used when no route matches. NotFoundHandler http.Handler + + // Configurable Handler to be used when the request method does not match the route. + MethodNotAllowedHandler http.Handler + // Parent route, if this is a subrouter. parent parentRoute // Routes to be matched, in order. @@ -65,6 +73,11 @@ func (r *Router) Match(req *http.Request, match *RouteMatch) bool { } } + if match.MatchErr == ErrMethodMismatch && r.MethodNotAllowedHandler != nil { + match.Handler = r.MethodNotAllowedHandler + return true + } + // Closest match for a router (includes sub-routers) if r.NotFoundHandler != nil { match.Handler = r.NotFoundHandler @@ -105,9 +118,15 @@ func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) { req = setVars(req, match.Vars) req = setCurrentRoute(req, match.Route) } + + if handler == nil && match.MatchErr == ErrMethodMismatch { + handler = methodNotAllowedHandler() + } + if handler == nil { handler = http.NotFoundHandler() } + if !r.KeepContext { defer contextClear(req) } @@ -176,6 +195,13 @@ func (r *Router) UseEncodedPath() *Router { // parentRoute // ---------------------------------------------------------------------------- +func (r *Router) getBuildScheme() string { + if r.parent != nil { + return r.parent.getBuildScheme() + } + return "" +} + // getNamedRoutes returns the map where named routes are registered. func (r *Router) getNamedRoutes() map[string]*Route { if r.namedRoutes == nil { @@ -299,10 +325,6 @@ type WalkFunc func(route *Route, router *Router, ancestors []*Route) error func (r *Router) walk(walkFn WalkFunc, ancestors []*Route) error { for _, t := range r.routes { - if t.regexp == nil || t.regexp.path == nil || t.regexp.path.template == "" { - continue - } - err := walkFn(t, r, ancestors) if err == SkipRouter { continue @@ -312,10 +334,12 @@ func (r *Router) walk(walkFn WalkFunc, ancestors []*Route) error { } for _, sr := range t.matchers { if h, ok := sr.(*Router); ok { + ancestors = append(ancestors, t) err := h.walk(walkFn, ancestors) if err != nil { return err } + ancestors = ancestors[:len(ancestors)-1] } } if h, ok := t.handler.(*Router); ok { @@ -339,6 +363,11 @@ type RouteMatch struct { Route *Route Handler http.Handler Vars map[string]string + + // MatchErr is set to appropriate matching error + // It is set to ErrMethodMismatch if there is a mismatch in + // the request method and route method + MatchErr error } type contextKey int @@ -458,7 +487,7 @@ func mapFromPairsToString(pairs ...string) (map[string]string, error) { return m, nil } -// mapFromPairsToRegex converts variadic string paramers to a +// mapFromPairsToRegex converts variadic string parameters to a // string to regex map. func mapFromPairsToRegex(pairs ...string) (map[string]*regexp.Regexp, error) { length, err := checkPairs(pairs...) @@ -540,3 +569,12 @@ func matchMapWithRegex(toCheck map[string]*regexp.Regexp, toMatch map[string][]s } return true } + +// methodNotAllowed replies to the request with an HTTP status code 405. +func methodNotAllowed(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusMethodNotAllowed) +} + +// methodNotAllowedHandler returns a simple request handler +// that replies to each request with a status code 405. +func methodNotAllowedHandler() http.Handler { return http.HandlerFunc(methodNotAllowed) } diff --git a/vendor/github.com/gorilla/mux/mux_test.go b/vendor/github.com/gorilla/mux/mux_test.go index 19ef5a8c..484fab43 100644 --- a/vendor/github.com/gorilla/mux/mux_test.go +++ b/vendor/github.com/gorilla/mux/mux_test.go @@ -11,6 +11,7 @@ import ( "fmt" "net/http" "net/url" + "reflect" "strings" "testing" ) @@ -35,6 +36,7 @@ type routeTest struct { scheme string // the expected scheme of the built URL host string // the expected host of the built URL path string // the expected path of the built URL + query string // the expected query string of the built URL pathTemplate string // the expected path template of the route hostTemplate string // the expected host template of the route methods []string // the expected route methods @@ -743,6 +745,7 @@ func TestQueries(t *testing.T) { vars: map[string]string{}, host: "", path: "", + query: "foo=bar&baz=ding", shouldMatch: true, }, { @@ -752,6 +755,7 @@ func TestQueries(t *testing.T) { vars: map[string]string{}, host: "", path: "", + query: "foo=bar&baz=ding", pathTemplate: `/api`, hostTemplate: `www.example.com`, shouldMatch: true, @@ -763,6 +767,7 @@ func TestQueries(t *testing.T) { vars: map[string]string{}, host: "", path: "", + query: "foo=bar&baz=ding", pathTemplate: `/api`, hostTemplate: `www.example.com`, shouldMatch: true, @@ -783,6 +788,7 @@ func TestQueries(t *testing.T) { vars: map[string]string{"v1": "bar"}, host: "", path: "", + query: "foo=bar", shouldMatch: true, }, { @@ -792,6 +798,7 @@ func TestQueries(t *testing.T) { vars: map[string]string{"v1": "bar", "v2": "ding"}, host: "", path: "", + query: "foo=bar&baz=ding", shouldMatch: true, }, { @@ -801,6 +808,7 @@ func TestQueries(t *testing.T) { vars: map[string]string{"v1": "10"}, host: "", path: "", + query: "foo=10", shouldMatch: true, }, { @@ -819,6 +827,7 @@ func TestQueries(t *testing.T) { vars: map[string]string{"v1": "1"}, host: "", path: "", + query: "foo=1", shouldMatch: true, }, { @@ -828,6 +837,7 @@ func TestQueries(t *testing.T) { vars: map[string]string{"v1": "1"}, host: "", path: "", + query: "foo=1", shouldMatch: true, }, { @@ -846,6 +856,7 @@ func TestQueries(t *testing.T) { vars: map[string]string{"v1": "1a"}, host: "", path: "", + query: "foo=1a", shouldMatch: true, }, { @@ -864,6 +875,7 @@ func TestQueries(t *testing.T) { vars: map[string]string{"v-1": "bar"}, host: "", path: "", + query: "foo=bar", shouldMatch: true, }, { @@ -873,6 +885,7 @@ func TestQueries(t *testing.T) { vars: map[string]string{"v-1": "bar", "v-2": "ding"}, host: "", path: "", + query: "foo=bar&baz=ding", shouldMatch: true, }, { @@ -882,6 +895,7 @@ func TestQueries(t *testing.T) { vars: map[string]string{"v-1": "10"}, host: "", path: "", + query: "foo=10", shouldMatch: true, }, { @@ -891,6 +905,7 @@ func TestQueries(t *testing.T) { vars: map[string]string{"v-1": "1a"}, host: "", path: "", + query: "foo=1a", shouldMatch: true, }, { @@ -900,6 +915,7 @@ func TestQueries(t *testing.T) { vars: map[string]string{}, host: "", path: "", + query: "foo=", shouldMatch: true, }, { @@ -918,6 +934,7 @@ func TestQueries(t *testing.T) { vars: map[string]string{}, host: "", path: "", + query: "foo=", shouldMatch: true, }, { @@ -945,6 +962,7 @@ func TestQueries(t *testing.T) { vars: map[string]string{"foo": ""}, host: "", path: "", + query: "foo=", shouldMatch: true, }, { @@ -956,6 +974,16 @@ func TestQueries(t *testing.T) { path: "", shouldMatch: false, }, + { + title: "Queries route with pattern, match, escaped value", + route: new(Route).Queries("foo", "{v1}"), + request: newRequest("GET", "http://localhost?foo=%25bar%26%20%2F%3D%3F"), + vars: map[string]string{"v1": "%bar& /=?"}, + host: "", + path: "", + query: "foo=%25bar%26+%2F%3D%3F", + shouldMatch: true, + }, } for _, test := range tests { @@ -1187,6 +1215,28 @@ func TestSubRouter(t *testing.T) { pathTemplate: `/{category}`, shouldMatch: true, }, + { + title: "Build with scheme on parent router", + route: new(Route).Schemes("ftp").Host("google.com").Subrouter().Path("/"), + request: newRequest("GET", "ftp://google.com/"), + scheme: "ftp", + host: "google.com", + path: "/", + pathTemplate: `/`, + hostTemplate: `google.com`, + shouldMatch: true, + }, + { + title: "Prefer scheme on child route when building URLs", + route: new(Route).Schemes("https", "ftp").Host("google.com").Subrouter().Schemes("ftp").Path("/"), + request: newRequest("GET", "ftp://google.com/"), + scheme: "ftp", + host: "google.com", + path: "/", + pathTemplate: `/`, + hostTemplate: `google.com`, + shouldMatch: true, + }, } for _, test := range tests { @@ -1382,11 +1432,55 @@ func TestWalkNested(t *testing.T) { l2 := l1.PathPrefix("/l").Subrouter() l2.Path("/a") - paths := []string{"/g", "/g/o", "/g/o/r", "/g/o/r/i", "/g/o/r/i/l", "/g/o/r/i/l/l", "/g/o/r/i/l/l/a"} + testCases := []struct { + path string + ancestors []*Route + }{ + {"/g", []*Route{}}, + {"/g/o", []*Route{g.parent.(*Route)}}, + {"/g/o/r", []*Route{g.parent.(*Route), o.parent.(*Route)}}, + {"/g/o/r/i", []*Route{g.parent.(*Route), o.parent.(*Route), r.parent.(*Route)}}, + {"/g/o/r/i/l", []*Route{g.parent.(*Route), o.parent.(*Route), r.parent.(*Route), i.parent.(*Route)}}, + {"/g/o/r/i/l/l", []*Route{g.parent.(*Route), o.parent.(*Route), r.parent.(*Route), i.parent.(*Route), l1.parent.(*Route)}}, + {"/g/o/r/i/l/l/a", []*Route{g.parent.(*Route), o.parent.(*Route), r.parent.(*Route), i.parent.(*Route), l1.parent.(*Route), l2.parent.(*Route)}}, + } + + idx := 0 + err := router.Walk(func(route *Route, router *Router, ancestors []*Route) error { + path := testCases[idx].path + tpl := route.regexp.path.template + if tpl != path { + t.Errorf(`Expected %s got %s`, path, tpl) + } + currWantAncestors := testCases[idx].ancestors + if !reflect.DeepEqual(currWantAncestors, ancestors) { + t.Errorf(`Expected %+v got %+v`, currWantAncestors, ancestors) + } + idx++ + return nil + }) + if err != nil { + panic(err) + } + if idx != len(testCases) { + t.Errorf("Expected %d routes, found %d", len(testCases), idx) + } +} + +func TestWalkSubrouters(t *testing.T) { + router := NewRouter() + + g := router.Path("/g").Subrouter() + o := g.PathPrefix("/o").Subrouter() + o.Methods("GET") + o.Methods("PUT") + + // all 4 routes should be matched, but final 2 routes do not have path templates + paths := []string{"/g", "/g/o", "", ""} idx := 0 err := router.Walk(func(route *Route, router *Router, ancestors []*Route) error { path := paths[idx] - tpl := route.regexp.path.template + tpl, _ := route.GetPathTemplate() if tpl != path { t.Errorf(`Expected %s got %s`, path, tpl) } @@ -1492,6 +1586,7 @@ func testRoute(t *testing.T, test routeTest) { route := test.route vars := test.vars shouldMatch := test.shouldMatch + query := test.query shouldRedirect := test.shouldRedirect uri := url.URL{ Scheme: test.scheme, @@ -1561,6 +1656,13 @@ func testRoute(t *testing.T, test routeTest) { return } } + if query != "" { + u, _ := route.URL(mapToPairs(match.Vars)...) + if query != u.RawQuery { + t.Errorf("(%v) URL query not equal: expected %v, got %v", test.title, query, u.RawQuery) + return + } + } if shouldRedirect && match.Handler == nil { t.Errorf("(%v) Did not redirect", test.title) return @@ -1769,3 +1871,42 @@ func newRequest(method, url string) *http.Request { } return req } + +func TestNoMatchMethodErrorHandler(t *testing.T) { + func1 := func(w http.ResponseWriter, r *http.Request) {} + + r := NewRouter() + r.HandleFunc("/", func1).Methods("GET", "POST") + + req, _ := http.NewRequest("PUT", "http://localhost/", nil) + match := new(RouteMatch) + matched := r.Match(req, match) + + if matched { + t.Error("Should not have matched route for methods") + } + + if match.MatchErr != ErrMethodMismatch { + t.Error("Should get ErrMethodMismatch error") + } + + resp := NewRecorder() + r.ServeHTTP(resp, req) + if resp.Code != 405 { + t.Errorf("Expecting code %v", 405) + } + + // Add matching route + r.HandleFunc("/", func1).Methods("PUT") + + match = new(RouteMatch) + matched = r.Match(req, match) + + if !matched { + t.Error("Should have matched route for methods") + } + + if match.MatchErr != nil { + t.Error("Should not have any matching error. Found:", match.MatchErr) + } +} diff --git a/vendor/github.com/gorilla/mux/old_test.go b/vendor/github.com/gorilla/mux/old_test.go index 9bdc5e5d..3751e472 100644 --- a/vendor/github.com/gorilla/mux/old_test.go +++ b/vendor/github.com/gorilla/mux/old_test.go @@ -121,12 +121,7 @@ func TestRouteMatchers(t *testing.T) { var routeMatch RouteMatch matched := router.Match(request, &routeMatch) if matched != shouldMatch { - // Need better messages. :) - if matched { - t.Errorf("Should match.") - } else { - t.Errorf("Should not match.") - } + t.Errorf("Expected: %v\nGot: %v\nRequest: %v %v", shouldMatch, matched, request.Method, url) } if matched { @@ -188,7 +183,6 @@ func TestRouteMatchers(t *testing.T) { match(true) // 2nd route -------------------------------------------------------------- - // Everything match. reset2() match(true) diff --git a/vendor/github.com/gorilla/mux/regexp.go b/vendor/github.com/gorilla/mux/regexp.go index 0189ad34..80d1f785 100644 --- a/vendor/github.com/gorilla/mux/regexp.go +++ b/vendor/github.com/gorilla/mux/regexp.go @@ -35,7 +35,7 @@ func newRouteRegexp(tpl string, matchHost, matchPrefix, matchQuery, strictSlash, // Now let's parse it. defaultPattern := "[^/]+" if matchQuery { - defaultPattern = "[^?&]*" + defaultPattern = ".*" } else if matchHost { defaultPattern = "[^.]+" matchPrefix = false @@ -178,6 +178,9 @@ func (r *routeRegexp) url(values map[string]string) (string, error) { if !ok { return "", fmt.Errorf("mux: missing route variable %q", v) } + if r.matchQuery { + value = url.QueryEscape(value) + } urlValues[k] = value } rv := fmt.Sprintf(r.reverse, urlValues...) diff --git a/vendor/github.com/gorilla/mux/route.go b/vendor/github.com/gorilla/mux/route.go index 56dcbbdc..6863adba 100644 --- a/vendor/github.com/gorilla/mux/route.go +++ b/vendor/github.com/gorilla/mux/route.go @@ -52,12 +52,27 @@ func (r *Route) Match(req *http.Request, match *RouteMatch) bool { if r.buildOnly || r.err != nil { return false } + + var matchErr error + // Match everything. for _, m := range r.matchers { if matched := m.Match(req, match); !matched { + if _, ok := m.(methodMatcher); ok { + matchErr = ErrMethodMismatch + continue + } + matchErr = nil return false } } + + if matchErr != nil { + match.MatchErr = matchErr + return false + } + + match.MatchErr = nil // Yay, we have a match. Let's collect some info about it. if match.Route == nil { match.Route = r @@ -68,6 +83,7 @@ func (r *Route) Match(req *http.Request, match *RouteMatch) bool { if match.Vars == nil { match.Vars = make(map[string]string) } + // Set variables. if r.regexp != nil { r.regexp.setMatch(req, match, r) @@ -482,13 +498,14 @@ func (r *Route) URL(pairs ...string) (*url.URL, error) { return nil, err } var scheme, host, path string + queries := make([]string, 0, len(r.regexp.queries)) if r.regexp.host != nil { if host, err = r.regexp.host.url(values); err != nil { return nil, err } scheme = "http" - if r.buildScheme != "" { - scheme = r.buildScheme + if s := r.getBuildScheme(); s != "" { + scheme = s } } if r.regexp.path != nil { @@ -496,10 +513,18 @@ func (r *Route) URL(pairs ...string) (*url.URL, error) { return nil, err } } + for _, q := range r.regexp.queries { + var query string + if query, err = q.url(values); err != nil { + return nil, err + } + queries = append(queries, query) + } return &url.URL{ - Scheme: scheme, - Host: host, - Path: path, + Scheme: scheme, + Host: host, + Path: path, + RawQuery: strings.Join(queries, "&"), }, nil } @@ -525,8 +550,8 @@ func (r *Route) URLHost(pairs ...string) (*url.URL, error) { Scheme: "http", Host: host, } - if r.buildScheme != "" { - u.Scheme = r.buildScheme + if s := r.getBuildScheme(); s != "" { + u.Scheme = s } return u, nil } @@ -640,11 +665,22 @@ func (r *Route) buildVars(m map[string]string) map[string]string { // parentRoute allows routes to know about parent host and path definitions. type parentRoute interface { + getBuildScheme() string getNamedRoutes() map[string]*Route getRegexpGroup() *routeRegexpGroup buildVars(map[string]string) map[string]string } +func (r *Route) getBuildScheme() string { + if r.buildScheme != "" { + return r.buildScheme + } + if r.parent != nil { + return r.parent.getBuildScheme() + } + return "" +} + // getNamedRoutes returns the map where named routes are registered. func (r *Route) getNamedRoutes() map[string]*Route { if r.parent == nil { diff --git a/vendor/github.com/rusenask/k8s-kv/LICENSE b/vendor/github.com/rusenask/k8s-kv/LICENSE new file mode 100644 index 00000000..1da4512d --- /dev/null +++ b/vendor/github.com/rusenask/k8s-kv/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2017 Karolis Rusenas + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/rusenask/k8s-kv/README.md b/vendor/github.com/rusenask/k8s-kv/README.md new file mode 100644 index 00000000..06fe6ba5 --- /dev/null +++ b/vendor/github.com/rusenask/k8s-kv/README.md @@ -0,0 +1,94 @@ +# Kubernetes backed KV + +[![GoDoc](https://godoc.org/github.com/rusenask/k8s-kv/kv?status.svg)](https://godoc.org/github.com/rusenask/k8s-kv/kv) + +Use Kubernetes config maps as key/value store! +When to use k8s-kv: +* You have a simple application that has a need to store some configuration and you can't be bothered to set up EBS like volumes or use some fancy external KV store. +* You have a stateless application that suddenly got to store state and you are not into converting + it into full stateless app that will use a proper database. + +When __not to__ use k8s-kv: +* You have a read/write heavy multi-node application (k8s-kv doesn't have cross-app locking). +* You want to store bigger values than 1MB. Even though k8s-kv uses compression for the data stored in bucket - it's wise to not try the limits. It's there because of the limit in Etcd. In this case use something else. + + +## Basics + +Package API: + +``` +// Pyt key/value pair into the store +Put(key string, value []byte) error +// Get value of the specified key +Get(key string) (value []byte, err error) +// Delete key/value pair from the store +Delete(key string) error +// List all key/value pairs under specified prefix +List(prefix string) (data map[string][]byte, err error) +// Delete config map (results in deleted data) +Teardown() error +``` + +## Caveats + +* Don't be silly, you can't put a lot of stuff here. + +## Example + +Usage example: + +1. Get minikube or your favourite k8s environment running. + +2. In your app you will probably want to use this: https://github.com/kubernetes/client-go/tree/master/examples/in-cluster-client-configuration + +3. Get ConfigMaps interface and supply it to this lib: + +``` +package main + +import ( + "fmt" + + "github.com/rusenask/k8s-kv/kv" + + "k8s.io/client-go/kubernetes" + core_v1 "k8s.io/client-go/kubernetes/typed/core/v1" + "k8s.io/client-go/tools/clientcmd" +) + +// get ConfigMapInterface to access config maps in "default" namespace +func getImplementer() (implementer core_v1.ConfigMapInterface) { + cfg, err := clientcmd.BuildConfigFromFlags("", ".kubeconfig") // in your app you could replace it with in-cluster-config + if err != nil { + panic(err) + } + + client, err := kubernetes.NewForConfig(cfg) + if err != nil { + panic(err) + } + + return client.ConfigMaps("default") +} + +func main() { + impl := getImplementer() + + // getting acces to k8s-kv. "my-app" will become a label + // for this config map, this way it's easier to manage configs + // "bucket1" will be config map's name and represent one entry in config maps list + kvdb, err := kv.New(impl, "my-app", "bucket1") + if err != nil { + panic(err) + } + + // insert a key "foo" with value "hello kubernetes world" + kvdb.Put("foo", []byte("hello kubernetes world")) + + // get value of key "foo" + stored, _ := kvdb.Get("foo") + + fmt.Println(string(stored)) +} +``` \ No newline at end of file diff --git a/vendor/github.com/rusenask/k8s-kv/examples/main.go b/vendor/github.com/rusenask/k8s-kv/examples/main.go new file mode 100644 index 00000000..96ae786e --- /dev/null +++ b/vendor/github.com/rusenask/k8s-kv/examples/main.go @@ -0,0 +1,40 @@ +package main + +import ( + "fmt" + + "github.com/rusenask/k8s-kv/kv" + + "k8s.io/client-go/kubernetes" + core_v1 "k8s.io/client-go/kubernetes/typed/core/v1" + "k8s.io/client-go/tools/clientcmd" +) + +func getImplementer() (implementer core_v1.ConfigMapInterface) { + cfg, err := clientcmd.BuildConfigFromFlags("", ".kubeconfig") // in your app you could replace it with in-cluster-config + if err != nil { + panic(err) + } + + client, err := kubernetes.NewForConfig(cfg) + if err != nil { + panic(err) + } + + return client.ConfigMaps("default") +} + +func main() { + impl := getImplementer() + + kvdb, err := kv.New(impl, "my-app", "bucket1") + if err != nil { + panic(err) + } + + kvdb.Put("foo", []byte("hello kubernetes world")) + + stored, _ := kvdb.Get("foo") + + fmt.Println(string(stored)) +} diff --git a/vendor/github.com/rusenask/k8s-kv/kv/doc.go b/vendor/github.com/rusenask/k8s-kv/kv/doc.go new file mode 100644 index 00000000..e129c923 --- /dev/null +++ b/vendor/github.com/rusenask/k8s-kv/kv/doc.go @@ -0,0 +1,16 @@ +/* +Package kv implements a low-level key/value store backed by Kubernetes config maps. +It supports main operations expected from key/value store such as Put, Get, Delete and List. +Operations are protected by an internal mutex and therefore can be safely used inside a single +node application. +Basics +There are only few things worth to know: key/value database is created based on bucket name so in order +to have multiple configMaps - use different bucket names. Teardown() function will remove configMap entry +completely destroying all entries. +Caveats +Since k8s-kv is based on configMaps which are in turn based on Etcd key/value store - all values have a limitation +of 1MB so each bucket in k8s-kv is limited to that size. To overcome it - create more buckets. +If you have multi-node application that is frequently reading/writing to the same buckets - be aware of race +conditions as it doesn't provide any cross-node locking capabilities. +*/ +package kv diff --git a/vendor/github.com/rusenask/k8s-kv/kv/kv.go b/vendor/github.com/rusenask/k8s-kv/kv/kv.go new file mode 100644 index 00000000..43f9cbb0 --- /dev/null +++ b/vendor/github.com/rusenask/k8s-kv/kv/kv.go @@ -0,0 +1,311 @@ +package kv + +import ( + "bytes" + "compress/gzip" + "encoding/base64" + "encoding/gob" + "errors" + "io/ioutil" + "strings" + "sync" + + apierrors "k8s.io/apimachinery/pkg/api/errors" + meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/pkg/api/v1" +) + +func init() { + gob.Register(&internalMap{}) +} + +type internalMap struct { + Data map[string][]byte +} + +// errors +var ( + ErrNotFound = errors.New("not found") +) + +var b64 = base64.StdEncoding + +// KVDB generic kv package interface +type KVDB interface { + Put(key string, value []byte) error + Get(key string) (value []byte, err error) + Delete(key string) error + List(prefix string) (data map[string][]byte, err error) + Teardown() error +} + +// KV provides access to key/value store operations such as Put, Get, Delete, List. +// Entry in ConfigMap is created based on bucket name and total size is limited to 1MB per bucket. +// Operations are protected by an internal mutex so it's safe to use in a single node application. +type KV struct { + app string + bucket string + implementer ConfigMapInterface + mu *sync.RWMutex + serializer Serializer +} + +// ConfigMapInterface implements a subset of Kubernetes original ConfigMapInterface to provide +// required operations for k8s-kv. Main purpose of this interface is to enable easier testing. +type ConfigMapInterface interface { + Get(name string, options meta_v1.GetOptions) (*v1.ConfigMap, error) + Create(cfgMap *v1.ConfigMap) (*v1.ConfigMap, error) + Update(cfgMap *v1.ConfigMap) (*v1.ConfigMap, error) + Delete(name string, options *meta_v1.DeleteOptions) error +} + +// New creates a new instance of KV. Requires prepared ConfigMapInterface (provided by go-client), app and bucket names. +// App name is used as a label to make it easier to distinguish different k8s-kv instances created by separate (or the same) +// application. Bucket name is used to give a name to config map. +func New(implementer ConfigMapInterface, app, bucket string) (*KV, error) { + kv := &KV{ + implementer: implementer, + app: app, + bucket: bucket, + mu: &sync.RWMutex{}, + serializer: DefaultSerializer(), + } + + _, err := kv.getMap() + if err != nil { + return nil, err + } + + return kv, nil + +} + +// Teardown deletes configMap for this bucket. All bucket's data is lost. +func (k *KV) Teardown() error { + return k.implementer.Delete(k.bucket, &meta_v1.DeleteOptions{}) +} + +func (k *KV) getMap() (*v1.ConfigMap, error) { + cfgMap, err := k.implementer.Get(k.bucket, meta_v1.GetOptions{}) + if err != nil { + // creating + if apierrors.IsNotFound(err) { + return k.newConfigMapsObject() + } + return nil, err + } + + if cfgMap.Data == nil { + cfgMap.Data = make(map[string]string) + } + + // it's there, nothing to do + return cfgMap, nil +} + +func encodeInternalMap(serializer Serializer, data map[string][]byte) (string, error) { + var im internalMap + im.Data = data + bts, err := serializer.Encode(&im) + if err != nil { + return "", err + } + + var buf bytes.Buffer + w, err := gzip.NewWriterLevel(&buf, gzip.BestCompression) + if err != nil { + return "", err + } + if _, err = w.Write(bts); err != nil { + return "", err + } + w.Close() + + return b64.EncodeToString(buf.Bytes()), nil +} + +func decodeInternalMap(serializer Serializer, data string) (map[string][]byte, error) { + if data == "" { + empty := make(map[string][]byte) + return empty, nil + } + + b, err := b64.DecodeString(data) + if err != nil { + return nil, err + } + + r, err := gzip.NewReader(bytes.NewReader(b)) + if err != nil { + return nil, err + } + decompressed, err := ioutil.ReadAll(r) + if err != nil { + return nil, err + } + + var im internalMap + + err = serializer.Decode(decompressed, &im) + return im.Data, err +} + +const dataKey = "data" + +func (k *KV) newConfigMapsObject() (*v1.ConfigMap, error) { + + var lbs labels + + lbs.init() + + // apply labels + lbs.set("BUCKET", k.bucket) + lbs.set("APP", k.app) + lbs.set("OWNER", "K8S-KV") + + // create and return configmap object + cfgMap := &v1.ConfigMap{ + ObjectMeta: meta_v1.ObjectMeta{ + Name: k.bucket, + Labels: lbs.toMap(), + }, + Data: map[string]string{ + dataKey: "", + }, + } + + cm, err := k.implementer.Create(cfgMap) + if err != nil { + return nil, err + } + + return cm, nil +} + +func (k *KV) saveInternalMap(cfgMap *v1.ConfigMap, im map[string][]byte) error { + encoded, err := encodeInternalMap(k.serializer, im) + if err != nil { + return err + } + + cfgMap.Data[dataKey] = encoded + + return k.saveMap(cfgMap) +} + +func (k *KV) getInternalMap() (*v1.ConfigMap, map[string][]byte, error) { + cfgMap, err := k.getMap() + if err != nil { + return nil, nil, err + } + + im, err := decodeInternalMap(k.serializer, cfgMap.Data[dataKey]) + if err != nil { + return nil, nil, err + } + return cfgMap, im, nil +} + +func (k *KV) saveMap(cfgMap *v1.ConfigMap) error { + _, err := k.implementer.Update(cfgMap) + return err +} + +// Put saves key/value pair into a bucket. Value can be any []byte value (ie: encoded JSON/GOB) +func (k *KV) Put(key string, value []byte) error { + k.mu.Lock() + defer k.mu.Unlock() + + cfgMap, im, err := k.getInternalMap() + if err != nil { + return err + } + + im[key] = value + + return k.saveInternalMap(cfgMap, im) +} + +// Get retrieves value from the key/value store bucket or returns ErrNotFound error if it was not found. +func (k *KV) Get(key string) (value []byte, err error) { + k.mu.RLock() + defer k.mu.RUnlock() + + _, im, err := k.getInternalMap() + if err != nil { + return + } + + val, ok := im[key] + if !ok { + return []byte(""), ErrNotFound + } + + return val, nil + +} + +// Delete removes entry from the KV store bucket. +func (k *KV) Delete(key string) error { + k.mu.Lock() + defer k.mu.Unlock() + + cfgMap, im, err := k.getInternalMap() + if err != nil { + return err + } + + delete(im, key) + + return k.saveInternalMap(cfgMap, im) +} + +// List retrieves all entries that match specific prefix +func (k *KV) List(prefix string) (data map[string][]byte, err error) { + k.mu.RLock() + defer k.mu.RUnlock() + + _, im, err := k.getInternalMap() + if err != nil { + return + } + + data = make(map[string][]byte) + for key, val := range im { + if strings.HasPrefix(key, prefix) { + data[key] = val + } + } + return +} + +// labels is a map of key value pairs to be included as metadata in a configmap object. +type labels map[string]string + +func (lbs *labels) init() { *lbs = labels(make(map[string]string)) } +func (lbs labels) get(key string) string { return lbs[key] } +func (lbs labels) set(key, val string) { lbs[key] = val } + +func (lbs labels) keys() (ls []string) { + for key := range lbs { + ls = append(ls, key) + } + return +} + +func (lbs labels) match(set labels) bool { + for _, key := range set.keys() { + if lbs.get(key) != set.get(key) { + return false + } + } + return true +} + +func (lbs labels) toMap() map[string]string { return lbs } + +func (lbs *labels) fromMap(kvs map[string]string) { + for k, v := range kvs { + lbs.set(k, v) + } +} diff --git a/vendor/github.com/rusenask/k8s-kv/kv/kv_test.go b/vendor/github.com/rusenask/k8s-kv/kv/kv_test.go new file mode 100644 index 00000000..113ff27a --- /dev/null +++ b/vendor/github.com/rusenask/k8s-kv/kv/kv_test.go @@ -0,0 +1,155 @@ +package kv + +import ( + "fmt" + "testing" + + meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/client-go/pkg/api/v1" +) + +type fakeImplementer struct { + getcfgMap *v1.ConfigMap + + createdMap *v1.ConfigMap + updatedMap *v1.ConfigMap + + deletedName string + deletedOptions *meta_v1.DeleteOptions +} + +func (i *fakeImplementer) Get(name string, options meta_v1.GetOptions) (*v1.ConfigMap, error) { + return i.getcfgMap, nil +} + +func (i *fakeImplementer) Create(cfgMap *v1.ConfigMap) (*v1.ConfigMap, error) { + i.createdMap = cfgMap + return i.createdMap, nil +} + +func (i *fakeImplementer) Update(cfgMap *v1.ConfigMap) (*v1.ConfigMap, error) { + i.updatedMap = cfgMap + return i.updatedMap, nil +} + +func (i *fakeImplementer) Delete(name string, options *meta_v1.DeleteOptions) error { + i.deletedName = name + i.deletedOptions = options + return nil +} + +func TestGetMap(t *testing.T) { + fi := &fakeImplementer{ + getcfgMap: &v1.ConfigMap{ + Data: map[string]string{ + "foo": "bar", + }, + }, + } + kv, err := New(fi, "app", "b1") + if err != nil { + t.Fatalf("failed to get kv: %s", err) + } + + cfgMap, err := kv.getMap() + if err != nil { + t.Fatalf("failed to get map: %s", err) + } + + if cfgMap.Data["foo"] != "bar" { + t.Errorf("cfgMap.Data is missing expected key") + } +} + +func TestGet(t *testing.T) { + + im := map[string][]byte{ + "foo": []byte("bar"), + } + fi := &fakeImplementer{ + getcfgMap: &v1.ConfigMap{ + Data: map[string]string{}, + }, + } + kv, err := New(fi, "app", "b1") + if err != nil { + t.Fatalf("failed to get kv: %s", err) + } + + cfgMap, _ := kv.getMap() + + kv.saveInternalMap(cfgMap, im) + + val, err := kv.Get("foo") + if err != nil { + t.Fatalf("failed to get key: %s", err) + } + + if string(val) != "bar" { + t.Errorf("expected 'bar' but got: %s", string(val)) + } +} + +func TestUpdate(t *testing.T) { + + im := map[string][]byte{ + "a": []byte("a-val"), + "b": []byte("b-val"), + "c": []byte("c-val"), + "d": []byte("d-val"), + } + + fi := &fakeImplementer{ + getcfgMap: &v1.ConfigMap{ + Data: map[string]string{}, + }, + } + kv, err := New(fi, "app", "b1") + if err != nil { + t.Fatalf("failed to get kv: %s", err) + } + + cfgMap, _ := kv.getMap() + + kv.saveInternalMap(cfgMap, im) + + err = kv.Put("b", []byte("updated")) + if err != nil { + t.Fatalf("failed to get key: %s", err) + } + + updatedIm, err := decodeInternalMap(kv.serializer, fi.updatedMap.Data[dataKey]) + if err != nil { + t.Fatalf("failed to decode internal map: %s", err) + } + + if string(updatedIm["b"]) != "updated" { + t.Errorf("b value was not updated") + } + +} + +func TestEncodeInternal(t *testing.T) { + serializer := DefaultSerializer() + + im := make(map[string][]byte) + + for i := 0; i < 100; i++ { + im[fmt.Sprintf("foo-%d", i)] = []byte(fmt.Sprintf("some important data here %d", i)) + } + + encoded, err := encodeInternalMap(serializer, im) + if err != nil { + t.Fatalf("failed to encode map: %s", err) + } + + decoded, err := decodeInternalMap(serializer, encoded) + if err != nil { + t.Fatalf("failed to decode map: %s", err) + } + + if string(decoded["foo-1"]) != "some important data here 1" { + t.Errorf("expected to find 'some important data here 1' but got: %s", string(decoded["foo-1"])) + } + +} diff --git a/vendor/github.com/rusenask/k8s-kv/kv/serialize.go b/vendor/github.com/rusenask/k8s-kv/kv/serialize.go new file mode 100644 index 00000000..584f1bac --- /dev/null +++ b/vendor/github.com/rusenask/k8s-kv/kv/serialize.go @@ -0,0 +1,56 @@ +package kv + +import ( + "bytes" + "encoding/gob" + "sync" +) + +var bufferPool = sync.Pool{New: allocBuffer} + +func allocBuffer() interface{} { + return &bytes.Buffer{} +} + +func getBuffer() *bytes.Buffer { + return bufferPool.Get().(*bytes.Buffer) +} + +func releaseBuffer(v *bytes.Buffer) { + v.Reset() + v.Grow(0) + bufferPool.Put(v) +} + +// Serializer - generic serializer interface +type Serializer interface { + Encode(source interface{}) ([]byte, error) + Decode(data []byte, target interface{}) error +} + +// DefaultSerializer - returns default serializer +func DefaultSerializer() Serializer { + return &GobSerializer{} +} + +// GobSerializer - gob based serializer +type GobSerializer struct{} + +// Encode - encodes source into bytes using Gob encoder +func (s *GobSerializer) Encode(source interface{}) ([]byte, error) { + buf := getBuffer() + defer releaseBuffer(buf) + enc := gob.NewEncoder(buf) + err := enc.Encode(source) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} + +// Decode - decodes given bytes into target struct +func (s *GobSerializer) Decode(data []byte, target interface{}) error { + buf := bytes.NewBuffer(data) + dec := gob.NewDecoder(buf) + return dec.Decode(target) +} diff --git a/vendor/github.com/rusenask/k8s-kv/tests/integration_test.go b/vendor/github.com/rusenask/k8s-kv/tests/integration_test.go new file mode 100644 index 00000000..59bcabf9 --- /dev/null +++ b/vendor/github.com/rusenask/k8s-kv/tests/integration_test.go @@ -0,0 +1,222 @@ +package tests + +import ( + "fmt" + "testing" + + "github.com/rusenask/k8s-kv/kv" + + "k8s.io/client-go/kubernetes" + core_v1 "k8s.io/client-go/kubernetes/typed/core/v1" + "k8s.io/client-go/tools/clientcmd" +) + +const clusterConfig = ".kubeconfig" +const testingNamespace = "default" + +func getImplementer(t *testing.T) (implementer core_v1.ConfigMapInterface) { + cfg, err := clientcmd.BuildConfigFromFlags("", clusterConfig) + if err != nil { + t.Fatalf("failed to get config: %s", err) + } + + client, err := kubernetes.NewForConfig(cfg) + if err != nil { + t.Fatalf("failed to create client: %s", err) + } + + return client.ConfigMaps(testingNamespace) +} + +func TestPut(t *testing.T) { + + impl := getImplementer(t) + kv, err := kv.New(impl, "test", "testput") + if err != nil { + t.Fatalf("failed to create kv: %s", err) + } + defer kv.Teardown() + + err = kv.Put("key", []byte("val")) + if err != nil { + t.Errorf("failed to put: %s", err) + } +} + +func TestPutDirectoryKeys(t *testing.T) { + impl := getImplementer(t) + kv, err := kv.New(impl, "test", "testputdirectorykeys") + if err != nil { + t.Fatalf("failed to create kv: %s", err) + } + defer kv.Teardown() + + err = kv.Put("/somedir/key-here", []byte("val")) + if err != nil { + t.Errorf("failed to put: %s", err) + } + + val, err := kv.Get("/somedir/key-here") + if err != nil { + t.Errorf("failed to get key: %s", err) + } + + if string(val) != "val" { + t.Errorf("unexpected return: %s", string(val)) + } +} + +func TestGet(t *testing.T) { + + impl := getImplementer(t) + kv, err := kv.New(impl, "test", "testget") + if err != nil { + t.Fatalf("failed to create kv: %s", err) + } + defer kv.Teardown() + + err = kv.Put("foo", []byte("bar")) + if err != nil { + t.Errorf("failed to put: %s", err) + } + + // getting it back + val, err := kv.Get("foo") + if err != nil { + t.Errorf("failed to get: %s", err) + } + + if string(val) != "bar" { + t.Errorf("expected 'bar' but got: '%s'", string(val)) + } + +} + +func TestDelete(t *testing.T) { + + impl := getImplementer(t) + kvdb, err := kv.New(impl, "test", "testdelete") + if err != nil { + t.Fatalf("failed to create kv: %s", err) + } + defer kvdb.Teardown() + + err = kvdb.Put("foo", []byte("bar")) + if err != nil { + t.Errorf("failed to put: %s", err) + } + + // getting it back + val, err := kvdb.Get("foo") + if err != nil { + t.Errorf("failed to get: %s", err) + } + + if string(val) != "bar" { + t.Errorf("expected 'bar' but got: '%s'", string(val)) + } + + // deleting it + err = kvdb.Delete("foo") + if err != nil { + t.Errorf("got error while deleting: %s", err) + } + + _, err = kvdb.Get("foo") + if err != kv.ErrNotFound { + t.Errorf("expected to get an error on deleted key") + } +} + +func TestList(t *testing.T) { + count := 3 + + impl := getImplementer(t) + kv, err := kv.New(impl, "test", "testlist") + if err != nil { + t.Fatalf("failed to create kv: %s", err) + } + defer kv.Teardown() + + for i := 0; i < count; i++ { + err = kv.Put(fmt.Sprint(i), []byte(fmt.Sprintf("bar-%d", i))) + if err != nil { + t.Errorf("failed to put: %s", err) + } + } + + items, err := kv.List("") + if err != nil { + t.Fatalf("failed to list items, error: %s", err) + } + + if len(items) != count { + t.Errorf("expected %d items, got: %d", count, len(items)) + } + + if string(items["0"]) != "bar-0" { + t.Errorf("unexpected value on '0': %s", items["0"]) + } + if string(items["1"]) != "bar-1" { + t.Errorf("unexpected value on '1': %s", items["1"]) + } + if string(items["2"]) != "bar-2" { + t.Errorf("unexpected value on '2': %s", items["2"]) + } + +} + +func TestListPrefix(t *testing.T) { + impl := getImplementer(t) + kv, err := kv.New(impl, "test", "testlistprefix") + if err != nil { + t.Fatalf("failed to create kv: %s", err) + } + defer kv.Teardown() + + err = kv.Put("aaa", []byte("aaa")) + if err != nil { + t.Errorf("failed to put key, error: %s", err) + } + err = kv.Put("aaaaa", []byte("aaa")) + if err != nil { + t.Errorf("failed to put key, error: %s", err) + } + err = kv.Put("aaaaaaa", []byte("aaa")) + if err != nil { + t.Errorf("failed to put key, error: %s", err) + } + + err = kv.Put("bbb", []byte("bbb")) + if err != nil { + t.Errorf("failed to put key, error: %s", err) + } + err = kv.Put("bbbbb", []byte("bbb")) + if err != nil { + t.Errorf("failed to put key, error: %s", err) + } + err = kv.Put("bbbbbbb", []byte("bbb")) + if err != nil { + t.Errorf("failed to put key, error: %s", err) + } + + items, err := kv.List("aaa") + if err != nil { + t.Fatalf("failed to list items, error: %s", err) + } + + if len(items) != 3 { + t.Errorf("expected %d items, got: %d", 3, len(items)) + } + + if string(items["aaa"]) != "aaa" { + t.Errorf("unexpected value on 'aaa': %s", items["aaa"]) + } + if string(items["aaaaa"]) != "aaa" { + t.Errorf("unexpected value on 'aaaaa': %s", items["aaaaa"]) + } + if string(items["aaaaaaa"]) != "aaa" { + t.Errorf("unexpected value on 'aaaaaaa': %s", items["aaaaaaa"]) + } + +} diff --git a/vendor/github.com/sirupsen/logrus/example_basic_test.go b/vendor/github.com/sirupsen/logrus/example_basic_test.go new file mode 100644 index 00000000..a2acf550 --- /dev/null +++ b/vendor/github.com/sirupsen/logrus/example_basic_test.go @@ -0,0 +1,69 @@ +package logrus_test + +import ( + "github.com/sirupsen/logrus" + "os" +) + +func Example_basic() { + var log = logrus.New() + log.Formatter = new(logrus.JSONFormatter) + log.Formatter = new(logrus.TextFormatter) //default + log.Formatter.(*logrus.TextFormatter).DisableTimestamp = true // remove timestamp from test output + log.Level = logrus.DebugLevel + log.Out = os.Stdout + + // file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY, 0666) + // if err == nil { + // log.Out = file + // } else { + // log.Info("Failed to log to file, using default stderr") + // } + + defer func() { + err := recover() + if err != nil { + entry := err.(*logrus.Entry) + log.WithFields(logrus.Fields{ + "omg": true, + "err_animal": entry.Data["animal"], + "err_size": entry.Data["size"], + "err_level": entry.Level, + "err_message": entry.Message, + "number": 100, + }).Error("The ice breaks!") // or use Fatal() to force the process to exit with a nonzero code + } + }() + + log.WithFields(logrus.Fields{ + "animal": "walrus", + "number": 8, + }).Debug("Started observing beach") + + log.WithFields(logrus.Fields{ + "animal": "walrus", + "size": 10, + }).Info("A group of walrus emerges from the ocean") + + log.WithFields(logrus.Fields{ + "omg": true, + "number": 122, + }).Warn("The group's number increased tremendously!") + + log.WithFields(logrus.Fields{ + "temperature": -4, + }).Debug("Temperature changes") + + log.WithFields(logrus.Fields{ + "animal": "orca", + "size": 9009, + }).Panic("It's over 9000!") + + // Output: + // level=debug msg="Started observing beach" animal=walrus number=8 + // level=info msg="A group of walrus emerges from the ocean" animal=walrus size=10 + // level=warning msg="The group's number increased tremendously!" number=122 omg=true + // level=debug msg="Temperature changes" temperature=-4 + // level=panic msg="It's over 9000!" animal=orca size=9009 + // level=error msg="The ice breaks!" err_animal=orca err_level=panic err_message="It's over 9000!" err_size=9009 number=100 omg=true +} diff --git a/vendor/github.com/sirupsen/logrus/example_hook_test.go b/vendor/github.com/sirupsen/logrus/example_hook_test.go new file mode 100644 index 00000000..d4ddffca --- /dev/null +++ b/vendor/github.com/sirupsen/logrus/example_hook_test.go @@ -0,0 +1,35 @@ +package logrus_test + +import ( + "github.com/sirupsen/logrus" + "gopkg.in/gemnasium/logrus-airbrake-hook.v2" + "os" +) + +func Example_hook() { + var log = logrus.New() + log.Formatter = new(logrus.TextFormatter) // default + log.Formatter.(*logrus.TextFormatter).DisableTimestamp = true // remove timestamp from test output + log.Hooks.Add(airbrake.NewHook(123, "xyz", "development")) + log.Out = os.Stdout + + log.WithFields(logrus.Fields{ + "animal": "walrus", + "size": 10, + }).Info("A group of walrus emerges from the ocean") + + log.WithFields(logrus.Fields{ + "omg": true, + "number": 122, + }).Warn("The group's number increased tremendously!") + + log.WithFields(logrus.Fields{ + "omg": true, + "number": 100, + }).Error("The ice breaks!") + + // Output: + // level=info msg="A group of walrus emerges from the ocean" animal=walrus size=10 + // level=warning msg="The group's number increased tremendously!" number=122 omg=true + // level=error msg="The ice breaks!" number=100 omg=true +} diff --git a/vendor/golang.org/x/crypto/chacha20poly1305/internal/chacha20/chacha_generic.go b/vendor/golang.org/x/crypto/chacha20poly1305/internal/chacha20/chacha_generic.go index f9e8a3a2..0f8efdba 100644 --- a/vendor/golang.org/x/crypto/chacha20poly1305/internal/chacha20/chacha_generic.go +++ b/vendor/golang.org/x/crypto/chacha20poly1305/internal/chacha20/chacha_generic.go @@ -167,9 +167,8 @@ func core(out *[64]byte, in *[16]byte, k *[32]byte) { } // XORKeyStream crypts bytes from in to out using the given key and counters. -// In and out may be the same slice but otherwise should not overlap. Counter -// contains the raw ChaCha20 counter bytes (i.e. block counter followed by -// nonce). +// In and out must overlap entirely or not at all. Counter contains the raw +// ChaCha20 counter bytes (i.e. block counter followed by nonce). func XORKeyStream(out, in []byte, counter *[16]byte, key *[32]byte) { var block [64]byte var counterCopy [16]byte diff --git a/vendor/golang.org/x/crypto/nacl/auth/auth.go b/vendor/golang.org/x/crypto/nacl/auth/auth.go new file mode 100644 index 00000000..0835d3bf --- /dev/null +++ b/vendor/golang.org/x/crypto/nacl/auth/auth.go @@ -0,0 +1,58 @@ +// Copyright 2017 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +/* +Package auth authenticates a message using a secret key. + +The Sum function, viewed as a function of the message for a uniform random +key, is designed to meet the standard notion of unforgeability. This means +that an attacker cannot find authenticators for any messages not authenticated +by the sender, even if the attacker has adaptively influenced the messages +authenticated by the sender. For a formal definition see, e.g., Section 2.4 +of Bellare, Kilian, and Rogaway, "The security of the cipher block chaining +message authentication code," Journal of Computer and System Sciences 61 (2000), +362–399; http://www-cse.ucsd.edu/~mihir/papers/cbc.html. + +auth does not make any promises regarding "strong" unforgeability; perhaps +one valid authenticator can be converted into another valid authenticator for +the same message. NaCl also does not make any promises regarding "truncated +unforgeability." + +This package is interoperable with NaCl: https://nacl.cr.yp.to/auth.html. +*/ +package auth + +import ( + "crypto/hmac" + "crypto/sha512" +) + +const ( + // Size is the size, in bytes, of an authenticated digest. + Size = 32 + // KeySize is the size, in bytes, of an authentication key. + KeySize = 32 +) + +// Sum generates an authenticator for m using a secret key and returns the +// 32-byte digest. +func Sum(m []byte, key *[KeySize]byte) *[Size]byte { + mac := hmac.New(sha512.New, key[:]) + mac.Write(m) + out := new([KeySize]byte) + copy(out[:], mac.Sum(nil)[:Size]) + return out +} + +// Verify checks that digest is a valid authenticator of message m under the +// given secret key. Verify does not leak timing information. +func Verify(digest []byte, m []byte, key *[32]byte) bool { + if len(digest) != Size { + return false + } + mac := hmac.New(sha512.New, key[:]) + mac.Write(m) + expectedMAC := mac.Sum(nil) // first 256 bits of 512-bit sum + return hmac.Equal(digest, expectedMAC[:Size]) +} diff --git a/vendor/golang.org/x/crypto/nacl/auth/auth_test.go b/vendor/golang.org/x/crypto/nacl/auth/auth_test.go new file mode 100644 index 00000000..92074b50 --- /dev/null +++ b/vendor/golang.org/x/crypto/nacl/auth/auth_test.go @@ -0,0 +1,172 @@ +// Copyright 2017 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package auth + +import ( + "bytes" + rand "crypto/rand" + mrand "math/rand" + "testing" +) + +// Test cases are from RFC 4231, and match those present in the tests directory +// of the download here: https://nacl.cr.yp.to/install.html +var testCases = []struct { + key [32]byte + msg []byte + out [32]byte +}{ + { + key: [32]byte{ + 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0b, 0x0b, 0x0b, + }, + msg: []byte("Hi There"), + out: [32]byte{ + 0x87, 0xaa, 0x7c, 0xde, 0xa5, 0xef, 0x61, 0x9d, + 0x4f, 0xf0, 0xb4, 0x24, 0x1a, 0x1d, 0x6c, 0xb0, + 0x23, 0x79, 0xf4, 0xe2, 0xce, 0x4e, 0xc2, 0x78, + 0x7a, 0xd0, 0xb3, 0x05, 0x45, 0xe1, 0x7c, 0xde, + }, + }, + { + key: [32]byte{'J', 'e', 'f', 'e'}, + msg: []byte("what do ya want for nothing?"), + out: [32]byte{ + 0x16, 0x4b, 0x7a, 0x7b, 0xfc, 0xf8, 0x19, 0xe2, + 0xe3, 0x95, 0xfb, 0xe7, 0x3b, 0x56, 0xe0, 0xa3, + 0x87, 0xbd, 0x64, 0x22, 0x2e, 0x83, 0x1f, 0xd6, + 0x10, 0x27, 0x0c, 0xd7, 0xea, 0x25, 0x05, 0x54, + }, + }, + { + key: [32]byte{ + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, + 0xaa, 0xaa, 0xaa, 0xaa, + }, + msg: []byte{ // 50 bytes of 0xdd + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, + }, + out: [32]byte{ + 0xfa, 0x73, 0xb0, 0x08, 0x9d, 0x56, 0xa2, 0x84, + 0xef, 0xb0, 0xf0, 0x75, 0x6c, 0x89, 0x0b, 0xe9, + 0xb1, 0xb5, 0xdb, 0xdd, 0x8e, 0xe8, 0x1a, 0x36, + 0x55, 0xf8, 0x3e, 0x33, 0xb2, 0x27, 0x9d, 0x39, + }, + }, + { + key: [32]byte{ + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, + 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, + 0x19, + }, + msg: []byte{ + 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, + 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, + 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, + 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, + 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, + 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, + 0xcd, 0xcd, + }, + out: [32]byte{ + 0xb0, 0xba, 0x46, 0x56, 0x37, 0x45, 0x8c, 0x69, + 0x90, 0xe5, 0xa8, 0xc5, 0xf6, 0x1d, 0x4a, 0xf7, + 0xe5, 0x76, 0xd9, 0x7f, 0xf9, 0x4b, 0x87, 0x2d, + 0xe7, 0x6f, 0x80, 0x50, 0x36, 0x1e, 0xe3, 0xdb, + }, + }, +} + +func TestSum(t *testing.T) { + for i, test := range testCases { + tag := Sum(test.msg, &test.key) + if !bytes.Equal(tag[:], test.out[:]) { + t.Errorf("#%d: Sum: got\n%x\nwant\n%x", i, tag, test.out) + } + } +} + +func TestVerify(t *testing.T) { + wrongMsg := []byte("unknown msg") + + for i, test := range testCases { + if !Verify(test.out[:], test.msg, &test.key) { + t.Errorf("#%d: Verify(%x, %q, %x) failed", i, test.out, test.msg, test.key) + } + if Verify(test.out[:], wrongMsg, &test.key) { + t.Errorf("#%d: Verify(%x, %q, %x) unexpectedly passed", i, test.out, wrongMsg, test.key) + } + } +} + +func TestStress(t *testing.T) { + if testing.Short() { + t.Skip("exhaustiveness test") + } + + var key [32]byte + msg := make([]byte, 10000) + prng := mrand.New(mrand.NewSource(0)) + + // copied from tests/auth5.c in nacl + for i := 0; i < 10000; i++ { + if _, err := rand.Read(key[:]); err != nil { + t.Fatal(err) + } + if _, err := rand.Read(msg[:i]); err != nil { + t.Fatal(err) + } + tag := Sum(msg[:i], &key) + if !Verify(tag[:], msg[:i], &key) { + t.Errorf("#%d: unexpected failure from Verify", i) + } + if i > 0 { + msgIndex := prng.Intn(i) + oldMsgByte := msg[msgIndex] + msg[msgIndex] += byte(1 + prng.Intn(255)) + if Verify(tag[:], msg[:i], &key) { + t.Errorf("#%d: unexpected success from Verify after corrupting message", i) + } + msg[msgIndex] = oldMsgByte + + tag[prng.Intn(len(tag))] += byte(1 + prng.Intn(255)) + if Verify(tag[:], msg[:i], &key) { + t.Errorf("#%d: unexpected success from Verify after corrupting authenticator", i) + } + } + } +} + +func BenchmarkAuth(b *testing.B) { + var key [32]byte + if _, err := rand.Read(key[:]); err != nil { + b.Fatal(err) + } + buf := make([]byte, 1024) + if _, err := rand.Read(buf[:]); err != nil { + b.Fatal(err) + } + + b.SetBytes(int64(len(buf))) + b.ReportAllocs() + b.ResetTimer() + + for i := 0; i < b.N; i++ { + tag := Sum(buf, &key) + if Verify(tag[:], buf, &key) == false { + b.Fatal("unexpected failure from Verify") + } + } +} diff --git a/vendor/golang.org/x/crypto/nacl/auth/example_test.go b/vendor/golang.org/x/crypto/nacl/auth/example_test.go new file mode 100644 index 00000000..02a2cd6c --- /dev/null +++ b/vendor/golang.org/x/crypto/nacl/auth/example_test.go @@ -0,0 +1,36 @@ +// Copyright 2017 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package auth_test + +import ( + "encoding/hex" + "fmt" + + "golang.org/x/crypto/nacl/auth" +) + +func Example() { + // Load your secret key from a safe place and reuse it across multiple + // Sum calls. (Obviously don't use this example key for anything + // real.) If you want to convert a passphrase to a key, use a suitable + // package like bcrypt or scrypt. + secretKeyBytes, err := hex.DecodeString("6368616e676520746869732070617373776f726420746f206120736563726574") + if err != nil { + panic(err) + } + + var secretKey [32]byte + copy(secretKey[:], secretKeyBytes) + + mac := auth.Sum([]byte("hello world"), &secretKey) + fmt.Printf("%x\n", *mac) + result := auth.Verify(mac[:], []byte("hello world"), &secretKey) + fmt.Println(result) + badResult := auth.Verify(mac[:], []byte("different message"), &secretKey) + fmt.Println(badResult) + // Output: eca5a521f3d77b63f567fb0cb6f5f2d200641bc8dada42f60c5f881260c30317 + // true + // false +} diff --git a/vendor/golang.org/x/crypto/nacl/box/box.go b/vendor/golang.org/x/crypto/nacl/box/box.go index 7ed1864f..31b697be 100644 --- a/vendor/golang.org/x/crypto/nacl/box/box.go +++ b/vendor/golang.org/x/crypto/nacl/box/box.go @@ -3,7 +3,7 @@ // license that can be found in the LICENSE file. /* -Package box authenticates and encrypts messages using public-key cryptography. +Package box authenticates and encrypts small messages using public-key cryptography. Box uses Curve25519, XSalsa20 and Poly1305 to encrypt and authenticate messages. The length of messages is not hidden. @@ -13,6 +13,23 @@ example, by using nonce 1 for the first message, nonce 2 for the second message, etc. Nonces are long enough that randomly generated nonces have negligible risk of collision. +Messages should be small because: + +1. The whole message needs to be held in memory to be processed. + +2. Using large messages pressures implementations on small machines to decrypt +and process plaintext before authenticating it. This is very dangerous, and +this API does not allow it, but a protocol that uses excessive message sizes +might present some implementations with no other choice. + +3. Fixed overheads will be sufficiently amortised by messages as small as 8KB. + +4. Performance may be improved by working with messages that fit into data caches. + +Thus large amounts of data should be chunked so that each message is small. +(Each message still needs a unique nonce.) If in doubt, 16KB is a reasonable +chunk size. + This package is interoperable with NaCl: https://nacl.cr.yp.to/box.html. */ package box // import "golang.org/x/crypto/nacl/box" @@ -56,7 +73,7 @@ func Precompute(sharedKey, peersPublicKey, privateKey *[32]byte) { } // Seal appends an encrypted and authenticated copy of message to out, which -// will be Overhead bytes longer than the original and must not overlap. The +// will be Overhead bytes longer than the original and must not overlap it. The // nonce must be unique for each distinct message for a given pair of keys. func Seal(out, message []byte, nonce *[24]byte, peersPublicKey, privateKey *[32]byte) []byte { var sharedKey [32]byte diff --git a/vendor/golang.org/x/crypto/nacl/secretbox/secretbox.go b/vendor/golang.org/x/crypto/nacl/secretbox/secretbox.go index 1e1dff50..53ee83cf 100644 --- a/vendor/golang.org/x/crypto/nacl/secretbox/secretbox.go +++ b/vendor/golang.org/x/crypto/nacl/secretbox/secretbox.go @@ -13,6 +13,23 @@ example, by using nonce 1 for the first message, nonce 2 for the second message, etc. Nonces are long enough that randomly generated nonces have negligible risk of collision. +Messages should be small because: + +1. The whole message needs to be held in memory to be processed. + +2. Using large messages pressures implementations on small machines to decrypt +and process plaintext before authenticating it. This is very dangerous, and +this API does not allow it, but a protocol that uses excessive message sizes +might present some implementations with no other choice. + +3. Fixed overheads will be sufficiently amortised by messages as small as 8KB. + +4. Performance may be improved by working with messages that fit into data caches. + +Thus large amounts of data should be chunked so that each message is small. +(Each message still needs a unique nonce.) If in doubt, 16KB is a reasonable +chunk size. + This package is interoperable with NaCl: https://nacl.cr.yp.to/secretbox.html. */ package secretbox // import "golang.org/x/crypto/nacl/secretbox" diff --git a/vendor/golang.org/x/crypto/openpgp/keys_test.go b/vendor/golang.org/x/crypto/openpgp/keys_test.go index f768e68a..76ba13ed 100644 --- a/vendor/golang.org/x/crypto/openpgp/keys_test.go +++ b/vendor/golang.org/x/crypto/openpgp/keys_test.go @@ -12,7 +12,10 @@ import ( ) func TestKeyExpiry(t *testing.T) { - kring, _ := ReadKeyRing(readerFromHex(expiringKeyHex)) + kring, err := ReadKeyRing(readerFromHex(expiringKeyHex)) + if err != nil { + t.Fatal(err) + } entity := kring[0] const timeFormat = "2006-01-02" @@ -104,7 +107,10 @@ func TestGoodCrossSignature(t *testing.T) { // TestExternallyRevokableKey attempts to load and parse a key with a third party revocation permission. func TestExternallyRevocableKey(t *testing.T) { - kring, _ := ReadKeyRing(readerFromHex(subkeyUsageHex)) + kring, err := ReadKeyRing(readerFromHex(subkeyUsageHex)) + if err != nil { + t.Fatal(err) + } // The 0xA42704B92866382A key can be revoked by 0xBE3893CB843D0FE70C // according to this signature that appears within the key: @@ -125,7 +131,10 @@ func TestExternallyRevocableKey(t *testing.T) { } func TestKeyRevocation(t *testing.T) { - kring, _ := ReadKeyRing(readerFromHex(revokedKeyHex)) + kring, err := ReadKeyRing(readerFromHex(revokedKeyHex)) + if err != nil { + t.Fatal(err) + } // revokedKeyHex contains these keys: // pub 1024R/9A34F7C0 2014-03-25 [revoked: 2014-03-25] @@ -145,7 +154,10 @@ func TestKeyRevocation(t *testing.T) { } func TestSubkeyRevocation(t *testing.T) { - kring, _ := ReadKeyRing(readerFromHex(revokedSubkeyHex)) + kring, err := ReadKeyRing(readerFromHex(revokedSubkeyHex)) + if err != nil { + t.Fatal(err) + } // revokedSubkeyHex contains these keys: // pub 1024R/4EF7E4BECCDE97F0 2014-03-25 @@ -178,7 +190,10 @@ func TestSubkeyRevocation(t *testing.T) { } func TestKeyUsage(t *testing.T) { - kring, _ := ReadKeyRing(readerFromHex(subkeyUsageHex)) + kring, err := ReadKeyRing(readerFromHex(subkeyUsageHex)) + if err != nil { + t.Fatal(err) + } // subkeyUsageHex contains these keys: // pub 1024R/2866382A created: 2014-04-01 expires: never usage: SC diff --git a/vendor/golang.org/x/crypto/salsa20/salsa/salsa20_amd64.go b/vendor/golang.org/x/crypto/salsa20/salsa/salsa20_amd64.go index c34d362e..f9269c38 100644 --- a/vendor/golang.org/x/crypto/salsa20/salsa/salsa20_amd64.go +++ b/vendor/golang.org/x/crypto/salsa20/salsa/salsa20_amd64.go @@ -13,7 +13,7 @@ package salsa func salsa2020XORKeyStream(out, in *byte, n uint64, nonce, key *byte) // XORKeyStream crypts bytes from in to out using the given key and counters. -// In and out may be the same slice but otherwise should not overlap. Counter +// In and out must overlap entirely or not at all. Counter // contains the raw salsa20 counter bytes (both nonce and block counter). func XORKeyStream(out, in []byte, counter *[16]byte, key *[32]byte) { if len(in) == 0 { diff --git a/vendor/golang.org/x/crypto/salsa20/salsa/salsa20_ref.go b/vendor/golang.org/x/crypto/salsa20/salsa/salsa20_ref.go index 95f8ca5b..22126d17 100644 --- a/vendor/golang.org/x/crypto/salsa20/salsa/salsa20_ref.go +++ b/vendor/golang.org/x/crypto/salsa20/salsa/salsa20_ref.go @@ -203,7 +203,7 @@ func core(out *[64]byte, in *[16]byte, k *[32]byte, c *[16]byte) { } // XORKeyStream crypts bytes from in to out using the given key and counters. -// In and out may be the same slice but otherwise should not overlap. Counter +// In and out must overlap entirely or not at all. Counter // contains the raw salsa20 counter bytes (both nonce and block counter). func XORKeyStream(out, in []byte, counter *[16]byte, key *[32]byte) { var block [64]byte diff --git a/vendor/golang.org/x/crypto/salsa20/salsa20.go b/vendor/golang.org/x/crypto/salsa20/salsa20.go index a8ddd76e..0ee62485 100644 --- a/vendor/golang.org/x/crypto/salsa20/salsa20.go +++ b/vendor/golang.org/x/crypto/salsa20/salsa20.go @@ -27,8 +27,8 @@ import ( "golang.org/x/crypto/salsa20/salsa" ) -// XORKeyStream crypts bytes from in to out using the given key and nonce. In -// and out may be the same slice but otherwise should not overlap. Nonce must +// XORKeyStream crypts bytes from in to out using the given key and nonce. +// In and out must overlap entirely or not at all. Nonce must // be either 8 or 24 bytes long. func XORKeyStream(out, in []byte, nonce []byte, key *[32]byte) { if len(out) < len(in) { diff --git a/vendor/golang.org/x/crypto/sha3/sha3.go b/vendor/golang.org/x/crypto/sha3/sha3.go index c86167c0..b12a35c8 100644 --- a/vendor/golang.org/x/crypto/sha3/sha3.go +++ b/vendor/golang.org/x/crypto/sha3/sha3.go @@ -42,9 +42,8 @@ type state struct { storage [maxRate]byte // Specific to SHA-3 and SHAKE. - fixedOutput bool // whether this is a fixed-output-length instance - outputLen int // the default output size in bytes - state spongeDirection // whether the sponge is absorbing or squeezing + outputLen int // the default output size in bytes + state spongeDirection // whether the sponge is absorbing or squeezing } // BlockSize returns the rate of sponge underlying this hash function. diff --git a/vendor/golang.org/x/crypto/ssh/agent/client_test.go b/vendor/golang.org/x/crypto/ssh/agent/client_test.go index 5fc47e57..a5b20f55 100644 --- a/vendor/golang.org/x/crypto/ssh/agent/client_test.go +++ b/vendor/golang.org/x/crypto/ssh/agent/client_test.go @@ -19,8 +19,8 @@ import ( "golang.org/x/crypto/ssh" ) -// startAgent executes ssh-agent, and returns a Agent interface to it. -func startAgent(t *testing.T) (client Agent, socket string, cleanup func()) { +// startOpenSSHAgent executes ssh-agent, and returns a Agent interface to it. +func startOpenSSHAgent(t *testing.T) (client Agent, socket string, cleanup func()) { if testing.Short() { // ssh-agent is not always available, and the key // types supported vary by platform. @@ -79,16 +79,32 @@ func startAgent(t *testing.T) (client Agent, socket string, cleanup func()) { } } -func testAgent(t *testing.T, key interface{}, cert *ssh.Certificate, lifetimeSecs uint32) { - agent, _, cleanup := startAgent(t) +// startKeyringAgent uses Keyring to simulate a ssh-agent Server and returns a client. +func startKeyringAgent(t *testing.T) (client Agent, cleanup func()) { + c1, c2, err := netPipe() + if err != nil { + t.Fatalf("netPipe: %v", err) + } + go ServeAgent(NewKeyring(), c2) + + return NewClient(c1), func() { + c1.Close() + c2.Close() + } +} + +func testOpenSSHAgent(t *testing.T, key interface{}, cert *ssh.Certificate, lifetimeSecs uint32) { + agent, _, cleanup := startOpenSSHAgent(t) defer cleanup() testAgentInterface(t, agent, key, cert, lifetimeSecs) } -func testKeyring(t *testing.T, key interface{}, cert *ssh.Certificate, lifetimeSecs uint32) { - a := NewKeyring() - testAgentInterface(t, a, key, cert, lifetimeSecs) +func testKeyringAgent(t *testing.T, key interface{}, cert *ssh.Certificate, lifetimeSecs uint32) { + agent, cleanup := startKeyringAgent(t) + defer cleanup() + + testAgentInterface(t, agent, key, cert, lifetimeSecs) } func testAgentInterface(t *testing.T, agent Agent, key interface{}, cert *ssh.Certificate, lifetimeSecs uint32) { @@ -159,8 +175,8 @@ func testAgentInterface(t *testing.T, agent Agent, key interface{}, cert *ssh.Ce func TestAgent(t *testing.T) { for _, keyType := range []string{"rsa", "dsa", "ecdsa", "ed25519"} { - testAgent(t, testPrivateKeys[keyType], nil, 0) - testKeyring(t, testPrivateKeys[keyType], nil, 1) + testOpenSSHAgent(t, testPrivateKeys[keyType], nil, 0) + testKeyringAgent(t, testPrivateKeys[keyType], nil, 0) } } @@ -172,8 +188,8 @@ func TestCert(t *testing.T) { } cert.SignCert(rand.Reader, testSigners["ecdsa"]) - testAgent(t, testPrivateKeys["rsa"], cert, 0) - testKeyring(t, testPrivateKeys["rsa"], cert, 1) + testOpenSSHAgent(t, testPrivateKeys["rsa"], cert, 0) + testKeyringAgent(t, testPrivateKeys["rsa"], cert, 0) } // netPipe is analogous to net.Pipe, but it uses a real net.Conn, and @@ -203,7 +219,7 @@ func netPipe() (net.Conn, net.Conn, error) { } func TestAuth(t *testing.T) { - agent, _, cleanup := startAgent(t) + agent, _, cleanup := startOpenSSHAgent(t) defer cleanup() a, b, err := netPipe() @@ -247,8 +263,14 @@ func TestAuth(t *testing.T) { conn.Close() } -func TestLockClient(t *testing.T) { - agent, _, cleanup := startAgent(t) +func TestLockOpenSSHAgent(t *testing.T) { + agent, _, cleanup := startOpenSSHAgent(t) + defer cleanup() + testLockAgent(agent, t) +} + +func TestLockKeyringAgent(t *testing.T) { + agent, cleanup := startKeyringAgent(t) defer cleanup() testLockAgent(agent, t) } @@ -308,10 +330,19 @@ func testLockAgent(agent Agent, t *testing.T) { } } -func TestAgentLifetime(t *testing.T) { - agent, _, cleanup := startAgent(t) +func testOpenSSHAgentLifetime(t *testing.T) { + agent, _, cleanup := startOpenSSHAgent(t) defer cleanup() + testAgentLifetime(t, agent) +} +func testKeyringAgentLifetime(t *testing.T) { + agent, cleanup := startKeyringAgent(t) + defer cleanup() + testAgentLifetime(t, agent) +} + +func testAgentLifetime(t *testing.T, agent Agent) { for _, keyType := range []string{"rsa", "dsa", "ecdsa"} { // Add private keys to the agent. err := agent.Add(AddedKey{ diff --git a/vendor/golang.org/x/crypto/ssh/agent/server.go b/vendor/golang.org/x/crypto/ssh/agent/server.go index 793dd2e7..321e48a2 100644 --- a/vendor/golang.org/x/crypto/ssh/agent/server.go +++ b/vendor/golang.org/x/crypto/ssh/agent/server.go @@ -106,7 +106,7 @@ func (s *server) processRequest(data []byte) (interface{}, error) { return nil, s.agent.Lock(req.Passphrase) case agentUnlock: - var req agentLockMsg + var req agentUnlockMsg if err := ssh.Unmarshal(data, &req); err != nil { return nil, err } diff --git a/vendor/golang.org/x/crypto/ssh/agent/server_test.go b/vendor/golang.org/x/crypto/ssh/agent/server_test.go index c34d05b3..038018eb 100644 --- a/vendor/golang.org/x/crypto/ssh/agent/server_test.go +++ b/vendor/golang.org/x/crypto/ssh/agent/server_test.go @@ -43,7 +43,7 @@ func TestSetupForwardAgent(t *testing.T) { defer a.Close() defer b.Close() - _, socket, cleanup := startAgent(t) + _, socket, cleanup := startOpenSSHAgent(t) defer cleanup() serverConf := ssh.ServerConfig{ diff --git a/vendor/golang.org/x/crypto/ssh/keys.go b/vendor/golang.org/x/crypto/ssh/keys.go index 7a8756a9..b682c174 100644 --- a/vendor/golang.org/x/crypto/ssh/keys.go +++ b/vendor/golang.org/x/crypto/ssh/keys.go @@ -367,6 +367,17 @@ func (r *dsaPublicKey) Type() string { return "ssh-dss" } +func checkDSAParams(param *dsa.Parameters) error { + // SSH specifies FIPS 186-2, which only provided a single size + // (1024 bits) DSA key. FIPS 186-3 allows for larger key + // sizes, which would confuse SSH. + if l := param.P.BitLen(); l != 1024 { + return fmt.Errorf("ssh: unsupported DSA key size %d", l) + } + + return nil +} + // parseDSA parses an DSA key according to RFC 4253, section 6.6. func parseDSA(in []byte) (out PublicKey, rest []byte, err error) { var w struct { @@ -377,13 +388,18 @@ func parseDSA(in []byte) (out PublicKey, rest []byte, err error) { return nil, nil, err } + param := dsa.Parameters{ + P: w.P, + Q: w.Q, + G: w.G, + } + if err := checkDSAParams(¶m); err != nil { + return nil, nil, err + } + key := &dsaPublicKey{ - Parameters: dsa.Parameters{ - P: w.P, - Q: w.Q, - G: w.G, - }, - Y: w.Y, + Parameters: param, + Y: w.Y, } return key, w.Rest, nil } @@ -630,19 +646,28 @@ func (k *ecdsaPublicKey) CryptoPublicKey() crypto.PublicKey { } // NewSignerFromKey takes an *rsa.PrivateKey, *dsa.PrivateKey, -// *ecdsa.PrivateKey or any other crypto.Signer and returns a corresponding -// Signer instance. ECDSA keys must use P-256, P-384 or P-521. +// *ecdsa.PrivateKey or any other crypto.Signer and returns a +// corresponding Signer instance. ECDSA keys must use P-256, P-384 or +// P-521. DSA keys must use parameter size L1024N160. func NewSignerFromKey(key interface{}) (Signer, error) { switch key := key.(type) { case crypto.Signer: return NewSignerFromSigner(key) case *dsa.PrivateKey: - return &dsaPrivateKey{key}, nil + return newDSAPrivateKey(key) default: return nil, fmt.Errorf("ssh: unsupported key type %T", key) } } +func newDSAPrivateKey(key *dsa.PrivateKey) (Signer, error) { + if err := checkDSAParams(&key.PublicKey.Parameters); err != nil { + return nil, err + } + + return &dsaPrivateKey{key}, nil +} + type wrappedSigner struct { signer crypto.Signer pubKey PublicKey diff --git a/vendor/golang.org/x/crypto/ssh/server.go b/vendor/golang.org/x/crypto/ssh/server.go index b6f4cc81..8a78b7ca 100644 --- a/vendor/golang.org/x/crypto/ssh/server.go +++ b/vendor/golang.org/x/crypto/ssh/server.go @@ -67,7 +67,7 @@ type ServerConfig struct { PasswordCallback func(conn ConnMetadata, password []byte) (*Permissions, error) // PublicKeyCallback, if non-nil, is called when a client - // offers a public key for authentication. It must return true + // offers a public key for authentication. It must return a nil error // if the given public key can be used to authenticate the // given user. For example, see CertChecker.Authenticate. A // call to this function does not guarantee that the key diff --git a/vendor/golang.org/x/crypto/ssh/terminal/util.go b/vendor/golang.org/x/crypto/ssh/terminal/util.go index d0191961..e7404ff4 100644 --- a/vendor/golang.org/x/crypto/ssh/terminal/util.go +++ b/vendor/golang.org/x/crypto/ssh/terminal/util.go @@ -19,6 +19,8 @@ package terminal // import "golang.org/x/crypto/ssh/terminal" import ( "syscall" "unsafe" + + "golang.org/x/sys/unix" ) // State contains the state of a terminal. @@ -50,6 +52,8 @@ func MakeRaw(fd int) (*State, error) { newState.Lflag &^= syscall.ECHO | syscall.ECHONL | syscall.ICANON | syscall.ISIG | syscall.IEXTEN newState.Cflag &^= syscall.CSIZE | syscall.PARENB newState.Cflag |= syscall.CS8 + newState.Cc[unix.VMIN] = 1 + newState.Cc[unix.VTIME] = 0 if _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlWriteTermios, uintptr(unsafe.Pointer(&newState)), 0, 0, 0); err != 0 { return nil, err } diff --git a/vendor/golang.org/x/crypto/xts/xts.go b/vendor/golang.org/x/crypto/xts/xts.go index a7643fdc..92cbce99 100644 --- a/vendor/golang.org/x/crypto/xts/xts.go +++ b/vendor/golang.org/x/crypto/xts/xts.go @@ -55,7 +55,7 @@ func NewCipher(cipherFunc func([]byte) (cipher.Block, error), key []byte) (c *Ci } // Encrypt encrypts a sector of plaintext and puts the result into ciphertext. -// Plaintext and ciphertext may be the same slice but should not overlap. +// Plaintext and ciphertext must overlap entirely or not at all. // Sectors must be a multiple of 16 bytes and less than 2²⁴ bytes. func (c *Cipher) Encrypt(ciphertext, plaintext []byte, sectorNum uint64) { if len(ciphertext) < len(plaintext) { @@ -86,7 +86,7 @@ func (c *Cipher) Encrypt(ciphertext, plaintext []byte, sectorNum uint64) { } // Decrypt decrypts a sector of ciphertext and puts the result into plaintext. -// Plaintext and ciphertext may be the same slice but should not overlap. +// Plaintext and ciphertext must overlap entirely or not at all. // Sectors must be a multiple of 16 bytes and less than 2²⁴ bytes. func (c *Cipher) Decrypt(plaintext, ciphertext []byte, sectorNum uint64) { if len(plaintext) < len(ciphertext) { diff --git a/vendor/google.golang.org/genproto/googleapis/api/serviceconfig/auth.pb.go b/vendor/google.golang.org/genproto/googleapis/api/serviceconfig/auth.pb.go index e424320d..ac8de7dd 100644 --- a/vendor/google.golang.org/genproto/googleapis/api/serviceconfig/auth.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/api/serviceconfig/auth.pb.go @@ -215,6 +215,9 @@ type AuthProvider struct { // audiences: bookstore_android.apps.googleusercontent.com, // bookstore_web.apps.googleusercontent.com Audiences string `protobuf:"bytes,4,opt,name=audiences" json:"audiences,omitempty"` + // Redirect URL if JWT token is required but no present or is expired. + // Implement authorizationUrl of securityDefinitions in OpenAPI spec. + AuthorizationUrl string `protobuf:"bytes,5,opt,name=authorization_url,json=authorizationUrl" json:"authorization_url,omitempty"` } func (m *AuthProvider) Reset() { *m = AuthProvider{} } @@ -250,6 +253,13 @@ func (m *AuthProvider) GetAudiences() string { return "" } +func (m *AuthProvider) GetAuthorizationUrl() string { + if m != nil { + return m.AuthorizationUrl + } + return "" +} + // OAuth scopes are a way to define data and permissions on data. For example, // there are scopes defined for "Read-only access to Google Calendar" and // "Access to Cloud Platform". Users can consent to a scope for an application, @@ -349,33 +359,35 @@ func init() { func init() { proto.RegisterFile("google/api/auth.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ - // 437 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x52, 0xcd, 0x6e, 0xd3, 0x40, - 0x10, 0x96, 0x9d, 0xa6, 0x8d, 0x27, 0x55, 0x0a, 0x2b, 0x51, 0x99, 0x52, 0x20, 0xf2, 0x29, 0x5c, - 0x1c, 0xa9, 0x45, 0x08, 0x09, 0x09, 0xd4, 0x22, 0x84, 0x7a, 0x22, 0x32, 0x42, 0x48, 0x5c, 0xac, - 0x65, 0x3d, 0x38, 0x4b, 0xdd, 0x1d, 0xb3, 0x3f, 0xcd, 0x8d, 0x87, 0xe1, 0xc9, 0x78, 0x94, 0xca, - 0x6b, 0x37, 0x71, 0xd2, 0xe3, 0x7c, 0x3f, 0x33, 0xf3, 0xcd, 0x2e, 0x3c, 0x29, 0x89, 0xca, 0x0a, - 0xe7, 0xbc, 0x96, 0x73, 0xee, 0xec, 0x32, 0xad, 0x35, 0x59, 0x62, 0xd0, 0xc2, 0x29, 0xaf, 0xe5, - 0xc9, 0x69, 0x5f, 0xa2, 0x14, 0x59, 0x6e, 0x25, 0x29, 0xd3, 0x2a, 0x93, 0xbf, 0x30, 0xb9, 0x70, - 0x76, 0x89, 0xca, 0x4a, 0xe1, 0x09, 0xf6, 0x1a, 0x86, 0xda, 0x55, 0x68, 0xe2, 0xc1, 0x74, 0x30, - 0x1b, 0x9f, 0xbd, 0x48, 0x37, 0xbd, 0xd2, 0x6d, 0x69, 0xe6, 0x2a, 0xcc, 0x5a, 0x31, 0x7b, 0x03, - 0x51, 0xad, 0xe9, 0x56, 0x16, 0xa8, 0x4d, 0xbc, 0xe7, 0x9d, 0xf1, 0xae, 0x73, 0xd1, 0x09, 0xb2, - 0x8d, 0x34, 0xf9, 0x1f, 0x00, 0x7b, 0xd8, 0x95, 0x9d, 0xc0, 0xc8, 0x60, 0x85, 0xc2, 0x92, 0x8e, - 0x83, 0x69, 0x30, 0x8b, 0xb2, 0x75, 0xcd, 0xce, 0x61, 0x48, 0x4d, 0xd6, 0x38, 0x9c, 0x06, 0xb3, - 0xf1, 0xd9, 0xf3, 0xfe, 0x98, 0x2f, 0x4d, 0xaf, 0x0c, 0xff, 0x38, 0xa9, 0xf1, 0x06, 0x95, 0x35, - 0x59, 0xab, 0x65, 0x6f, 0x21, 0xe6, 0x55, 0x45, 0xab, 0x7c, 0x25, 0xed, 0x92, 0x9c, 0xcd, 0x85, - 0xc6, 0xa2, 0x19, 0xca, 0xab, 0x78, 0x38, 0x0d, 0x66, 0xa3, 0xec, 0xd8, 0xf3, 0xdf, 0x5b, 0xfa, - 0xe3, 0x9a, 0x65, 0x1f, 0xe0, 0x50, 0xf7, 0x1a, 0xc6, 0x07, 0x3e, 0xdc, 0xb3, 0xdd, 0x70, 0xbd, - 0xa1, 0xd9, 0x96, 0x21, 0x21, 0x38, 0xec, 0xa7, 0x67, 0x13, 0x08, 0x65, 0xd1, 0xa5, 0x0a, 0x65, - 0xc1, 0x8e, 0x61, 0x5f, 0x1a, 0xe3, 0x50, 0xfb, 0x40, 0x51, 0xd6, 0x55, 0xec, 0x29, 0x8c, 0x7e, - 0xaf, 0xae, 0x4d, 0xee, 0xb4, 0x8c, 0x07, 0x9e, 0x39, 0x68, 0xea, 0x6f, 0x5a, 0xb2, 0x53, 0x88, - 0xb8, 0x2b, 0x24, 0x2a, 0x81, 0xcd, 0xb5, 0x1b, 0x6e, 0x03, 0x24, 0xef, 0xe1, 0xf1, 0x83, 0x3b, - 0xb0, 0x57, 0xf0, 0x48, 0x70, 0x45, 0x4a, 0x0a, 0x5e, 0xe5, 0x46, 0x50, 0x8d, 0xa6, 0xdb, 0xe1, - 0x68, 0x8d, 0x7f, 0xf5, 0x70, 0xb2, 0x80, 0xa3, 0x1d, 0x3b, 0x7b, 0x09, 0xe3, 0xfb, 0x37, 0xcb, - 0xd7, 0xcb, 0xc3, 0x3d, 0x74, 0x55, 0x6c, 0x6f, 0x14, 0xee, 0x6c, 0x74, 0x79, 0x0d, 0x13, 0x41, - 0x37, 0xbd, 0x93, 0x5d, 0x46, 0xdd, 0x49, 0x2c, 0x2d, 0x82, 0x1f, 0x9f, 0x3a, 0xa2, 0xa4, 0x8a, - 0xab, 0x32, 0x25, 0x5d, 0xce, 0x4b, 0x54, 0xfe, 0x83, 0xce, 0x5b, 0x8a, 0xd7, 0xd2, 0xf8, 0x1f, - 0x6c, 0x50, 0xdf, 0x4a, 0x81, 0x82, 0xd4, 0x2f, 0x59, 0xbe, 0xdb, 0xaa, 0xfe, 0x85, 0x7b, 0x9f, - 0x2f, 0x16, 0x57, 0x3f, 0xf7, 0xbd, 0xf1, 0xfc, 0x2e, 0x00, 0x00, 0xff, 0xff, 0xb9, 0x6d, 0xc6, - 0x5e, 0x1c, 0x03, 0x00, 0x00, + // 465 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x52, 0x5f, 0x6b, 0x13, 0x4f, + 0x14, 0x65, 0x93, 0xa6, 0xcd, 0xde, 0x94, 0xb4, 0x1d, 0xf8, 0x95, 0xfd, 0xd5, 0xaa, 0x21, 0x4f, + 0x11, 0x61, 0x03, 0xad, 0x88, 0x20, 0x28, 0xad, 0x88, 0xf4, 0xc9, 0x30, 0x52, 0x04, 0x5f, 0x96, + 0x71, 0x76, 0xdc, 0x8c, 0x9d, 0xce, 0x5d, 0xe7, 0x4f, 0x03, 0x3e, 0xf8, 0x49, 0x7c, 0xf2, 0x93, + 0xf9, 0x51, 0x64, 0x67, 0xb7, 0xc9, 0x6e, 0xfa, 0x78, 0xef, 0x39, 0xe7, 0xde, 0x7b, 0xce, 0x0c, + 0xfc, 0x57, 0x20, 0x16, 0x4a, 0xcc, 0x59, 0x29, 0xe7, 0xcc, 0xbb, 0x65, 0x5a, 0x1a, 0x74, 0x48, + 0xa0, 0x6e, 0xa7, 0xac, 0x94, 0x27, 0xa7, 0x6d, 0x8a, 0xd6, 0xe8, 0x98, 0x93, 0xa8, 0x6d, 0xcd, + 0x9c, 0xfe, 0x82, 0xf1, 0x85, 0x77, 0x4b, 0xa1, 0x9d, 0xe4, 0x01, 0x20, 0x2f, 0x60, 0x60, 0xbc, + 0x12, 0x36, 0xe9, 0x4f, 0xfa, 0xb3, 0xd1, 0xd9, 0x93, 0x74, 0x33, 0x2b, 0xed, 0x52, 0xa9, 0x57, + 0x82, 0xd6, 0x64, 0xf2, 0x12, 0xe2, 0xd2, 0xe0, 0x9d, 0xcc, 0x85, 0xb1, 0xc9, 0x4e, 0x50, 0x26, + 0xdb, 0xca, 0x45, 0x43, 0xa0, 0x1b, 0xea, 0xf4, 0x6f, 0x04, 0xe4, 0xe1, 0x54, 0x72, 0x02, 0x43, + 0x2b, 0x94, 0xe0, 0x0e, 0x4d, 0x12, 0x4d, 0xa2, 0x59, 0x4c, 0xd7, 0x35, 0x39, 0x87, 0x01, 0x56, + 0x5e, 0x93, 0xde, 0x24, 0x9a, 0x8d, 0xce, 0x1e, 0xb7, 0xd7, 0x7c, 0xac, 0x66, 0x51, 0xf1, 0xc3, + 0x4b, 0x23, 0x6e, 0x85, 0x76, 0x96, 0xd6, 0x5c, 0xf2, 0x0a, 0x12, 0xa6, 0x14, 0xae, 0xb2, 0x95, + 0x74, 0x4b, 0xf4, 0x2e, 0xe3, 0x46, 0xe4, 0xd5, 0x52, 0xa6, 0x92, 0xc1, 0x24, 0x9a, 0x0d, 0xe9, + 0x71, 0xc0, 0x3f, 0xd7, 0xf0, 0xbb, 0x35, 0x4a, 0xde, 0xc2, 0xbe, 0x69, 0x0d, 0x4c, 0xf6, 0x82, + 0xb9, 0x47, 0xdb, 0xe6, 0x5a, 0x4b, 0x69, 0x47, 0x30, 0xfd, 0x1d, 0xc1, 0x7e, 0xdb, 0x3e, 0x19, + 0x43, 0x4f, 0xe6, 0x8d, 0xad, 0x9e, 0xcc, 0xc9, 0x31, 0xec, 0x4a, 0x6b, 0xbd, 0x30, 0xc1, 0x51, + 0x4c, 0x9b, 0x8a, 0xfc, 0x0f, 0xc3, 0xef, 0xab, 0x1b, 0x9b, 0x79, 0x23, 0x93, 0x7e, 0x40, 0xf6, + 0xaa, 0xfa, 0xda, 0x48, 0x72, 0x0a, 0x31, 0xf3, 0xb9, 0x14, 0x9a, 0x8b, 0x2a, 0xee, 0x0a, 0xdb, + 0x34, 0xc8, 0x73, 0x38, 0xaa, 0x4c, 0xa3, 0x91, 0x3f, 0x43, 0xa4, 0x99, 0x37, 0xb5, 0xcb, 0x98, + 0x1e, 0x76, 0x80, 0x6b, 0xa3, 0xa6, 0x6f, 0xe0, 0xe8, 0x41, 0x6a, 0xe4, 0x19, 0x1c, 0x72, 0xa6, + 0x51, 0x4b, 0xce, 0x54, 0x66, 0x39, 0x96, 0xc2, 0x36, 0x07, 0x1f, 0xac, 0xfb, 0x9f, 0x42, 0x7b, + 0xba, 0x80, 0x83, 0x2d, 0x39, 0x79, 0x0a, 0xa3, 0xfb, 0x17, 0xce, 0xd6, 0x4e, 0xe1, 0xbe, 0x75, + 0x95, 0x77, 0xcf, 0xef, 0x6d, 0x9d, 0x7f, 0x79, 0x03, 0x63, 0x8e, 0xb7, 0xad, 0x80, 0x2f, 0xe3, + 0x26, 0x3f, 0x87, 0x8b, 0xe8, 0xcb, 0xfb, 0x06, 0x28, 0x50, 0x31, 0x5d, 0xa4, 0x68, 0x8a, 0x79, + 0x21, 0x74, 0xf8, 0xce, 0xf3, 0x1a, 0x62, 0xa5, 0xb4, 0xe1, 0xbf, 0x5b, 0x61, 0xee, 0x24, 0x17, + 0x1c, 0xf5, 0x37, 0x59, 0xbc, 0xee, 0x54, 0x7f, 0x7a, 0x3b, 0x1f, 0x2e, 0x16, 0x57, 0x5f, 0x77, + 0x83, 0xf0, 0xfc, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe5, 0xa3, 0x9d, 0xc6, 0x4a, 0x03, 0x00, + 0x00, } diff --git a/vendor/google.golang.org/genproto/googleapis/api/servicecontrol/v1/service_controller.pb.go b/vendor/google.golang.org/genproto/googleapis/api/servicecontrol/v1/service_controller.pb.go index c5c6ea7f..3f3abc7c 100644 --- a/vendor/google.golang.org/genproto/googleapis/api/servicecontrol/v1/service_controller.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/api/servicecontrol/v1/service_controller.pb.go @@ -75,6 +75,8 @@ type CheckResponse struct { CheckErrors []*CheckError `protobuf:"bytes,2,rep,name=check_errors,json=checkErrors" json:"check_errors,omitempty"` // The actual config id used to process the request. ServiceConfigId string `protobuf:"bytes,5,opt,name=service_config_id,json=serviceConfigId" json:"service_config_id,omitempty"` + // Feedback data returned from the server during processing a Check request. + CheckInfo *CheckResponse_CheckInfo `protobuf:"bytes,6,opt,name=check_info,json=checkInfo" json:"check_info,omitempty"` } func (m *CheckResponse) Reset() { *m = CheckResponse{} } @@ -103,6 +105,49 @@ func (m *CheckResponse) GetServiceConfigId() string { return "" } +func (m *CheckResponse) GetCheckInfo() *CheckResponse_CheckInfo { + if m != nil { + return m.CheckInfo + } + return nil +} + +type CheckResponse_CheckInfo struct { + // Consumer info of this check. + ConsumerInfo *CheckResponse_ConsumerInfo `protobuf:"bytes,2,opt,name=consumer_info,json=consumerInfo" json:"consumer_info,omitempty"` +} + +func (m *CheckResponse_CheckInfo) Reset() { *m = CheckResponse_CheckInfo{} } +func (m *CheckResponse_CheckInfo) String() string { return proto.CompactTextString(m) } +func (*CheckResponse_CheckInfo) ProtoMessage() {} +func (*CheckResponse_CheckInfo) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1, 0} } + +func (m *CheckResponse_CheckInfo) GetConsumerInfo() *CheckResponse_ConsumerInfo { + if m != nil { + return m.ConsumerInfo + } + return nil +} + +// `ConsumerInfo` provides information about the consumer project. +type CheckResponse_ConsumerInfo struct { + // The Google cloud project number, e.g. 1234567890. A value of 0 indicates + // no project number is found. + ProjectNumber int64 `protobuf:"varint,1,opt,name=project_number,json=projectNumber" json:"project_number,omitempty"` +} + +func (m *CheckResponse_ConsumerInfo) Reset() { *m = CheckResponse_ConsumerInfo{} } +func (m *CheckResponse_ConsumerInfo) String() string { return proto.CompactTextString(m) } +func (*CheckResponse_ConsumerInfo) ProtoMessage() {} +func (*CheckResponse_ConsumerInfo) Descriptor() ([]byte, []int) { return fileDescriptor5, []int{1, 1} } + +func (m *CheckResponse_ConsumerInfo) GetProjectNumber() int64 { + if m != nil { + return m.ProjectNumber + } + return 0 +} + // Request message for the Report method. type ReportRequest struct { // The service name as specified in its service configuration. For example, @@ -168,8 +213,9 @@ type ReportResponse struct { // `Operations` in the request succeeded. Each // `Operation` that failed processing has a corresponding item // in this list. - // 3. A failed RPC status indicates a complete failure where none of the - // `Operations` in the request succeeded. + // 3. A failed RPC status indicates a general non-deterministic failure. + // When this happens, it's impossible to know which of the + // 'Operations' in the request succeeded or failed. ReportErrors []*ReportResponse_ReportError `protobuf:"bytes,1,rep,name=report_errors,json=reportErrors" json:"report_errors,omitempty"` // The actual config id used to process the request. ServiceConfigId string `protobuf:"bytes,2,opt,name=service_config_id,json=serviceConfigId" json:"service_config_id,omitempty"` @@ -224,6 +270,8 @@ func (m *ReportResponse_ReportError) GetStatus() *google_rpc.Status { func init() { proto.RegisterType((*CheckRequest)(nil), "google.api.servicecontrol.v1.CheckRequest") proto.RegisterType((*CheckResponse)(nil), "google.api.servicecontrol.v1.CheckResponse") + proto.RegisterType((*CheckResponse_CheckInfo)(nil), "google.api.servicecontrol.v1.CheckResponse.CheckInfo") + proto.RegisterType((*CheckResponse_ConsumerInfo)(nil), "google.api.servicecontrol.v1.CheckResponse.ConsumerInfo") proto.RegisterType((*ReportRequest)(nil), "google.api.servicecontrol.v1.ReportRequest") proto.RegisterType((*ReportResponse)(nil), "google.api.servicecontrol.v1.ReportResponse") proto.RegisterType((*ReportResponse_ReportError)(nil), "google.api.servicecontrol.v1.ReportResponse.ReportError") @@ -245,21 +293,25 @@ type ServiceControllerClient interface { // operation is executed. // // If feasible, the client should cache the check results and reuse them for - // up to 60s. In case of server errors, the client may rely on the cached + // 60 seconds. In case of server errors, the client can rely on the cached // results for longer time. // + // NOTE: the `CheckRequest` has the size limit of 64KB. + // // This method requires the `servicemanagement.services.check` permission // on the specified service. For more information, see // [Google Cloud IAM](https://cloud.google.com/iam). Check(ctx context.Context, in *CheckRequest, opts ...grpc.CallOption) (*CheckResponse, error) - // Reports operations to Google Service Control. It should be called - // after the operation is completed. + // Reports operation results to Google Service Control, such as logs and + // metrics. It should be called after an operation is completed. // - // If feasible, the client should aggregate reporting data for up to 5s to - // reduce API traffic. Limiting aggregation to 5s is to reduce data loss - // during client crashes. Clients should carefully choose the aggregation - // window to avoid data loss risk more than 0.01% for business and - // compliance reasons. + // If feasible, the client should aggregate reporting data for up to 5 + // seconds to reduce API traffic. Limiting aggregation to 5 seconds is to + // reduce data loss during client crashes. Clients should carefully choose + // the aggregation time window to avoid data loss risk more than 0.01% + // for business and compliance reasons. + // + // NOTE: the `ReportRequest` has the size limit of 1MB. // // This method requires the `servicemanagement.services.report` permission // on the specified service. For more information, see @@ -301,21 +353,25 @@ type ServiceControllerServer interface { // operation is executed. // // If feasible, the client should cache the check results and reuse them for - // up to 60s. In case of server errors, the client may rely on the cached + // 60 seconds. In case of server errors, the client can rely on the cached // results for longer time. // + // NOTE: the `CheckRequest` has the size limit of 64KB. + // // This method requires the `servicemanagement.services.check` permission // on the specified service. For more information, see // [Google Cloud IAM](https://cloud.google.com/iam). Check(context.Context, *CheckRequest) (*CheckResponse, error) - // Reports operations to Google Service Control. It should be called - // after the operation is completed. + // Reports operation results to Google Service Control, such as logs and + // metrics. It should be called after an operation is completed. // - // If feasible, the client should aggregate reporting data for up to 5s to - // reduce API traffic. Limiting aggregation to 5s is to reduce data loss - // during client crashes. Clients should carefully choose the aggregation - // window to avoid data loss risk more than 0.01% for business and - // compliance reasons. + // If feasible, the client should aggregate reporting data for up to 5 + // seconds to reduce API traffic. Limiting aggregation to 5 seconds is to + // reduce data loss during client crashes. Clients should carefully choose + // the aggregation time window to avoid data loss risk more than 0.01% + // for business and compliance reasons. + // + // NOTE: the `ReportRequest` has the size limit of 1MB. // // This method requires the `servicemanagement.services.report` permission // on the specified service. For more information, see @@ -385,39 +441,44 @@ func init() { } var fileDescriptor5 = []byte{ - // 537 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x94, 0xcf, 0x6e, 0xd3, 0x40, - 0x10, 0xc6, 0xb5, 0xee, 0x1f, 0xa9, 0xe3, 0x04, 0xd4, 0x3d, 0x40, 0x64, 0xf5, 0x90, 0xfa, 0x40, - 0x23, 0x37, 0xd8, 0x6a, 0x10, 0x12, 0x0a, 0x27, 0x1a, 0x55, 0x55, 0x41, 0x82, 0xca, 0xb9, 0x21, - 0x50, 0xb4, 0x38, 0x8b, 0xb1, 0x48, 0xbc, 0xcb, 0xae, 0x9b, 0x0b, 0xe2, 0xc2, 0x03, 0x70, 0x28, - 0x6f, 0x80, 0x90, 0x38, 0xf0, 0x04, 0x3c, 0x07, 0xaf, 0xc0, 0x43, 0xc0, 0x0d, 0x79, 0x77, 0xed, - 0x3a, 0xc2, 0x58, 0xee, 0x2d, 0x9e, 0x9d, 0xf9, 0xe6, 0xb7, 0xdf, 0x4c, 0x16, 0xee, 0xc7, 0x8c, - 0xc5, 0x0b, 0x1a, 0x10, 0x9e, 0x04, 0x92, 0x8a, 0x55, 0x12, 0xd1, 0x88, 0xa5, 0x99, 0x60, 0x8b, - 0x60, 0x75, 0x54, 0x44, 0x66, 0x26, 0xb4, 0xa0, 0xc2, 0xe7, 0x82, 0x65, 0x0c, 0xef, 0xe9, 0x32, - 0x9f, 0xf0, 0xc4, 0x5f, 0x2f, 0xf3, 0x57, 0x47, 0xce, 0x5e, 0x45, 0x94, 0xa4, 0x29, 0xcb, 0x48, - 0x96, 0xb0, 0x54, 0xea, 0x5a, 0xc7, 0x6f, 0x6c, 0x19, 0xbd, 0xa1, 0xd1, 0xdb, 0x19, 0x15, 0x82, - 0x99, 0x5e, 0xce, 0xb0, 0x31, 0x9f, 0x71, 0x2a, 0x94, 0xbc, 0xc9, 0xbe, 0x6d, 0xb2, 0x05, 0x8f, - 0x02, 0x99, 0x91, 0xec, 0xc2, 0xb4, 0x75, 0xbf, 0x22, 0xe8, 0x4c, 0x72, 0xf1, 0x90, 0xbe, 0xbb, - 0xa0, 0x32, 0xc3, 0xfb, 0xd0, 0x29, 0xee, 0x97, 0x92, 0x25, 0xed, 0xa1, 0x3e, 0x1a, 0xec, 0x84, - 0xb6, 0x89, 0x3d, 0x25, 0x4b, 0x8a, 0x4f, 0x60, 0xa7, 0xd4, 0xef, 0x59, 0x7d, 0x34, 0xb0, 0x47, - 0x07, 0x7e, 0xd3, 0xd5, 0xfd, 0x67, 0x45, 0x7a, 0x78, 0x55, 0x89, 0x3d, 0xd8, 0xad, 0x38, 0xf9, - 0x3a, 0x89, 0x67, 0xc9, 0xbc, 0xb7, 0xa9, 0xda, 0xdd, 0x34, 0x07, 0x13, 0x15, 0x3f, 0x9b, 0xbb, - 0xdf, 0x11, 0x74, 0x0d, 0xa6, 0xe4, 0x2c, 0x95, 0x34, 0xe7, 0x2c, 0xa5, 0xf2, 0x42, 0xc3, 0x59, - 0xc6, 0xce, 0xe6, 0xf8, 0x09, 0x74, 0x2a, 0xbe, 0xc9, 0x9e, 0xd5, 0xdf, 0x18, 0xd8, 0xa3, 0x41, - 0x33, 0xaa, 0xea, 0x72, 0x92, 0x17, 0x84, 0x76, 0x54, 0xfe, 0x96, 0xf5, 0xb4, 0x5b, 0xf5, 0xb4, - 0xdf, 0x10, 0x74, 0x43, 0xca, 0x99, 0xc8, 0xae, 0xe1, 0xea, 0x29, 0x40, 0x09, 0x5f, 0xb0, 0xb6, - 0xb6, 0xb5, 0x52, 0x5a, 0x4f, 0xba, 0x51, 0x4f, 0xfa, 0x07, 0xc1, 0x8d, 0x82, 0xd4, 0x18, 0xfb, - 0x12, 0xba, 0x42, 0x45, 0x0a, 0xdb, 0x90, 0x42, 0x79, 0xd0, 0x8c, 0xb2, 0x2e, 0x62, 0x3e, 0xb5, - 0x8d, 0x1d, 0x71, 0xf5, 0xf1, 0x1f, 0x3a, 0xab, 0x96, 0xce, 0x79, 0x01, 0x76, 0x45, 0xa8, 0xcd, - 0xc8, 0x3d, 0xd8, 0xd6, 0xeb, 0x6d, 0xf6, 0x12, 0x17, 0xd4, 0x82, 0x47, 0xfe, 0x54, 0x9d, 0x84, - 0x26, 0x63, 0xf4, 0xc3, 0x82, 0xdd, 0x69, 0xd9, 0xd1, 0xfc, 0x93, 0xf1, 0x27, 0x04, 0x5b, 0x6a, - 0x07, 0xb0, 0xd7, 0x62, 0x51, 0xcc, 0x7c, 0x9d, 0xc3, 0x56, 0xb9, 0xda, 0x1c, 0x77, 0xf8, 0xf1, - 0xe7, 0xaf, 0xcf, 0xd6, 0x1d, 0x77, 0xbf, 0xf2, 0x98, 0xc8, 0xe0, 0x7d, 0x75, 0x41, 0x3e, 0x8c, - 0xd5, 0xee, 0x8d, 0x91, 0x87, 0x2f, 0x11, 0x6c, 0x6b, 0x17, 0xf0, 0x61, 0xbb, 0x19, 0x68, 0xa4, - 0xe1, 0x75, 0x06, 0xe6, 0xde, 0x55, 0x4c, 0x07, 0xae, 0xdb, 0xc4, 0xa4, 0x07, 0x39, 0x46, 0xde, - 0xf1, 0x25, 0x82, 0x7e, 0xc4, 0x96, 0x8d, 0x2d, 0x8e, 0x6f, 0xfd, 0xe3, 0xee, 0x79, 0xfe, 0xe6, - 0x9c, 0xa3, 0xe7, 0x8f, 0x4d, 0x5d, 0xcc, 0x16, 0x24, 0x8d, 0x7d, 0x26, 0xe2, 0x20, 0xa6, 0xa9, - 0x7a, 0x91, 0x02, 0x7d, 0x44, 0x78, 0x22, 0xeb, 0xdf, 0xb6, 0x87, 0xeb, 0x91, 0xdf, 0x08, 0x7d, - 0xb1, 0x36, 0x4f, 0x1f, 0x4d, 0x27, 0xaf, 0xb6, 0x95, 0xc0, 0xbd, 0xbf, 0x01, 0x00, 0x00, 0xff, - 0xff, 0x6c, 0x58, 0x92, 0x07, 0xbe, 0x05, 0x00, 0x00, + // 619 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xc1, 0x6e, 0xd3, 0x4c, + 0x10, 0xd6, 0x3a, 0x6d, 0xa4, 0x4c, 0x9c, 0xfe, 0xea, 0x1e, 0x7e, 0x22, 0xab, 0x87, 0xd4, 0x12, + 0x34, 0x4a, 0x8b, 0xad, 0x16, 0x55, 0x42, 0xe1, 0x44, 0xa3, 0xaa, 0x0a, 0x48, 0xa5, 0x72, 0x38, + 0x21, 0xaa, 0xc8, 0xdd, 0x6c, 0x8c, 0x4b, 0xb2, 0x6b, 0xd6, 0x4e, 0x2e, 0x88, 0x0b, 0x0f, 0xc0, + 0xa1, 0xbc, 0x01, 0xaa, 0xc4, 0x33, 0xf0, 0x1c, 0xbc, 0x02, 0x0f, 0x01, 0x37, 0x94, 0xdd, 0xb5, + 0xeb, 0x08, 0x63, 0x92, 0x9b, 0xf7, 0xdb, 0x99, 0xf9, 0xbe, 0x9d, 0xf9, 0x3c, 0x70, 0x1c, 0x70, + 0x1e, 0x4c, 0xa8, 0xeb, 0x47, 0xa1, 0x1b, 0x53, 0x31, 0x0f, 0x09, 0x25, 0x9c, 0x25, 0x82, 0x4f, + 0xdc, 0xf9, 0x61, 0x8a, 0x0c, 0x35, 0x34, 0xa1, 0xc2, 0x89, 0x04, 0x4f, 0x38, 0xde, 0x51, 0x69, + 0x8e, 0x1f, 0x85, 0xce, 0x72, 0x9a, 0x33, 0x3f, 0xb4, 0x76, 0x72, 0x45, 0x7d, 0xc6, 0x78, 0xe2, + 0x27, 0x21, 0x67, 0xb1, 0xca, 0xb5, 0x9c, 0x52, 0x4a, 0xf2, 0x86, 0x92, 0xb7, 0x43, 0x2a, 0x04, + 0xd7, 0x5c, 0xd6, 0x41, 0x69, 0x3c, 0x8f, 0xa8, 0x90, 0xe5, 0x75, 0xf4, 0x3d, 0x1d, 0x2d, 0x22, + 0xe2, 0xc6, 0x89, 0x9f, 0xcc, 0x34, 0xad, 0x7d, 0x8b, 0xc0, 0xec, 0x2d, 0x8a, 0x7b, 0xf4, 0xdd, + 0x8c, 0xc6, 0x09, 0xde, 0x05, 0x33, 0x7d, 0x1f, 0xf3, 0xa7, 0xb4, 0x89, 0x5a, 0xa8, 0x5d, 0xf3, + 0xea, 0x1a, 0x3b, 0xf7, 0xa7, 0x14, 0x9f, 0x42, 0x2d, 0xab, 0xdf, 0x34, 0x5a, 0xa8, 0x5d, 0x3f, + 0xda, 0x73, 0xca, 0x9e, 0xee, 0xbc, 0x48, 0xc3, 0xbd, 0xbb, 0x4c, 0xdc, 0x81, 0xed, 0x5c, 0x27, + 0xc7, 0x61, 0x30, 0x0c, 0x47, 0xcd, 0x0d, 0x49, 0xf7, 0x9f, 0xbe, 0xe8, 0x49, 0xbc, 0x3f, 0xb2, + 0x6f, 0x2b, 0xd0, 0xd0, 0x32, 0xe3, 0x88, 0xb3, 0x98, 0x2e, 0x74, 0x66, 0xa5, 0x16, 0x89, 0x5a, + 0x67, 0x86, 0xf5, 0x47, 0xf8, 0x39, 0x98, 0xb9, 0xbe, 0xc5, 0x4d, 0xa3, 0x55, 0x69, 0xd7, 0x8f, + 0xda, 0xe5, 0x52, 0x25, 0xcb, 0xe9, 0x22, 0xc1, 0xab, 0x93, 0xec, 0x3b, 0x2e, 0x56, 0xbb, 0x59, + 0xa8, 0x16, 0xbf, 0x04, 0x50, 0xc4, 0x21, 0x1b, 0xf3, 0x66, 0x55, 0x76, 0xe8, 0x78, 0x05, 0xda, + 0xf4, 0x71, 0xea, 0xd4, 0x67, 0x63, 0xee, 0xd5, 0x48, 0xfa, 0x69, 0x5d, 0x43, 0x2d, 0xc3, 0xf1, + 0x25, 0x34, 0x08, 0x67, 0xf1, 0x6c, 0x4a, 0x85, 0x62, 0x51, 0x73, 0x78, 0xbc, 0x16, 0x8b, 0x2e, + 0x20, 0x89, 0x4c, 0x92, 0x3b, 0x59, 0xc7, 0x60, 0xe6, 0x6f, 0xf1, 0x7d, 0xd8, 0x8a, 0x04, 0xbf, + 0xa6, 0x24, 0x19, 0xb2, 0xd9, 0xf4, 0x8a, 0x0a, 0xd9, 0xef, 0x8a, 0xd7, 0xd0, 0xe8, 0xb9, 0x04, + 0xed, 0xaf, 0x08, 0x1a, 0x1e, 0x8d, 0xb8, 0x48, 0xd6, 0xb0, 0xd3, 0x19, 0x40, 0x36, 0xb5, 0x74, + 0x48, 0x2b, 0xfb, 0x29, 0x97, 0x5a, 0x3c, 0xa2, 0x4a, 0xb1, 0xa1, 0x7e, 0x21, 0xd8, 0x4a, 0x95, + 0x6a, 0x47, 0x5d, 0x42, 0x43, 0x48, 0x24, 0xf5, 0x0b, 0x92, 0x52, 0xfe, 0xd1, 0xd2, 0xe5, 0x22, + 0xfa, 0xa8, 0xfc, 0x63, 0x8a, 0xbb, 0xc3, 0x5f, 0xd4, 0x19, 0x85, 0xea, 0xac, 0xd7, 0x50, 0xcf, + 0x15, 0x5a, 0xc5, 0xeb, 0x1d, 0xa8, 0xaa, 0xff, 0x5a, 0x1b, 0x01, 0xa7, 0xaa, 0x45, 0x44, 0x9c, + 0x81, 0xbc, 0xf1, 0x74, 0xc4, 0xd1, 0x37, 0x03, 0xb6, 0x07, 0x19, 0xa3, 0x5e, 0x61, 0xf8, 0x13, + 0x82, 0x4d, 0xe9, 0x0f, 0xdc, 0x59, 0xc9, 0x44, 0x72, 0xbe, 0xd6, 0xfe, 0x1a, 0x86, 0xb3, 0x0f, + 0x3e, 0x7e, 0xff, 0xf1, 0xd9, 0x78, 0x60, 0xef, 0xe6, 0xb6, 0x68, 0xec, 0xbe, 0xcf, 0x1b, 0xe4, + 0x43, 0x57, 0x1a, 0xbe, 0x8b, 0x3a, 0xf8, 0x06, 0x41, 0x55, 0x75, 0x01, 0xef, 0xaf, 0x36, 0x03, + 0x25, 0xe9, 0x60, 0x9d, 0x81, 0xd9, 0x0f, 0xa5, 0xa6, 0x3d, 0xdb, 0x2e, 0xd3, 0xa4, 0x06, 0xd9, + 0x45, 0x9d, 0x93, 0x1b, 0x04, 0x2d, 0xc2, 0xa7, 0xa5, 0x14, 0x27, 0xff, 0xff, 0xd1, 0xdd, 0x8b, + 0xc5, 0xb2, 0xbd, 0x40, 0xaf, 0x9e, 0xe9, 0xbc, 0x80, 0x4f, 0x7c, 0x16, 0x38, 0x5c, 0x04, 0x6e, + 0x40, 0x99, 0x5c, 0xc5, 0xae, 0xba, 0xf2, 0xa3, 0x30, 0x2e, 0x5e, 0xea, 0x4f, 0x96, 0x91, 0x9f, + 0x08, 0x7d, 0x31, 0x36, 0xce, 0x9e, 0x0e, 0x7a, 0x57, 0x55, 0x59, 0xe0, 0xd1, 0xef, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x5e, 0x28, 0x7b, 0xe6, 0xb7, 0x06, 0x00, 0x00, } diff --git a/vendor/google.golang.org/genproto/googleapis/assistant/embedded/v1alpha1/embedded_assistant.pb.go b/vendor/google.golang.org/genproto/googleapis/assistant/embedded/v1alpha1/embedded_assistant.pb.go index 414e8cbc..f3917faf 100644 --- a/vendor/google.golang.org/genproto/googleapis/assistant/embedded/v1alpha1/embedded_assistant.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/assistant/embedded/v1alpha1/embedded_assistant.pb.go @@ -215,7 +215,7 @@ func (m *ConverseConfig) GetConverseState() *ConverseState { // Specifies how to process the `audio_in` data that will be provided in // subsequent requests. For recommended settings, see the Google Assistant SDK -// [best practices](https://developers.google.com/assistant/best-practices). +// [best practices](https://developers.google.com/assistant/sdk/develop/grpc/best-practices/audio). type AudioInConfig struct { // *Required* Encoding of audio data sent in all `audio_in` messages. Encoding AudioInConfig_Encoding `protobuf:"varint,1,opt,name=encoding,enum=google.assistant.embedded.v1alpha1.AudioInConfig_Encoding" json:"encoding,omitempty"` diff --git a/vendor/google.golang.org/genproto/googleapis/bigtable/v2/bigtable.pb.go b/vendor/google.golang.org/genproto/googleapis/bigtable/v2/bigtable.pb.go index 0b861f68..fcdc0faa 100644 --- a/vendor/google.golang.org/genproto/googleapis/bigtable/v2/bigtable.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/bigtable/v2/bigtable.pb.go @@ -1091,76 +1091,78 @@ var _Bigtable_serviceDesc = grpc.ServiceDesc{ func init() { proto.RegisterFile("google/bigtable/v2/bigtable.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ - // 1135 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x4f, 0x6f, 0x1b, 0x45, - 0x14, 0x67, 0xec, 0xda, 0xf1, 0xbe, 0x24, 0x4d, 0x32, 0x84, 0xc6, 0x35, 0x09, 0xb8, 0x4b, 0x0b, - 0x8e, 0x4b, 0xd7, 0x55, 0x50, 0x0f, 0x75, 0x95, 0x02, 0x0e, 0x49, 0x83, 0xc0, 0x55, 0x35, 0x96, - 0x40, 0x42, 0x48, 0xd6, 0x78, 0x3d, 0x76, 0x96, 0xec, 0xbf, 0xee, 0x8c, 0x63, 0x5c, 0xc4, 0x85, - 0x03, 0x1f, 0x00, 0xce, 0x88, 0x13, 0x82, 0x0b, 0x1c, 0xb9, 0x72, 0xe0, 0x23, 0x70, 0xe0, 0x0b, - 0xf4, 0x13, 0xf0, 0x09, 0xd0, 0xcc, 0xce, 0xda, 0x4e, 0x62, 0xb7, 0x9b, 0xaa, 0xb7, 0x9d, 0xf7, - 0xde, 0xef, 0xcd, 0xef, 0xfd, 0x1d, 0x1b, 0xae, 0xf5, 0x83, 0xa0, 0xef, 0xb2, 0x5a, 0xc7, 0xe9, - 0x0b, 0xda, 0x71, 0x59, 0xed, 0x64, 0x67, 0xfc, 0x6d, 0x85, 0x51, 0x20, 0x02, 0x8c, 0x63, 0x13, - 0x6b, 0x2c, 0x3e, 0xd9, 0x29, 0x6d, 0x6a, 0x18, 0x0d, 0x9d, 0x1a, 0xf5, 0xfd, 0x40, 0x50, 0xe1, - 0x04, 0x3e, 0x8f, 0x11, 0xa5, 0xad, 0x19, 0x4e, 0xbb, 0x54, 0x50, 0xad, 0x7e, 0x43, 0xab, 0xd5, - 0xa9, 0x33, 0xe8, 0xd5, 0x86, 0x11, 0x0d, 0x43, 0x16, 0x25, 0xf0, 0x0d, 0xad, 0x8f, 0x42, 0xbb, - 0xc6, 0x05, 0x15, 0x03, 0xad, 0x30, 0xff, 0x44, 0xb0, 0x42, 0x18, 0xed, 0x92, 0x60, 0xc8, 0x09, - 0x7b, 0x3c, 0x60, 0x5c, 0xe0, 0x2d, 0x00, 0x75, 0x47, 0xdb, 0xa7, 0x1e, 0x2b, 0xa2, 0x32, 0xaa, - 0x18, 0xc4, 0x50, 0x92, 0x87, 0xd4, 0x63, 0xd8, 0x82, 0x4b, 0x51, 0x30, 0xe4, 0xc5, 0x4c, 0x19, - 0x55, 0x16, 0x77, 0x4a, 0xd6, 0xf9, 0x58, 0x2c, 0x12, 0x0c, 0x5b, 0x4c, 0x10, 0x65, 0x87, 0xef, - 0x40, 0xbe, 0xe7, 0xb8, 0x82, 0x45, 0xc5, 0xac, 0x42, 0x6c, 0xcd, 0x41, 0x1c, 0x28, 0x23, 0xa2, - 0x8d, 0x25, 0x0b, 0x09, 0x6f, 0xbb, 0x8e, 0xe7, 0x88, 0xe2, 0xa5, 0x32, 0xaa, 0x64, 0x89, 0x21, - 0x25, 0x9f, 0x4a, 0x81, 0xf9, 0x5f, 0x16, 0x56, 0x27, 0xc4, 0x79, 0x18, 0xf8, 0x9c, 0xe1, 0x03, - 0xc8, 0xdb, 0x47, 0x03, 0xff, 0x98, 0x17, 0x51, 0x39, 0x5b, 0x59, 0xdc, 0xb1, 0x66, 0x5e, 0x75, - 0x06, 0x65, 0xed, 0x31, 0xd7, 0xdd, 0x93, 0x30, 0xa2, 0xd1, 0xb8, 0x06, 0xeb, 0x2e, 0xe5, 0xa2, - 0xcd, 0x6d, 0xea, 0xfb, 0xac, 0xdb, 0x8e, 0x82, 0x61, 0xfb, 0x98, 0x8d, 0x54, 0xc8, 0x4b, 0x64, - 0x4d, 0xea, 0x5a, 0xb1, 0x8a, 0x04, 0xc3, 0x4f, 0xd8, 0xa8, 0xf4, 0x34, 0x03, 0xc6, 0xd8, 0x0d, - 0xde, 0x80, 0x85, 0x04, 0x81, 0x14, 0x22, 0x1f, 0x29, 0x33, 0xbc, 0x0b, 0x8b, 0x3d, 0xea, 0x39, - 0xee, 0x28, 0x4e, 0x6d, 0x9c, 0xc1, 0xcd, 0x84, 0x64, 0x52, 0x3c, 0xab, 0x25, 0x22, 0xc7, 0xef, - 0x7f, 0x46, 0xdd, 0x01, 0x23, 0x10, 0x03, 0x54, 0xe6, 0xef, 0x82, 0xf1, 0x78, 0x40, 0x5d, 0xa7, - 0xe7, 0x8c, 0x93, 0xf9, 0xfa, 0x39, 0x70, 0x63, 0x24, 0x18, 0x8f, 0xb1, 0x13, 0x6b, 0xbc, 0x0d, - 0xab, 0xc2, 0xf1, 0x18, 0x17, 0xd4, 0x0b, 0xdb, 0x9e, 0x63, 0x47, 0x01, 0xd7, 0x39, 0x5d, 0x19, - 0xcb, 0x9b, 0x4a, 0x8c, 0xaf, 0x40, 0xde, 0xa5, 0x1d, 0xe6, 0xf2, 0x62, 0xae, 0x9c, 0xad, 0x18, - 0x44, 0x9f, 0xf0, 0x3a, 0xe4, 0x4e, 0xa4, 0xdb, 0x62, 0x5e, 0xc5, 0x14, 0x1f, 0x64, 0x99, 0xd4, - 0x47, 0x9b, 0x3b, 0x4f, 0x58, 0x71, 0xa1, 0x8c, 0x2a, 0x39, 0x62, 0x28, 0x49, 0xcb, 0x79, 0x22, - 0xd5, 0x46, 0xc4, 0x38, 0x13, 0x32, 0x85, 0xc5, 0x42, 0x19, 0x55, 0x0a, 0x87, 0xaf, 0x90, 0x82, - 0x12, 0x91, 0x60, 0x88, 0xdf, 0x04, 0xb0, 0x03, 0xcf, 0x73, 0x62, 0xbd, 0xa1, 0xf5, 0x46, 0x2c, - 0x23, 0xc1, 0xb0, 0xb1, 0xa4, 0xba, 0xa0, 0x1d, 0xf7, 0xac, 0x79, 0x07, 0xd6, 0x5b, 0xd4, 0x0b, - 0x5d, 0x16, 0xa7, 0x3d, 0x65, 0xc7, 0x9a, 0x2d, 0x78, 0xed, 0x0c, 0x4c, 0xf7, 0xcb, 0xdc, 0x42, - 0x5d, 0x83, 0xa5, 0xa0, 0xd7, 0x93, 0xbc, 0x3b, 0x32, 0x9d, 0xaa, 0x52, 0x59, 0xb2, 0x18, 0xcb, - 0x54, 0x86, 0xcd, 0xef, 0x11, 0xac, 0x36, 0x07, 0x82, 0x0a, 0xe9, 0x35, 0xe5, 0xe8, 0x4c, 0xdd, - 0x97, 0x39, 0x75, 0x5f, 0x1d, 0x0c, 0x6f, 0xa0, 0x27, 0xbe, 0x98, 0x55, 0xbd, 0xbb, 0x39, 0xab, - 0x77, 0x9b, 0xda, 0x88, 0x4c, 0xcc, 0xcd, 0x57, 0x61, 0x6d, 0x8a, 0x47, 0x1c, 0x99, 0xf9, 0x2f, - 0x9a, 0x92, 0xa6, 0x9d, 0xec, 0x7d, 0x58, 0x60, 0xbe, 0x88, 0x1c, 0x15, 0xb0, 0xe4, 0x70, 0x73, - 0x2e, 0x87, 0x69, 0xb7, 0xd6, 0xbe, 0x2f, 0xa2, 0x11, 0x49, 0xb0, 0xa5, 0x2f, 0x21, 0xa7, 0x24, - 0xf3, 0xd3, 0x7b, 0x2a, 0xdc, 0xcc, 0xc5, 0xc2, 0xfd, 0x15, 0x01, 0x9e, 0xa6, 0x30, 0x1e, 0xfd, - 0x31, 0xf7, 0x78, 0xf6, 0xdf, 0x7d, 0x1e, 0x77, 0x3d, 0xfd, 0x67, 0xc8, 0x7f, 0x9c, 0x90, 0x5f, - 0x87, 0x9c, 0xe3, 0x77, 0xd9, 0xd7, 0x8a, 0x7a, 0x96, 0xc4, 0x07, 0x5c, 0x85, 0x7c, 0xdc, 0x8b, - 0x7a, 0x78, 0x71, 0x72, 0x4b, 0x14, 0xda, 0x56, 0x4b, 0x69, 0x88, 0xb6, 0x30, 0x7f, 0xcb, 0x40, - 0x71, 0xef, 0x88, 0xd9, 0xc7, 0x1f, 0xfa, 0xdd, 0x97, 0xd6, 0x29, 0x87, 0xb0, 0x1a, 0x46, 0xac, - 0xeb, 0xd8, 0x54, 0xb0, 0xb6, 0xde, 0xab, 0xf9, 0x34, 0x7b, 0x75, 0x65, 0x0c, 0x8b, 0x05, 0x78, - 0x0f, 0x2e, 0x8b, 0x68, 0xc0, 0xda, 0x93, 0x4a, 0x5c, 0x4a, 0x51, 0x89, 0x65, 0x89, 0x49, 0x4e, - 0x1c, 0xef, 0xc3, 0x4a, 0x8f, 0xba, 0x7c, 0xda, 0x4b, 0x2e, 0x85, 0x97, 0xcb, 0x0a, 0x34, 0x76, - 0x63, 0x1e, 0xc2, 0xd5, 0x19, 0x99, 0xd2, 0xa5, 0xbd, 0x09, 0x6b, 0x93, 0x90, 0x3d, 0x2a, 0xec, - 0x23, 0xd6, 0x55, 0x19, 0x2b, 0x90, 0x49, 0x2e, 0x9a, 0xb1, 0xdc, 0xfc, 0x01, 0xc1, 0x55, 0xb9, - 0xe1, 0x9b, 0x41, 0xd7, 0xe9, 0x8d, 0x3e, 0x8f, 0x9c, 0x97, 0x92, 0xf5, 0x5d, 0xc8, 0x45, 0x03, - 0x97, 0x25, 0xb3, 0xf9, 0xce, 0xbc, 0x77, 0x65, 0xfa, 0xd6, 0x81, 0xcb, 0x48, 0x8c, 0x32, 0x1f, - 0x40, 0x69, 0x16, 0x27, 0x1d, 0xdf, 0x36, 0x64, 0xe5, 0xf6, 0x43, 0xaa, 0x8a, 0x1b, 0x73, 0xaa, - 0x48, 0xa4, 0xcd, 0xce, 0xef, 0x05, 0x28, 0x34, 0xb4, 0x02, 0xff, 0x84, 0xa0, 0x90, 0x3c, 0x66, - 0xf8, 0xad, 0x67, 0x3f, 0x75, 0x2a, 0xfc, 0xd2, 0xf5, 0x34, 0xef, 0xa1, 0xf9, 0xd1, 0x77, 0xff, - 0x3c, 0xfd, 0x31, 0x73, 0xdf, 0xbc, 0x2b, 0x7f, 0x64, 0x7c, 0x33, 0xc9, 0xd7, 0x6e, 0x18, 0x05, - 0x5f, 0x31, 0x5b, 0xf0, 0x5a, 0xb5, 0xe6, 0xf8, 0x5c, 0x50, 0xdf, 0x66, 0xf2, 0x5b, 0x59, 0xf0, - 0x5a, 0xf5, 0xdb, 0x7a, 0xa4, 0x5d, 0xd5, 0x51, 0xf5, 0x36, 0xc2, 0x7f, 0x20, 0x58, 0x3e, 0xb5, - 0x77, 0x71, 0x65, 0xd6, 0xfd, 0xb3, 0x36, 0x7a, 0x69, 0x3b, 0x85, 0xa5, 0xa6, 0x7b, 0xa0, 0xe8, - 0x7e, 0x80, 0xef, 0x5f, 0x98, 0x2e, 0x9f, 0xf6, 0x77, 0x1b, 0xe1, 0x9f, 0x11, 0x18, 0xe3, 0xf6, - 0xc3, 0xd7, 0x9f, 0xb9, 0x40, 0x12, 0xa2, 0x37, 0x9e, 0x63, 0xa5, 0x49, 0xee, 0x2b, 0x92, 0xef, - 0x9b, 0xf5, 0x0b, 0x93, 0xf4, 0x12, 0x5f, 0x75, 0x54, 0xc5, 0xbf, 0x20, 0x80, 0xc9, 0x0e, 0xc3, - 0x37, 0x52, 0xed, 0xe7, 0xd2, 0xdb, 0xe9, 0x56, 0x61, 0x92, 0x49, 0xf3, 0xde, 0x8b, 0x93, 0xd4, - 0xa5, 0xff, 0x0b, 0xc1, 0xda, 0xb9, 0x81, 0xc6, 0x33, 0x57, 0xf2, 0xbc, 0x0d, 0x59, 0xba, 0x95, - 0xd2, 0x5a, 0x93, 0x6f, 0x2a, 0xf2, 0x0f, 0xcc, 0xc6, 0x85, 0xc9, 0xdb, 0x67, 0x7d, 0xca, 0x4c, - 0xff, 0x8d, 0x00, 0x9f, 0x9f, 0x59, 0x7c, 0x2b, 0xcd, 0xe4, 0x4f, 0x62, 0xb0, 0xd2, 0x9a, 0xeb, - 0x20, 0x1e, 0xaa, 0x20, 0x0e, 0xcd, 0xbd, 0x17, 0x1a, 0xbd, 0xd3, 0x4e, 0xeb, 0xa8, 0xda, 0x60, - 0x70, 0xc5, 0x0e, 0xbc, 0x19, 0x24, 0x1a, 0xcb, 0xc9, 0x1a, 0x79, 0x24, 0x7f, 0x38, 0x3e, 0x42, - 0x5f, 0xd4, 0xb5, 0x51, 0x3f, 0x70, 0xa9, 0xdf, 0xb7, 0x82, 0xa8, 0x5f, 0xeb, 0x33, 0x5f, 0xfd, - 0xac, 0xac, 0xc5, 0x2a, 0x1a, 0x3a, 0x7c, 0xfa, 0x0f, 0xc8, 0xbd, 0xe4, 0xbb, 0x93, 0x57, 0x66, - 0xef, 0xfd, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x38, 0x8d, 0xf4, 0x91, 0xfb, 0x0c, 0x00, 0x00, + // 1154 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xdd, 0x6e, 0x1b, 0x45, + 0x14, 0x66, 0xec, 0xd8, 0xf1, 0x9e, 0x24, 0x4d, 0x32, 0x84, 0x66, 0x6b, 0x12, 0x70, 0x97, 0x16, + 0x1c, 0x97, 0xae, 0x2b, 0xa3, 0x5e, 0xd4, 0x55, 0x0a, 0xd8, 0xe4, 0x07, 0x81, 0xab, 0x6a, 0x2c, + 0x15, 0x09, 0x21, 0x59, 0xe3, 0xf5, 0xd8, 0x59, 0xb2, 0x7f, 0xdd, 0x9d, 0x8d, 0x71, 0x11, 0x12, + 0xe2, 0x82, 0x07, 0x80, 0x6b, 0xc4, 0x15, 0x02, 0x21, 0xc1, 0x25, 0xb7, 0x5c, 0xf0, 0x08, 0x5c, + 0xf0, 0x02, 0x7d, 0x02, 0x9e, 0xa0, 0xda, 0xd9, 0x59, 0xdb, 0x49, 0xec, 0x76, 0x53, 0xf5, 0x6e, + 0xe7, 0x9c, 0xf3, 0x9d, 0xf9, 0xce, 0xef, 0xd8, 0x70, 0x75, 0xe0, 0xba, 0x03, 0x8b, 0x55, 0xbb, + 0xe6, 0x80, 0xd3, 0xae, 0xc5, 0xaa, 0x27, 0xb5, 0xf1, 0xb7, 0xee, 0xf9, 0x2e, 0x77, 0x31, 0x8e, + 0x4d, 0xf4, 0xb1, 0xf8, 0xa4, 0x56, 0xdc, 0x92, 0x30, 0xea, 0x99, 0x55, 0xea, 0x38, 0x2e, 0xa7, + 0xdc, 0x74, 0x9d, 0x20, 0x46, 0x14, 0xb7, 0x67, 0x38, 0xed, 0x51, 0x4e, 0xa5, 0xfa, 0x0d, 0xa9, + 0x16, 0xa7, 0x6e, 0xd8, 0xaf, 0x0e, 0x7d, 0xea, 0x79, 0xcc, 0x4f, 0xe0, 0x9b, 0x52, 0xef, 0x7b, + 0x46, 0x35, 0xe0, 0x94, 0x87, 0x52, 0xa1, 0xfd, 0x85, 0x60, 0x95, 0x30, 0xda, 0x23, 0xee, 0x30, + 0x20, 0xec, 0x51, 0xc8, 0x02, 0x8e, 0xb7, 0x01, 0xc4, 0x1d, 0x1d, 0x87, 0xda, 0x4c, 0x45, 0x25, + 0x54, 0x56, 0x88, 0x22, 0x24, 0xf7, 0xa9, 0xcd, 0xb0, 0x0e, 0x0b, 0xbe, 0x3b, 0x0c, 0xd4, 0x4c, + 0x09, 0x95, 0x97, 0x6a, 0x45, 0xfd, 0x7c, 0x2c, 0x3a, 0x71, 0x87, 0x6d, 0xc6, 0x89, 0xb0, 0xc3, + 0xb7, 0x21, 0xdf, 0x37, 0x2d, 0xce, 0x7c, 0x35, 0x2b, 0x10, 0xdb, 0x73, 0x10, 0xfb, 0xc2, 0x88, + 0x48, 0xe3, 0x88, 0x45, 0x04, 0xef, 0x58, 0xa6, 0x6d, 0x72, 0x75, 0xa1, 0x84, 0xca, 0x59, 0xa2, + 0x44, 0x92, 0x4f, 0x23, 0x81, 0xf6, 0x7f, 0x16, 0xd6, 0x26, 0xc4, 0x03, 0xcf, 0x75, 0x02, 0x86, + 0xf7, 0x21, 0x6f, 0x1c, 0x85, 0xce, 0x71, 0xa0, 0xa2, 0x52, 0xb6, 0xbc, 0x54, 0xd3, 0x67, 0x5e, + 0x75, 0x06, 0xa5, 0x37, 0x99, 0x65, 0x35, 0x23, 0x18, 0x91, 0x68, 0x5c, 0x85, 0x0d, 0x8b, 0x06, + 0xbc, 0x13, 0x18, 0xd4, 0x71, 0x58, 0xaf, 0xe3, 0xbb, 0xc3, 0xce, 0x31, 0x1b, 0x89, 0x90, 0x97, + 0xc9, 0x7a, 0xa4, 0x6b, 0xc7, 0x2a, 0xe2, 0x0e, 0x3f, 0x61, 0xa3, 0xe2, 0x93, 0x0c, 0x28, 0x63, + 0x37, 0x78, 0x13, 0x16, 0x13, 0x04, 0x12, 0x88, 0xbc, 0x2f, 0xcc, 0xf0, 0x2e, 0x2c, 0xf5, 0xa9, + 0x6d, 0x5a, 0xa3, 0x38, 0xb5, 0x71, 0x06, 0xb7, 0x12, 0x92, 0x49, 0xf1, 0xf4, 0x36, 0xf7, 0x4d, + 0x67, 0xf0, 0x90, 0x5a, 0x21, 0x23, 0x10, 0x03, 0x44, 0xe6, 0xef, 0x80, 0xf2, 0x28, 0xa4, 0x96, + 0xd9, 0x37, 0xc7, 0xc9, 0x7c, 0xfd, 0x1c, 0xb8, 0x31, 0xe2, 0x2c, 0x88, 0xb1, 0x13, 0x6b, 0xbc, + 0x03, 0x6b, 0xdc, 0xb4, 0x59, 0xc0, 0xa9, 0xed, 0x75, 0x6c, 0xd3, 0xf0, 0xdd, 0x40, 0xe6, 0x74, + 0x75, 0x2c, 0x6f, 0x09, 0x31, 0xbe, 0x0c, 0x79, 0x8b, 0x76, 0x99, 0x15, 0xa8, 0xb9, 0x52, 0xb6, + 0xac, 0x10, 0x79, 0xc2, 0x1b, 0x90, 0x3b, 0x89, 0xdc, 0xaa, 0x79, 0x11, 0x53, 0x7c, 0x88, 0xca, + 0x24, 0x3e, 0x3a, 0x81, 0xf9, 0x98, 0xa9, 0x8b, 0x25, 0x54, 0xce, 0x11, 0x45, 0x48, 0xda, 0xe6, + 0xe3, 0x48, 0xad, 0xf8, 0x2c, 0x60, 0x3c, 0x4a, 0xa1, 0x5a, 0x28, 0xa1, 0x72, 0xe1, 0xf0, 0x15, + 0x52, 0x10, 0x22, 0xe2, 0x0e, 0xf1, 0x9b, 0x00, 0x86, 0x6b, 0xdb, 0x66, 0xac, 0x57, 0xa4, 0x5e, + 0x89, 0x65, 0xc4, 0x1d, 0x36, 0x96, 0x45, 0x17, 0x74, 0xe2, 0x9e, 0xd5, 0x6e, 0xc3, 0x46, 0x9b, + 0xda, 0x9e, 0xc5, 0xe2, 0xb4, 0xa7, 0xec, 0x58, 0xad, 0x0d, 0xaf, 0x9d, 0x81, 0xc9, 0x7e, 0x99, + 0x5b, 0xa8, 0xab, 0xb0, 0xec, 0xf6, 0xfb, 0x11, 0xef, 0x6e, 0x94, 0x4e, 0x51, 0xa9, 0x2c, 0x59, + 0x8a, 0x65, 0x22, 0xc3, 0xda, 0xf7, 0x08, 0xd6, 0x5a, 0x21, 0xa7, 0x3c, 0xf2, 0x9a, 0x72, 0x74, + 0xa6, 0xee, 0xcb, 0x9c, 0xba, 0xaf, 0x0e, 0x8a, 0x1d, 0xca, 0x89, 0x57, 0xb3, 0xa2, 0x77, 0xb7, + 0x66, 0xf5, 0x6e, 0x4b, 0x1a, 0x91, 0x89, 0xb9, 0xf6, 0x2a, 0xac, 0x4f, 0xf1, 0x88, 0x23, 0xd3, + 0xfe, 0x43, 0x53, 0xd2, 0xb4, 0x93, 0xbd, 0x07, 0x8b, 0xcc, 0xe1, 0xbe, 0x29, 0x02, 0x8e, 0x38, + 0xdc, 0x98, 0xcb, 0x61, 0xda, 0xad, 0xbe, 0xe7, 0x70, 0x7f, 0x44, 0x12, 0x6c, 0xf1, 0x0b, 0xc8, + 0x09, 0xc9, 0xfc, 0xf4, 0x9e, 0x0a, 0x37, 0x73, 0xb1, 0x70, 0x7f, 0x45, 0x80, 0xa7, 0x29, 0x8c, + 0x47, 0x7f, 0xcc, 0x3d, 0x9e, 0xfd, 0x77, 0x9f, 0xc7, 0x5d, 0x4e, 0xff, 0x19, 0xf2, 0x1f, 0x27, + 0xe4, 0x37, 0x20, 0x67, 0x3a, 0x3d, 0xf6, 0x95, 0xa0, 0x9e, 0x25, 0xf1, 0x01, 0x57, 0x20, 0x1f, + 0xf7, 0xa2, 0x1c, 0x5e, 0x9c, 0xdc, 0xe2, 0x7b, 0x86, 0xde, 0x16, 0x1a, 0x22, 0x2d, 0xb4, 0xdf, + 0x32, 0xa0, 0x36, 0x8f, 0x98, 0x71, 0xfc, 0xa1, 0xd3, 0x7b, 0x69, 0x9d, 0x72, 0x08, 0x6b, 0x9e, + 0xcf, 0x7a, 0xa6, 0x41, 0x39, 0xeb, 0xc8, 0xbd, 0x9a, 0x4f, 0xb3, 0x57, 0x57, 0xc7, 0xb0, 0x58, + 0x80, 0x9b, 0x70, 0x89, 0xfb, 0x21, 0xeb, 0x4c, 0x2a, 0xb1, 0x90, 0xa2, 0x12, 0x2b, 0x11, 0x26, + 0x39, 0x05, 0x78, 0x0f, 0x56, 0xfb, 0xd4, 0x0a, 0xa6, 0xbd, 0xe4, 0x52, 0x78, 0xb9, 0x24, 0x40, + 0x63, 0x37, 0xda, 0x21, 0x5c, 0x99, 0x91, 0x29, 0x59, 0xda, 0x1b, 0xb0, 0x3e, 0x09, 0xd9, 0xa6, + 0xdc, 0x38, 0x62, 0x3d, 0x91, 0xb1, 0x02, 0x99, 0xe4, 0xa2, 0x15, 0xcb, 0xb5, 0x1f, 0x10, 0x5c, + 0x89, 0x36, 0x7c, 0xcb, 0xed, 0x99, 0xfd, 0xd1, 0x67, 0xbe, 0xf9, 0x52, 0xb2, 0xbe, 0x0b, 0x39, + 0x3f, 0xb4, 0x58, 0x32, 0x9b, 0xef, 0xcc, 0x7b, 0x57, 0xa6, 0x6f, 0x0d, 0x2d, 0x46, 0x62, 0x94, + 0x76, 0x00, 0xc5, 0x59, 0x9c, 0x64, 0x7c, 0x3b, 0x90, 0x8d, 0xb6, 0x1f, 0x12, 0x55, 0xdc, 0x9c, + 0x53, 0x45, 0x12, 0xd9, 0xd4, 0xfe, 0x28, 0x40, 0xa1, 0x21, 0x15, 0xf8, 0x27, 0x04, 0x85, 0xe4, + 0x31, 0xc3, 0x6f, 0x3d, 0xfb, 0xa9, 0x13, 0xe1, 0x17, 0xaf, 0xa5, 0x79, 0x0f, 0xb5, 0x8f, 0xbe, + 0xfb, 0xf7, 0xc9, 0x8f, 0x99, 0x7b, 0xda, 0x9d, 0xe8, 0x47, 0xc6, 0xd7, 0x93, 0x7c, 0xed, 0x7a, + 0xbe, 0xfb, 0x25, 0x33, 0x78, 0x50, 0xad, 0x54, 0x4d, 0x27, 0xe0, 0xd4, 0x31, 0x58, 0xf4, 0x2d, + 0x2c, 0x82, 0x6a, 0xe5, 0x9b, 0xba, 0x2f, 0x5d, 0xd5, 0x51, 0xe5, 0x16, 0xc2, 0x7f, 0x22, 0x58, + 0x39, 0xb5, 0x77, 0x71, 0x79, 0xd6, 0xfd, 0xb3, 0x36, 0x7a, 0x71, 0x27, 0x85, 0xa5, 0xa4, 0xbb, + 0x2f, 0xe8, 0x7e, 0x80, 0xef, 0x5d, 0x98, 0x6e, 0x30, 0xed, 0xef, 0x16, 0xc2, 0x3f, 0x23, 0x50, + 0xc6, 0xed, 0x87, 0xaf, 0x3d, 0x73, 0x81, 0x24, 0x44, 0xaf, 0x3f, 0xc7, 0x4a, 0x92, 0xdc, 0x13, + 0x24, 0xdf, 0xd7, 0xea, 0x17, 0x26, 0x69, 0x27, 0xbe, 0xea, 0xa8, 0x82, 0x7f, 0x41, 0x00, 0x93, + 0x1d, 0x86, 0xaf, 0xa7, 0xda, 0xcf, 0xc5, 0xb7, 0xd3, 0xad, 0xc2, 0x24, 0x93, 0xda, 0xdd, 0x17, + 0x27, 0x29, 0x4b, 0xff, 0x37, 0x82, 0xf5, 0x73, 0x03, 0x8d, 0x67, 0xae, 0xe4, 0x79, 0x1b, 0xb2, + 0x78, 0x33, 0xa5, 0xb5, 0x24, 0xdf, 0x12, 0xe4, 0x0f, 0xb4, 0xc6, 0x85, 0xc9, 0x1b, 0x67, 0x7d, + 0x46, 0x99, 0xfe, 0x07, 0x01, 0x3e, 0x3f, 0xb3, 0xf8, 0x66, 0x9a, 0xc9, 0x9f, 0xc4, 0xa0, 0xa7, + 0x35, 0x97, 0x41, 0xdc, 0x17, 0x41, 0x1c, 0x6a, 0xcd, 0x17, 0x1a, 0xbd, 0xd3, 0x4e, 0xeb, 0xa8, + 0xd2, 0xf8, 0x16, 0xc1, 0x65, 0xc3, 0xb5, 0x67, 0xb0, 0x68, 0xac, 0x24, 0x7b, 0xe4, 0x41, 0xf4, + 0xcb, 0xf1, 0x01, 0xfa, 0xbc, 0x2e, 0x8d, 0x06, 0xae, 0x45, 0x9d, 0x81, 0xee, 0xfa, 0x83, 0xea, + 0x80, 0x39, 0xe2, 0x77, 0x65, 0x35, 0x56, 0x51, 0xcf, 0x0c, 0xa6, 0xff, 0x81, 0xdc, 0x4d, 0xbe, + 0x7f, 0xcf, 0xa8, 0x07, 0x31, 0xb8, 0x69, 0xb9, 0x61, 0x4f, 0x4f, 0x5c, 0xeb, 0x0f, 0x6b, 0xdd, + 0xbc, 0xf0, 0xf0, 0xde, 0xd3, 0x00, 0x00, 0x00, 0xff, 0xff, 0x74, 0x6b, 0x7a, 0xa3, 0x17, 0x0d, + 0x00, 0x00, } diff --git a/vendor/google.golang.org/genproto/googleapis/bigtable/v2/data.pb.go b/vendor/google.golang.org/genproto/googleapis/bigtable/v2/data.pb.go index a256a3a5..cf96dc22 100644 --- a/vendor/google.golang.org/genproto/googleapis/bigtable/v2/data.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/bigtable/v2/data.pb.go @@ -2024,94 +2024,95 @@ func init() { func init() { proto.RegisterFile("google/bigtable/v2/data.proto", fileDescriptor1) } var fileDescriptor1 = []byte{ - // 1412 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xdb, 0x6e, 0xdb, 0x46, - 0x13, 0x16, 0x2d, 0xeb, 0x34, 0x94, 0x25, 0x65, 0xe3, 0x38, 0x8a, 0xfe, 0xf8, 0x8f, 0xc1, 0x14, - 0xa9, 0xe2, 0xb6, 0x72, 0xab, 0x04, 0xe9, 0x21, 0x45, 0x11, 0xcb, 0x69, 0xaa, 0x36, 0xe7, 0x8d, - 0x91, 0x02, 0x01, 0x0a, 0x76, 0x2d, 0xad, 0x54, 0xc2, 0x4b, 0x2e, 0x4b, 0x52, 0x56, 0xf4, 0x22, - 0xbd, 0x6f, 0x5f, 0xa3, 0x77, 0x7d, 0x89, 0xf6, 0x31, 0xfa, 0x00, 0xbd, 0x28, 0xf6, 0xc0, 0x93, - 0xa2, 0xd8, 0x46, 0x91, 0x3b, 0x72, 0xe6, 0xfb, 0xbe, 0x99, 0x9d, 0x9d, 0x1d, 0x2e, 0x61, 0x7b, - 0xca, 0xf9, 0x94, 0xd1, 0xbd, 0x23, 0x67, 0x1a, 0x91, 0x23, 0x46, 0xf7, 0x4e, 0xfa, 0x7b, 0x63, - 0x12, 0x91, 0x9e, 0x1f, 0xf0, 0x88, 0x23, 0xa4, 0xdc, 0xbd, 0xd8, 0xdd, 0x3b, 0xe9, 0x5b, 0x4f, - 0xa1, 0x88, 0xf9, 0x1c, 0xb5, 0xa0, 0x78, 0x4c, 0x17, 0x6d, 0x63, 0xc7, 0xe8, 0xd6, 0xb1, 0x78, - 0x44, 0x77, 0xa0, 0x3a, 0x21, 0xae, 0xc3, 0x1c, 0x1a, 0xb6, 0xd7, 0x76, 0x8a, 0x5d, 0xb3, 0xdf, - 0xe9, 0xbd, 0xc9, 0xef, 0x3d, 0x10, 0x98, 0x05, 0x4e, 0xb0, 0x16, 0x86, 0xb2, 0xb2, 0x21, 0x04, - 0xeb, 0x1e, 0x71, 0xa9, 0x14, 0xad, 0x61, 0xf9, 0x8c, 0x6e, 0x43, 0x65, 0xc4, 0xd9, 0xcc, 0xf5, - 0x4e, 0x15, 0x3d, 0x90, 0x10, 0x1c, 0x43, 0xad, 0x97, 0x50, 0x56, 0x26, 0x74, 0x15, 0x6a, 0x3f, - 0xcf, 0x08, 0x73, 0x26, 0x0e, 0x0d, 0x74, 0xb6, 0xa9, 0x01, 0xf5, 0xa0, 0x34, 0xa2, 0x8c, 0xc5, - 0xda, 0xed, 0x95, 0xda, 0x94, 0x31, 0xac, 0x60, 0x96, 0x0d, 0xeb, 0xe2, 0x15, 0xdd, 0x84, 0x56, - 0xe4, 0xb8, 0x34, 0x8c, 0x88, 0xeb, 0xdb, 0xae, 0x33, 0x0a, 0x78, 0x28, 0xc5, 0x8b, 0xb8, 0x99, - 0xd8, 0x1f, 0x4b, 0x33, 0xda, 0x84, 0xd2, 0x09, 0x61, 0x33, 0xda, 0x5e, 0x93, 0xc1, 0xd5, 0x0b, - 0xda, 0x82, 0x32, 0x23, 0x47, 0x94, 0x85, 0xed, 0xe2, 0x4e, 0xb1, 0x5b, 0xc3, 0xfa, 0xcd, 0xfa, - 0xc3, 0x80, 0x2a, 0xe6, 0x73, 0x4c, 0xbc, 0x29, 0x45, 0xbb, 0xd0, 0x0a, 0x23, 0x12, 0x44, 0xf6, - 0x31, 0x5d, 0xd8, 0x23, 0xc6, 0x43, 0x3a, 0x56, 0x4b, 0x18, 0x16, 0x70, 0x43, 0x7a, 0x1e, 0xd2, - 0xc5, 0x81, 0xb4, 0xa3, 0x1b, 0xd0, 0x48, 0xb1, 0xdc, 0xa7, 0x9e, 0x8a, 0x37, 0x2c, 0xe0, 0x7a, - 0x8c, 0x7c, 0xea, 0x53, 0x0f, 0x59, 0x50, 0xa7, 0xde, 0x38, 0x45, 0x15, 0x25, 0xca, 0xc0, 0x40, - 0xbd, 0x71, 0x8c, 0xb9, 0x01, 0x8d, 0x18, 0xa3, 0xa3, 0xae, 0x6b, 0x54, 0x5d, 0xa1, 0x54, 0xcc, - 0x81, 0x09, 0xb5, 0x24, 0xe6, 0xa0, 0x06, 0x15, 0x4d, 0xb2, 0x7e, 0x84, 0x32, 0xe6, 0xf3, 0x17, - 0x34, 0x42, 0x57, 0xa0, 0x1a, 0xf0, 0xb9, 0x30, 0x8a, 0xfa, 0x14, 0xbb, 0x75, 0x5c, 0x09, 0xf8, - 0xfc, 0x21, 0x5d, 0x84, 0xe8, 0x2e, 0x80, 0x70, 0x05, 0x62, 0xa5, 0x71, 0xfd, 0xaf, 0xae, 0xaa, - 0x7f, 0x5c, 0x0e, 0x5c, 0x0b, 0xf4, 0x53, 0x68, 0xfd, 0xb6, 0x06, 0xa6, 0xde, 0x73, 0x59, 0xa9, - 0x6b, 0x60, 0xca, 0x7e, 0x5a, 0xd8, 0x99, 0x06, 0x02, 0x65, 0x7a, 0x22, 0xda, 0xe8, 0x0e, 0x6c, - 0xa9, 0x54, 0x93, 0xbd, 0x8f, 0x97, 0x16, 0x97, 0x69, 0x53, 0xfa, 0x9f, 0xc7, 0x6e, 0x5d, 0xd6, - 0x3e, 0x6c, 0x2e, 0xf3, 0x32, 0x65, 0x2b, 0x60, 0x94, 0x67, 0xc9, 0xf2, 0xf5, 0x61, 0x53, 0x54, - 0xe2, 0x8d, 0x48, 0x71, 0x11, 0x11, 0xf5, 0xc6, 0xcb, 0x71, 0x7a, 0x80, 0xf2, 0x1c, 0x19, 0xa5, - 0xa4, 0x19, 0xad, 0x2c, 0x43, 0xc4, 0x18, 0x5c, 0x80, 0xe6, 0x52, 0x5e, 0x83, 0x26, 0x6c, 0xe4, - 0x24, 0xac, 0xd7, 0xd0, 0x38, 0x8c, 0x9b, 0x51, 0x95, 0xe9, 0x76, 0x5c, 0x85, 0xb7, 0x34, 0xaf, - 0x5a, 0xeb, 0xe1, 0x52, 0x07, 0x7f, 0xac, 0xd6, 0xf3, 0x06, 0x67, 0x4d, 0x72, 0x44, 0xde, 0x4b, - 0x0c, 0xeb, 0x2f, 0x03, 0xe0, 0xa5, 0xe8, 0x73, 0x15, 0xb6, 0x07, 0xaa, 0x4c, 0xb6, 0xec, 0xfd, - 0xe5, 0x4e, 0x56, 0x3d, 0x2e, 0xe1, 0xba, 0x18, 0x49, 0xdf, 0x2b, 0x7c, 0xae, 0x9b, 0x1b, 0x29, - 0x5a, 0x16, 0x7b, 0x17, 0x44, 0x71, 0xf2, 0xca, 0x71, 0x4f, 0x8b, 0x2e, 0xce, 0xea, 0xea, 0xbe, - 0xce, 0xa8, 0x66, 0xfb, 0x3a, 0xd1, 0x1c, 0x6c, 0x80, 0x99, 0x89, 0x2f, 0xda, 0x3c, 0xa1, 0x59, - 0xff, 0x98, 0x50, 0xc3, 0x7c, 0xfe, 0xc0, 0x61, 0x11, 0x0d, 0xd0, 0x5d, 0x28, 0x8d, 0x7e, 0x22, - 0x8e, 0x27, 0x17, 0x63, 0xf6, 0xaf, 0xbf, 0xa5, 0x7f, 0x15, 0xba, 0x77, 0x20, 0xa0, 0xc3, 0x02, - 0x56, 0x1c, 0xf4, 0x1d, 0x80, 0xe3, 0x45, 0x34, 0x60, 0x94, 0x9c, 0xa8, 0xf1, 0x60, 0xf6, 0xbb, - 0xa7, 0x2b, 0x7c, 0x9b, 0xe0, 0x87, 0x05, 0x9c, 0x61, 0xa3, 0x6f, 0xa0, 0x36, 0xe2, 0xde, 0xd8, - 0x89, 0x1c, 0xae, 0x9a, 0xd3, 0xec, 0xbf, 0x7f, 0x46, 0x32, 0x31, 0x7c, 0x58, 0xc0, 0x29, 0x17, - 0x6d, 0xc2, 0x7a, 0xe8, 0x78, 0xc7, 0xed, 0xd6, 0x8e, 0xd1, 0xad, 0x0e, 0x0b, 0x58, 0xbe, 0xa1, - 0x2e, 0x34, 0x7d, 0x12, 0x86, 0x36, 0x61, 0xcc, 0x9e, 0x48, 0x7e, 0xfb, 0x82, 0x06, 0x6c, 0x08, - 0xc7, 0x3e, 0x63, 0xba, 0x22, 0xbb, 0xd0, 0x3a, 0x62, 0x7c, 0x74, 0x9c, 0x85, 0x22, 0x0d, 0x6d, - 0x48, 0x4f, 0x8a, 0xfd, 0x04, 0x36, 0xf5, 0x74, 0xb0, 0x03, 0x3a, 0xa5, 0xaf, 0x63, 0xfc, 0xba, - 0xde, 0xeb, 0x0b, 0x6a, 0x56, 0x60, 0xe1, 0xd3, 0x94, 0x0f, 0x41, 0x18, 0xed, 0x90, 0xb8, 0x3e, - 0xa3, 0x31, 0xbe, 0xb1, 0x63, 0x74, 0x8d, 0x61, 0x01, 0x37, 0x03, 0x3e, 0x7f, 0x21, 0x3d, 0x1a, - 0xfd, 0x39, 0xb4, 0x33, 0x63, 0x21, 0x1f, 0x44, 0x9c, 0xad, 0xda, 0xb0, 0x80, 0x2f, 0xa5, 0x53, - 0x22, 0x1b, 0xe8, 0x00, 0xb6, 0xd5, 0xc7, 0x24, 0x73, 0x26, 0x73, 0xfc, 0xb2, 0x4e, 0xb2, 0xa3, - 0x60, 0xc9, 0xf1, 0xcc, 0x8a, 0x3c, 0x87, 0x8b, 0x5a, 0x44, 0x8e, 0xb9, 0x98, 0x5a, 0x91, 0xfb, - 0x73, 0xed, 0x94, 0x0f, 0x99, 0x40, 0x8b, 0x02, 0x8c, 0xd2, 0x57, 0x2d, 0xf9, 0x0a, 0xb6, 0xd2, - 0x83, 0x98, 0x53, 0xad, 0x4a, 0x55, 0x6b, 0x95, 0x6a, 0x7e, 0x0c, 0x88, 0x61, 0x17, 0xe5, 0x2c, - 0x5a, 0xbb, 0x07, 0x48, 0x9d, 0x8d, 0xdc, 0x42, 0x6b, 0xf1, 0x39, 0x95, 0xbe, 0xec, 0xf2, 0x9e, - 0x24, 0xf8, 0x6c, 0x1e, 0x4d, 0x99, 0xc7, 0xff, 0x57, 0xe5, 0x91, 0xce, 0x84, 0x54, 0x2f, 0x13, - 0xff, 0x2b, 0xf8, 0x9f, 0xfc, 0xcc, 0xda, 0xbe, 0x28, 0x36, 0x9f, 0xdb, 0x7c, 0x32, 0x09, 0x69, - 0x14, 0x0b, 0xc3, 0x8e, 0xd1, 0x2d, 0x0d, 0x0b, 0xf8, 0xb2, 0x04, 0x3d, 0xa3, 0x01, 0xe6, 0xf3, - 0xa7, 0x12, 0xa1, 0xf9, 0x5f, 0x42, 0x27, 0xcf, 0x67, 0x8e, 0xeb, 0x24, 0x74, 0x53, 0xd3, 0xb7, - 0x32, 0xf4, 0x47, 0x02, 0xa0, 0xd9, 0x03, 0xd8, 0x4e, 0xd9, 0x7a, 0xdb, 0x72, 0x02, 0x75, 0x2d, - 0x70, 0x25, 0x16, 0x50, 0x9b, 0x95, 0xd5, 0xf8, 0x0c, 0x2e, 0x87, 0x51, 0xe0, 0xf8, 0x7a, 0xc6, - 0x44, 0x01, 0xf1, 0xc2, 0x09, 0x0f, 0x5c, 0x1a, 0xb4, 0x37, 0xf4, 0x21, 0xb8, 0x24, 0x01, 0xb2, - 0x12, 0x87, 0xa9, 0x5b, 0x30, 0x89, 0xef, 0xb3, 0x85, 0x2d, 0x2f, 0x02, 0x39, 0xe6, 0xc5, 0xb8, - 0x53, 0x25, 0xe0, 0x91, 0xf0, 0x67, 0x98, 0x9d, 0x7b, 0x50, 0x92, 0x83, 0x05, 0x7d, 0x0a, 0x15, - 0x95, 0xa9, 0xfa, 0xd6, 0x9a, 0xfd, 0xed, 0x53, 0x27, 0x00, 0x8e, 0xd1, 0x9d, 0xaf, 0x01, 0xd2, - 0xc1, 0xf2, 0xdf, 0x65, 0xfe, 0x34, 0xa0, 0x96, 0x4c, 0x15, 0x34, 0x84, 0x96, 0x1f, 0xd0, 0xb1, - 0x33, 0x22, 0x51, 0xd2, 0x1a, 0x6a, 0x4a, 0x9e, 0xa1, 0xd7, 0x4c, 0x68, 0x49, 0x5b, 0x98, 0x51, - 0x30, 0x4b, 0x44, 0xd6, 0xce, 0x23, 0x02, 0x82, 0xa1, 0xf9, 0xf7, 0xa0, 0x3e, 0x21, 0x2c, 0x4c, - 0x04, 0x8a, 0xe7, 0x11, 0x30, 0x25, 0x45, 0xbd, 0x0c, 0xaa, 0x50, 0x56, 0x5c, 0xeb, 0xef, 0x12, - 0x54, 0x1f, 0xcf, 0x22, 0x22, 0x97, 0xb8, 0x0f, 0x55, 0xd1, 0x9e, 0xa2, 0x1d, 0xf4, 0xd2, 0xde, - 0x5b, 0x25, 0x1a, 0xe3, 0x7b, 0x2f, 0x68, 0x24, 0x6e, 0x8f, 0xc3, 0x02, 0xae, 0x84, 0xea, 0x11, - 0xfd, 0x00, 0x68, 0x4c, 0x19, 0x15, 0x25, 0x0a, 0xb8, 0xab, 0xdb, 0x4e, 0x2f, 0xf1, 0xa3, 0x53, - 0xc5, 0xee, 0x4b, 0xda, 0x83, 0x80, 0xbb, 0xaa, 0x0d, 0xc5, 0x89, 0x1a, 0x2f, 0xd9, 0x96, 0xe5, - 0xd5, 0xa8, 0xd3, 0x05, 0x38, 0xaf, 0xbc, 0xba, 0x9c, 0xe7, 0xe5, 0xf5, 0x85, 0xfd, 0x10, 0x9a, - 0x59, 0xf9, 0x80, 0xcf, 0xe5, 0xec, 0x36, 0xfb, 0xbb, 0xe7, 0xd4, 0xc6, 0x7c, 0x2e, 0x3e, 0x21, - 0xe3, 0xac, 0xa1, 0xf3, 0x8b, 0x01, 0x15, 0x5d, 0xaa, 0xb3, 0x2f, 0x76, 0x37, 0xa1, 0xb5, 0x3c, - 0xa7, 0xf5, 0x4d, 0xbb, 0xb9, 0x34, 0x98, 0x57, 0x5e, 0xda, 0x8b, 0x67, 0x5c, 0xda, 0xd7, 0x33, - 0x97, 0xf6, 0xce, 0xaf, 0x06, 0xb4, 0x96, 0xcb, 0xfe, 0x4e, 0x33, 0xdc, 0x07, 0x10, 0x99, 0xa8, - 0x79, 0xaa, 0xb7, 0xe9, 0x1c, 0x03, 0x1d, 0xd7, 0x04, 0x4b, 0x3e, 0x76, 0x6e, 0x65, 0x53, 0xd4, - 0xdb, 0x74, 0x56, 0x8a, 0x9d, 0x26, 0x6c, 0xe4, 0xf6, 0x64, 0x00, 0x50, 0x75, 0xf5, 0x6e, 0x59, - 0xbf, 0x1b, 0x70, 0x11, 0x53, 0x32, 0x7e, 0xcc, 0xc7, 0xce, 0x64, 0xf1, 0x7d, 0xe0, 0x44, 0x14, - 0xcf, 0x18, 0x7d, 0xa7, 0x0b, 0xbf, 0x0e, 0x75, 0xe2, 0xfb, 0xc9, 0x2d, 0x2b, 0xb9, 0x5e, 0x9b, - 0xca, 0x2a, 0xa7, 0x25, 0xfa, 0x00, 0x5a, 0x8e, 0x37, 0x0a, 0xa8, 0x4b, 0xbd, 0xc8, 0x26, 0x2e, - 0x9f, 0x79, 0x91, 0xdc, 0x9f, 0xa2, 0xf8, 0xf4, 0x27, 0x9e, 0x7d, 0xe9, 0x18, 0x94, 0x61, 0x3d, - 0x98, 0x31, 0x3a, 0x20, 0xb0, 0x35, 0xe2, 0xee, 0x8a, 0x1a, 0x0e, 0x6a, 0xf7, 0x49, 0x44, 0x9e, - 0x89, 0xff, 0xdc, 0x67, 0xc6, 0xab, 0x2f, 0x34, 0x60, 0xca, 0x19, 0xf1, 0xa6, 0x3d, 0x1e, 0x4c, - 0xf7, 0xa6, 0xd4, 0x93, 0x7f, 0xc1, 0x7b, 0xca, 0x45, 0x7c, 0x27, 0xcc, 0xfe, 0x27, 0xdf, 0x8d, - 0x9f, 0x8f, 0xca, 0x12, 0x76, 0xeb, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd8, 0xbb, 0x74, 0x4d, - 0x4d, 0x0f, 0x00, 0x00, + // 1430 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xdd, 0x6e, 0x1b, 0x45, + 0x14, 0xf6, 0xc6, 0x89, 0x7f, 0xce, 0x3a, 0xb6, 0x3b, 0x4d, 0x53, 0xd7, 0x34, 0x34, 0xda, 0xa2, + 0xe2, 0x06, 0x70, 0xc0, 0xad, 0xca, 0x4f, 0x11, 0x6a, 0x9c, 0xd2, 0x1a, 0xfa, 0x3f, 0x8d, 0x8a, + 0x54, 0x09, 0x2d, 0x13, 0x7b, 0x6c, 0x56, 0x99, 0xdd, 0x59, 0x76, 0xd7, 0x71, 0x2d, 0xf1, 0x1c, + 0xdc, 0xc3, 0x25, 0xaf, 0xc0, 0x1d, 0x2f, 0x01, 0x8f, 0xc1, 0x03, 0x70, 0x81, 0xe6, 0x67, 0xff, + 0x5c, 0x37, 0x89, 0x50, 0xef, 0x76, 0xcf, 0xf9, 0xbe, 0xef, 0x9c, 0x39, 0x73, 0xe6, 0xec, 0x2c, + 0x6c, 0x4d, 0x38, 0x9f, 0x30, 0xba, 0x7b, 0xe8, 0x4c, 0x22, 0x72, 0xc8, 0xe8, 0xee, 0x71, 0x6f, + 0x77, 0x44, 0x22, 0xd2, 0xf5, 0x03, 0x1e, 0x71, 0x84, 0x94, 0xbb, 0x1b, 0xbb, 0xbb, 0xc7, 0x3d, + 0xeb, 0x09, 0x14, 0x31, 0x9f, 0xa1, 0x26, 0x14, 0x8f, 0xe8, 0xbc, 0x65, 0x6c, 0x1b, 0x9d, 0x1a, + 0x16, 0x8f, 0xe8, 0x16, 0x54, 0xc6, 0xc4, 0x75, 0x98, 0x43, 0xc3, 0xd6, 0xca, 0x76, 0xb1, 0x63, + 0xf6, 0xda, 0xdd, 0xd7, 0xf9, 0xdd, 0x7b, 0x02, 0x33, 0xc7, 0x09, 0xd6, 0xc2, 0x50, 0x52, 0x36, + 0x84, 0x60, 0xd5, 0x23, 0x2e, 0x95, 0xa2, 0x55, 0x2c, 0x9f, 0xd1, 0x4d, 0x28, 0x0f, 0x39, 0x9b, + 0xba, 0xde, 0x89, 0xa2, 0xfb, 0x12, 0x82, 0x63, 0xa8, 0xf5, 0x02, 0x4a, 0xca, 0x84, 0x2e, 0x43, + 0xf5, 0xa7, 0x29, 0x61, 0xce, 0xd8, 0xa1, 0x81, 0xce, 0x36, 0x35, 0xa0, 0x2e, 0xac, 0x0d, 0x29, + 0x63, 0xb1, 0x76, 0x6b, 0xa9, 0x36, 0x65, 0x0c, 0x2b, 0x98, 0x65, 0xc3, 0xaa, 0x78, 0x45, 0xd7, + 0xa1, 0x19, 0x39, 0x2e, 0x0d, 0x23, 0xe2, 0xfa, 0xb6, 0xeb, 0x0c, 0x03, 0x1e, 0x4a, 0xf1, 0x22, + 0x6e, 0x24, 0xf6, 0x47, 0xd2, 0x8c, 0x36, 0x60, 0xed, 0x98, 0xb0, 0x29, 0x6d, 0xad, 0xc8, 0xe0, + 0xea, 0x05, 0x6d, 0x42, 0x89, 0x91, 0x43, 0xca, 0xc2, 0x56, 0x71, 0xbb, 0xd8, 0xa9, 0x62, 0xfd, + 0x66, 0xfd, 0x69, 0x40, 0x05, 0xf3, 0x19, 0x26, 0xde, 0x84, 0xa2, 0x1d, 0x68, 0x86, 0x11, 0x09, + 0x22, 0xfb, 0x88, 0xce, 0xed, 0x21, 0xe3, 0x21, 0x1d, 0xa9, 0x25, 0x0c, 0x0a, 0xb8, 0x2e, 0x3d, + 0x0f, 0xe8, 0x7c, 0x5f, 0xda, 0xd1, 0x35, 0xa8, 0xa7, 0x58, 0xee, 0x53, 0x4f, 0xc5, 0x1b, 0x14, + 0x70, 0x2d, 0x46, 0x3e, 0xf1, 0xa9, 0x87, 0x2c, 0xa8, 0x51, 0x6f, 0x94, 0xa2, 0x8a, 0x12, 0x65, + 0x60, 0xa0, 0xde, 0x28, 0xc6, 0x5c, 0x83, 0x7a, 0x8c, 0xd1, 0x51, 0x57, 0x35, 0xaa, 0xa6, 0x50, + 0x2a, 0x66, 0xdf, 0x84, 0x6a, 0x12, 0xb3, 0x5f, 0x85, 0xb2, 0x26, 0x59, 0x3f, 0x40, 0x09, 0xf3, + 0xd9, 0x73, 0x1a, 0xa1, 0x4b, 0x50, 0x09, 0xf8, 0x4c, 0x18, 0x45, 0x7d, 0x8a, 0x9d, 0x1a, 0x2e, + 0x07, 0x7c, 0xf6, 0x80, 0xce, 0x43, 0x74, 0x1b, 0x40, 0xb8, 0x02, 0xb1, 0xd2, 0xb8, 0xfe, 0x97, + 0x97, 0xd5, 0x3f, 0x2e, 0x07, 0xae, 0x06, 0xfa, 0x29, 0xb4, 0x7e, 0x5b, 0x01, 0x53, 0xef, 0xb9, + 0xac, 0xd4, 0x15, 0x30, 0x65, 0x3f, 0xcd, 0xed, 0x4c, 0x03, 0x81, 0x32, 0x3d, 0x16, 0x6d, 0x74, + 0x0b, 0x36, 0x55, 0xaa, 0xc9, 0xde, 0xc7, 0x4b, 0x8b, 0xcb, 0xb4, 0x21, 0xfd, 0xcf, 0x62, 0xb7, + 0x2e, 0x6b, 0x0f, 0x36, 0x16, 0x79, 0x99, 0xb2, 0x15, 0x30, 0xca, 0xb3, 0x64, 0xf9, 0x7a, 0xb0, + 0x21, 0x2a, 0xf1, 0x5a, 0xa4, 0xb8, 0x88, 0x88, 0x7a, 0xa3, 0xc5, 0x38, 0x5d, 0x40, 0x79, 0x8e, + 0x8c, 0xb2, 0xa6, 0x19, 0xcd, 0x2c, 0x43, 0xc4, 0xe8, 0x9f, 0x83, 0xc6, 0x42, 0x5e, 0xfd, 0x06, + 0xac, 0xe7, 0x24, 0xac, 0x57, 0x50, 0x3f, 0x88, 0x9b, 0x51, 0x95, 0xe9, 0x66, 0x5c, 0x85, 0x37, + 0x34, 0xaf, 0x5a, 0xeb, 0xc1, 0x42, 0x07, 0x7f, 0xac, 0xd6, 0xf3, 0x1a, 0x67, 0x45, 0x72, 0x44, + 0xde, 0x0b, 0x0c, 0xeb, 0x6f, 0x03, 0xe0, 0x85, 0xe8, 0x73, 0x15, 0xb6, 0x0b, 0xaa, 0x4c, 0xb6, + 0xec, 0xfd, 0xc5, 0x4e, 0x56, 0x3d, 0x2e, 0xe1, 0xba, 0x18, 0x49, 0xdf, 0x2b, 0x7c, 0xae, 0x9b, + 0xeb, 0x29, 0x5a, 0x16, 0x7b, 0x07, 0x44, 0x71, 0xf2, 0xca, 0x71, 0x4f, 0x8b, 0x2e, 0xce, 0xea, + 0xea, 0xbe, 0xce, 0xa8, 0x66, 0xfb, 0x3a, 0xd1, 0xec, 0xaf, 0x83, 0x99, 0x89, 0x2f, 0xda, 0x3c, + 0xa1, 0x59, 0xff, 0x9a, 0x50, 0xc5, 0x7c, 0x76, 0xcf, 0x61, 0x11, 0x0d, 0xd0, 0x6d, 0x58, 0x1b, + 0xfe, 0x48, 0x1c, 0x4f, 0x2e, 0xc6, 0xec, 0x5d, 0x7d, 0x43, 0xff, 0x2a, 0x74, 0x77, 0x5f, 0x40, + 0x07, 0x05, 0xac, 0x38, 0xe8, 0x5b, 0x00, 0xc7, 0x8b, 0x68, 0xc0, 0x28, 0x39, 0x56, 0xe3, 0xc1, + 0xec, 0x75, 0x4e, 0x56, 0xf8, 0x26, 0xc1, 0x0f, 0x0a, 0x38, 0xc3, 0x46, 0xf7, 0xa1, 0x3a, 0xe4, + 0xde, 0xc8, 0x89, 0x1c, 0xae, 0x9a, 0xd3, 0xec, 0xbd, 0x7f, 0x4a, 0x32, 0x31, 0x7c, 0x50, 0xc0, + 0x29, 0x17, 0x6d, 0xc0, 0x6a, 0xe8, 0x78, 0x47, 0xad, 0xe6, 0xb6, 0xd1, 0xa9, 0x0c, 0x0a, 0x58, + 0xbe, 0xa1, 0x0e, 0x34, 0x7c, 0x12, 0x86, 0x36, 0x61, 0xcc, 0x1e, 0x4b, 0x7e, 0xeb, 0x9c, 0x06, + 0xac, 0x0b, 0xc7, 0x1e, 0x63, 0xba, 0x22, 0x3b, 0xd0, 0x3c, 0x64, 0x7c, 0x78, 0x94, 0x85, 0x22, + 0x0d, 0xad, 0x4b, 0x4f, 0x8a, 0xfd, 0x04, 0x36, 0xf4, 0x74, 0xb0, 0x03, 0x3a, 0xa1, 0xaf, 0x62, + 0xfc, 0xaa, 0xde, 0xeb, 0x73, 0x6a, 0x56, 0x60, 0xe1, 0xd3, 0x94, 0x0f, 0x41, 0x18, 0xed, 0x90, + 0xb8, 0x3e, 0xa3, 0x31, 0xbe, 0xbe, 0x6d, 0x74, 0x8c, 0x41, 0x01, 0x37, 0x02, 0x3e, 0x7b, 0x2e, + 0x3d, 0x1a, 0xfd, 0x39, 0xb4, 0x32, 0x63, 0x21, 0x1f, 0x44, 0x9c, 0xad, 0xea, 0xa0, 0x80, 0x2f, + 0xa4, 0x53, 0x22, 0x1b, 0x68, 0x1f, 0xb6, 0xd4, 0xc7, 0x24, 0x73, 0x26, 0x73, 0xfc, 0x92, 0x4e, + 0xb2, 0xad, 0x60, 0xc9, 0xf1, 0xcc, 0x8a, 0x3c, 0x83, 0xf3, 0x5a, 0x44, 0x8e, 0xb9, 0x98, 0x5a, + 0x96, 0xfb, 0x73, 0xe5, 0x84, 0x0f, 0x99, 0x40, 0x8b, 0x02, 0x0c, 0xd3, 0x57, 0x2d, 0xf9, 0x12, + 0x36, 0xd3, 0x83, 0x98, 0x53, 0xad, 0x48, 0x55, 0x6b, 0x99, 0x6a, 0x7e, 0x0c, 0x88, 0x61, 0x17, + 0xe5, 0x2c, 0x5a, 0xbb, 0x0b, 0x48, 0x9d, 0x8d, 0xdc, 0x42, 0xab, 0xf1, 0x39, 0x95, 0xbe, 0xec, + 0xf2, 0x1e, 0x27, 0xf8, 0x6c, 0x1e, 0x0d, 0x99, 0xc7, 0xbb, 0xcb, 0xf2, 0x48, 0x67, 0x42, 0xaa, + 0x97, 0x89, 0xff, 0x15, 0xbc, 0x23, 0x3f, 0xb3, 0xb6, 0x2f, 0x8a, 0xcd, 0x67, 0x36, 0x1f, 0x8f, + 0x43, 0x1a, 0xc5, 0xc2, 0xb0, 0x6d, 0x74, 0xd6, 0x06, 0x05, 0x7c, 0x51, 0x82, 0x9e, 0xd2, 0x00, + 0xf3, 0xd9, 0x13, 0x89, 0xd0, 0xfc, 0x2f, 0xa1, 0x9d, 0xe7, 0x33, 0xc7, 0x75, 0x12, 0xba, 0xa9, + 0xe9, 0x9b, 0x19, 0xfa, 0x43, 0x01, 0xd0, 0xec, 0x3e, 0x6c, 0xa5, 0x6c, 0xbd, 0x6d, 0x39, 0x81, + 0x9a, 0x16, 0xb8, 0x14, 0x0b, 0xa8, 0xcd, 0xca, 0x6a, 0x7c, 0x06, 0x17, 0xc3, 0x28, 0x70, 0x7c, + 0x3d, 0x63, 0xa2, 0x80, 0x78, 0xe1, 0x98, 0x07, 0x2e, 0x0d, 0x5a, 0xeb, 0xfa, 0x10, 0x5c, 0x90, + 0x00, 0x59, 0x89, 0x83, 0xd4, 0x2d, 0x98, 0xc4, 0xf7, 0xd9, 0xdc, 0x96, 0x17, 0x81, 0x1c, 0xf3, + 0x7c, 0xdc, 0xa9, 0x12, 0xf0, 0x50, 0xf8, 0x33, 0xcc, 0xf6, 0x1d, 0x58, 0x93, 0x83, 0x05, 0x7d, + 0x0a, 0x65, 0x95, 0xa9, 0xfa, 0xd6, 0x9a, 0xbd, 0xad, 0x13, 0x27, 0x00, 0x8e, 0xd1, 0xed, 0xaf, + 0x01, 0xd2, 0xc1, 0xf2, 0xff, 0x65, 0xfe, 0x32, 0xa0, 0x9a, 0x4c, 0x15, 0x34, 0x80, 0xa6, 0x1f, + 0xd0, 0x91, 0x33, 0x24, 0x51, 0xd2, 0x1a, 0x6a, 0x4a, 0x9e, 0xa2, 0xd7, 0x48, 0x68, 0x49, 0x5b, + 0x98, 0x51, 0x30, 0x4d, 0x44, 0x56, 0xce, 0x22, 0x02, 0x82, 0xa1, 0xf9, 0x77, 0xa0, 0x36, 0x26, + 0x2c, 0x4c, 0x04, 0x8a, 0x67, 0x11, 0x30, 0x25, 0x45, 0xbd, 0xf4, 0x2b, 0x50, 0x52, 0x5c, 0xeb, + 0x9f, 0x35, 0xa8, 0x3c, 0x9a, 0x46, 0x44, 0x2e, 0x71, 0x0f, 0x2a, 0xa2, 0x3d, 0x45, 0x3b, 0xe8, + 0xa5, 0xbd, 0xb7, 0x4c, 0x34, 0xc6, 0x77, 0x9f, 0xd3, 0x48, 0xdc, 0x1e, 0x07, 0x05, 0x5c, 0x0e, + 0xd5, 0x23, 0xfa, 0x1e, 0xd0, 0x88, 0x32, 0x2a, 0x4a, 0x14, 0x70, 0x57, 0xb7, 0x9d, 0x5e, 0xe2, + 0x47, 0x27, 0x8a, 0xdd, 0x95, 0xb4, 0x7b, 0x01, 0x77, 0x55, 0x1b, 0x8a, 0x13, 0x35, 0x5a, 0xb0, + 0x2d, 0xca, 0xab, 0x51, 0xa7, 0x0b, 0x70, 0x56, 0x79, 0x75, 0x39, 0xcf, 0xcb, 0xeb, 0x0b, 0xfb, + 0x01, 0x34, 0xb2, 0xf2, 0x01, 0x9f, 0xc9, 0xd9, 0x6d, 0xf6, 0x76, 0xce, 0xa8, 0x8d, 0xf9, 0x4c, + 0x7c, 0x42, 0x46, 0x59, 0x43, 0xfb, 0x17, 0x03, 0xca, 0xba, 0x54, 0xa7, 0x5f, 0xec, 0xae, 0x43, + 0x73, 0x71, 0x4e, 0xeb, 0x9b, 0x76, 0x63, 0x61, 0x30, 0x2f, 0xbd, 0xb4, 0x17, 0x4f, 0xb9, 0xb4, + 0xaf, 0x66, 0x2e, 0xed, 0xed, 0x5f, 0x0d, 0x68, 0x2e, 0x96, 0xfd, 0xad, 0x66, 0xb8, 0x07, 0x20, + 0x32, 0x51, 0xf3, 0x54, 0x6f, 0xd3, 0x19, 0x06, 0x3a, 0xae, 0x0a, 0x96, 0x7c, 0x6c, 0xdf, 0xc8, + 0xa6, 0xa8, 0xb7, 0xe9, 0xb4, 0x14, 0xdb, 0x0d, 0x58, 0xcf, 0xed, 0x49, 0x1f, 0xa0, 0xe2, 0xea, + 0xdd, 0xb2, 0xfe, 0x30, 0xe0, 0x3c, 0xa6, 0x64, 0xf4, 0x88, 0x8f, 0x9c, 0xf1, 0xfc, 0xbb, 0xc0, + 0x89, 0x28, 0x9e, 0x32, 0xfa, 0x56, 0x17, 0x7e, 0x15, 0x6a, 0xc4, 0xf7, 0x93, 0x5b, 0x56, 0x72, + 0xbd, 0x36, 0x95, 0x55, 0x4e, 0x4b, 0xf4, 0x01, 0x34, 0x1d, 0x6f, 0x18, 0x50, 0x97, 0x7a, 0x91, + 0x4d, 0x5c, 0x3e, 0xf5, 0x22, 0xb9, 0x3f, 0x45, 0xf1, 0xe9, 0x4f, 0x3c, 0x7b, 0xd2, 0xd1, 0x2f, + 0xc1, 0x6a, 0x30, 0x65, 0xb4, 0xff, 0x33, 0x6c, 0x0e, 0xb9, 0xbb, 0xa4, 0x86, 0xfd, 0xea, 0x5d, + 0x12, 0x91, 0xa7, 0xe2, 0x3f, 0xf7, 0xa9, 0xf1, 0xf2, 0x0b, 0x0d, 0x98, 0x70, 0x46, 0xbc, 0x49, + 0x97, 0x07, 0x93, 0xdd, 0x09, 0xf5, 0xe4, 0x5f, 0xf0, 0xae, 0x72, 0x11, 0xdf, 0x09, 0xb3, 0xff, + 0xc9, 0xb7, 0xe3, 0xe7, 0xdf, 0x57, 0x5a, 0xf7, 0x15, 0x79, 0x9f, 0xf1, 0xe9, 0xa8, 0xdb, 0x8f, + 0x63, 0xbc, 0xe8, 0x1d, 0x96, 0xa4, 0xc2, 0x8d, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x32, 0x40, + 0x30, 0x5e, 0x68, 0x0f, 0x00, 0x00, } diff --git a/vendor/google.golang.org/genproto/googleapis/cloud/language/v1beta2/language_service.pb.go b/vendor/google.golang.org/genproto/googleapis/cloud/language/v1beta2/language_service.pb.go index d82a8403..50a52693 100644 --- a/vendor/google.golang.org/genproto/googleapis/cloud/language/v1beta2/language_service.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/cloud/language/v1beta2/language_service.pb.go @@ -17,6 +17,7 @@ It has these top-level messages: DependencyEdge EntityMention TextSpan + ClassificationCategory AnalyzeSentimentRequest AnalyzeSentimentResponse AnalyzeEntitySentimentRequest @@ -25,6 +26,8 @@ It has these top-level messages: AnalyzeEntitiesResponse AnalyzeSyntaxRequest AnalyzeSyntaxResponse + ClassifyTextRequest + ClassifyTextResponse AnnotateTextRequest AnnotateTextResponse */ @@ -1069,7 +1072,7 @@ type Document struct { // The language of the document (if not specified, the language is // automatically detected). Both ISO and BCP-47 language codes are // accepted.
- // [Language Support](https://cloud.google.com/natural-language/docs/languages) + // [Language Support](/natural-language/docs/languages) // lists currently supported languages for each API method. // If the language (either specified by the caller or automatically detected) // is not supported by the called API method, an `INVALID_ARGUMENT` error @@ -1595,6 +1598,34 @@ func (m *TextSpan) GetBeginOffset() int32 { return 0 } +// Represents a category returned from the text classifier. +type ClassificationCategory struct { + // The name of the category representing the document. + Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + // The classifier's confidence of the category. Number represents how certain + // the classifier is that this category represents the given text. + Confidence float32 `protobuf:"fixed32,2,opt,name=confidence" json:"confidence,omitempty"` +} + +func (m *ClassificationCategory) Reset() { *m = ClassificationCategory{} } +func (m *ClassificationCategory) String() string { return proto.CompactTextString(m) } +func (*ClassificationCategory) ProtoMessage() {} +func (*ClassificationCategory) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } + +func (m *ClassificationCategory) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *ClassificationCategory) GetConfidence() float32 { + if m != nil { + return m.Confidence + } + return 0 +} + // The sentiment analysis request message. type AnalyzeSentimentRequest struct { // Input document. @@ -1607,7 +1638,7 @@ type AnalyzeSentimentRequest struct { func (m *AnalyzeSentimentRequest) Reset() { *m = AnalyzeSentimentRequest{} } func (m *AnalyzeSentimentRequest) String() string { return proto.CompactTextString(m) } func (*AnalyzeSentimentRequest) ProtoMessage() {} -func (*AnalyzeSentimentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } +func (*AnalyzeSentimentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } func (m *AnalyzeSentimentRequest) GetDocument() *Document { if m != nil { @@ -1638,7 +1669,7 @@ type AnalyzeSentimentResponse struct { func (m *AnalyzeSentimentResponse) Reset() { *m = AnalyzeSentimentResponse{} } func (m *AnalyzeSentimentResponse) String() string { return proto.CompactTextString(m) } func (*AnalyzeSentimentResponse) ProtoMessage() {} -func (*AnalyzeSentimentResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } +func (*AnalyzeSentimentResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } func (m *AnalyzeSentimentResponse) GetDocumentSentiment() *Sentiment { if m != nil { @@ -1672,7 +1703,7 @@ type AnalyzeEntitySentimentRequest struct { func (m *AnalyzeEntitySentimentRequest) Reset() { *m = AnalyzeEntitySentimentRequest{} } func (m *AnalyzeEntitySentimentRequest) String() string { return proto.CompactTextString(m) } func (*AnalyzeEntitySentimentRequest) ProtoMessage() {} -func (*AnalyzeEntitySentimentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } +func (*AnalyzeEntitySentimentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } func (m *AnalyzeEntitySentimentRequest) GetDocument() *Document { if m != nil { @@ -1701,7 +1732,7 @@ type AnalyzeEntitySentimentResponse struct { func (m *AnalyzeEntitySentimentResponse) Reset() { *m = AnalyzeEntitySentimentResponse{} } func (m *AnalyzeEntitySentimentResponse) String() string { return proto.CompactTextString(m) } func (*AnalyzeEntitySentimentResponse) ProtoMessage() {} -func (*AnalyzeEntitySentimentResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } +func (*AnalyzeEntitySentimentResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } func (m *AnalyzeEntitySentimentResponse) GetEntities() []*Entity { if m != nil { @@ -1728,7 +1759,7 @@ type AnalyzeEntitiesRequest struct { func (m *AnalyzeEntitiesRequest) Reset() { *m = AnalyzeEntitiesRequest{} } func (m *AnalyzeEntitiesRequest) String() string { return proto.CompactTextString(m) } func (*AnalyzeEntitiesRequest) ProtoMessage() {} -func (*AnalyzeEntitiesRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } +func (*AnalyzeEntitiesRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} } func (m *AnalyzeEntitiesRequest) GetDocument() *Document { if m != nil { @@ -1757,7 +1788,7 @@ type AnalyzeEntitiesResponse struct { func (m *AnalyzeEntitiesResponse) Reset() { *m = AnalyzeEntitiesResponse{} } func (m *AnalyzeEntitiesResponse) String() string { return proto.CompactTextString(m) } func (*AnalyzeEntitiesResponse) ProtoMessage() {} -func (*AnalyzeEntitiesResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} } +func (*AnalyzeEntitiesResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } func (m *AnalyzeEntitiesResponse) GetEntities() []*Entity { if m != nil { @@ -1784,7 +1815,7 @@ type AnalyzeSyntaxRequest struct { func (m *AnalyzeSyntaxRequest) Reset() { *m = AnalyzeSyntaxRequest{} } func (m *AnalyzeSyntaxRequest) String() string { return proto.CompactTextString(m) } func (*AnalyzeSyntaxRequest) ProtoMessage() {} -func (*AnalyzeSyntaxRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } +func (*AnalyzeSyntaxRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } func (m *AnalyzeSyntaxRequest) GetDocument() *Document { if m != nil { @@ -1815,7 +1846,7 @@ type AnalyzeSyntaxResponse struct { func (m *AnalyzeSyntaxResponse) Reset() { *m = AnalyzeSyntaxResponse{} } func (m *AnalyzeSyntaxResponse) String() string { return proto.CompactTextString(m) } func (*AnalyzeSyntaxResponse) ProtoMessage() {} -func (*AnalyzeSyntaxResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } +func (*AnalyzeSyntaxResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } func (m *AnalyzeSyntaxResponse) GetSentences() []*Sentence { if m != nil { @@ -1838,6 +1869,42 @@ func (m *AnalyzeSyntaxResponse) GetLanguage() string { return "" } +// The document classification request message. +type ClassifyTextRequest struct { + // Input document. + Document *Document `protobuf:"bytes,1,opt,name=document" json:"document,omitempty"` +} + +func (m *ClassifyTextRequest) Reset() { *m = ClassifyTextRequest{} } +func (m *ClassifyTextRequest) String() string { return proto.CompactTextString(m) } +func (*ClassifyTextRequest) ProtoMessage() {} +func (*ClassifyTextRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } + +func (m *ClassifyTextRequest) GetDocument() *Document { + if m != nil { + return m.Document + } + return nil +} + +// The document classification response message. +type ClassifyTextResponse struct { + // Categories representing the input document. + Categories []*ClassificationCategory `protobuf:"bytes,1,rep,name=categories" json:"categories,omitempty"` +} + +func (m *ClassifyTextResponse) Reset() { *m = ClassifyTextResponse{} } +func (m *ClassifyTextResponse) String() string { return proto.CompactTextString(m) } +func (*ClassifyTextResponse) ProtoMessage() {} +func (*ClassifyTextResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } + +func (m *ClassifyTextResponse) GetCategories() []*ClassificationCategory { + if m != nil { + return m.Categories + } + return nil +} + // The request message for the text annotation API, which can perform multiple // analysis types (sentiment, entities, and syntax) in one call. type AnnotateTextRequest struct { @@ -1852,7 +1919,7 @@ type AnnotateTextRequest struct { func (m *AnnotateTextRequest) Reset() { *m = AnnotateTextRequest{} } func (m *AnnotateTextRequest) String() string { return proto.CompactTextString(m) } func (*AnnotateTextRequest) ProtoMessage() {} -func (*AnnotateTextRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } +func (*AnnotateTextRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} } func (m *AnnotateTextRequest) GetDocument() *Document { if m != nil { @@ -1886,13 +1953,15 @@ type AnnotateTextRequest_Features struct { ExtractDocumentSentiment bool `protobuf:"varint,3,opt,name=extract_document_sentiment,json=extractDocumentSentiment" json:"extract_document_sentiment,omitempty"` // Extract entities and their associated sentiment. ExtractEntitySentiment bool `protobuf:"varint,4,opt,name=extract_entity_sentiment,json=extractEntitySentiment" json:"extract_entity_sentiment,omitempty"` + // Classify the full document into categories. + ClassifyText bool `protobuf:"varint,6,opt,name=classify_text,json=classifyText" json:"classify_text,omitempty"` } func (m *AnnotateTextRequest_Features) Reset() { *m = AnnotateTextRequest_Features{} } func (m *AnnotateTextRequest_Features) String() string { return proto.CompactTextString(m) } func (*AnnotateTextRequest_Features) ProtoMessage() {} func (*AnnotateTextRequest_Features) Descriptor() ([]byte, []int) { - return fileDescriptor0, []int{17, 0} + return fileDescriptor0, []int{20, 0} } func (m *AnnotateTextRequest_Features) GetExtractSyntax() bool { @@ -1923,6 +1992,13 @@ func (m *AnnotateTextRequest_Features) GetExtractEntitySentiment() bool { return false } +func (m *AnnotateTextRequest_Features) GetClassifyText() bool { + if m != nil { + return m.ClassifyText + } + return false +} + // The text annotations response message. type AnnotateTextResponse struct { // Sentences in the input document. Populated if the user enables @@ -1943,12 +2019,14 @@ type AnnotateTextResponse struct { // in the request or, if not specified, the automatically-detected language. // See [Document.language][google.cloud.language.v1beta2.Document.language] field for more details. Language string `protobuf:"bytes,5,opt,name=language" json:"language,omitempty"` + // Categories identified in the input document. + Categories []*ClassificationCategory `protobuf:"bytes,6,rep,name=categories" json:"categories,omitempty"` } func (m *AnnotateTextResponse) Reset() { *m = AnnotateTextResponse{} } func (m *AnnotateTextResponse) String() string { return proto.CompactTextString(m) } func (*AnnotateTextResponse) ProtoMessage() {} -func (*AnnotateTextResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } +func (*AnnotateTextResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} } func (m *AnnotateTextResponse) GetSentences() []*Sentence { if m != nil { @@ -1985,6 +2063,13 @@ func (m *AnnotateTextResponse) GetLanguage() string { return "" } +func (m *AnnotateTextResponse) GetCategories() []*ClassificationCategory { + if m != nil { + return m.Categories + } + return nil +} + func init() { proto.RegisterType((*Document)(nil), "google.cloud.language.v1beta2.Document") proto.RegisterType((*Sentence)(nil), "google.cloud.language.v1beta2.Sentence") @@ -1995,6 +2080,7 @@ func init() { proto.RegisterType((*DependencyEdge)(nil), "google.cloud.language.v1beta2.DependencyEdge") proto.RegisterType((*EntityMention)(nil), "google.cloud.language.v1beta2.EntityMention") proto.RegisterType((*TextSpan)(nil), "google.cloud.language.v1beta2.TextSpan") + proto.RegisterType((*ClassificationCategory)(nil), "google.cloud.language.v1beta2.ClassificationCategory") proto.RegisterType((*AnalyzeSentimentRequest)(nil), "google.cloud.language.v1beta2.AnalyzeSentimentRequest") proto.RegisterType((*AnalyzeSentimentResponse)(nil), "google.cloud.language.v1beta2.AnalyzeSentimentResponse") proto.RegisterType((*AnalyzeEntitySentimentRequest)(nil), "google.cloud.language.v1beta2.AnalyzeEntitySentimentRequest") @@ -2003,6 +2089,8 @@ func init() { proto.RegisterType((*AnalyzeEntitiesResponse)(nil), "google.cloud.language.v1beta2.AnalyzeEntitiesResponse") proto.RegisterType((*AnalyzeSyntaxRequest)(nil), "google.cloud.language.v1beta2.AnalyzeSyntaxRequest") proto.RegisterType((*AnalyzeSyntaxResponse)(nil), "google.cloud.language.v1beta2.AnalyzeSyntaxResponse") + proto.RegisterType((*ClassifyTextRequest)(nil), "google.cloud.language.v1beta2.ClassifyTextRequest") + proto.RegisterType((*ClassifyTextResponse)(nil), "google.cloud.language.v1beta2.ClassifyTextResponse") proto.RegisterType((*AnnotateTextRequest)(nil), "google.cloud.language.v1beta2.AnnotateTextRequest") proto.RegisterType((*AnnotateTextRequest_Features)(nil), "google.cloud.language.v1beta2.AnnotateTextRequest.Features") proto.RegisterType((*AnnotateTextResponse)(nil), "google.cloud.language.v1beta2.AnnotateTextResponse") @@ -2049,8 +2137,10 @@ type LanguageServiceClient interface { // tokenization along with part of speech tags, dependency trees, and other // properties. AnalyzeSyntax(ctx context.Context, in *AnalyzeSyntaxRequest, opts ...grpc.CallOption) (*AnalyzeSyntaxResponse, error) - // A convenience method that provides all syntax, sentiment, and entity - // features in one call. + // Classifies a document into categories. + ClassifyText(ctx context.Context, in *ClassifyTextRequest, opts ...grpc.CallOption) (*ClassifyTextResponse, error) + // A convenience method that provides all syntax, sentiment, entity, and + // classification features in one call. AnnotateText(ctx context.Context, in *AnnotateTextRequest, opts ...grpc.CallOption) (*AnnotateTextResponse, error) } @@ -2098,6 +2188,15 @@ func (c *languageServiceClient) AnalyzeSyntax(ctx context.Context, in *AnalyzeSy return out, nil } +func (c *languageServiceClient) ClassifyText(ctx context.Context, in *ClassifyTextRequest, opts ...grpc.CallOption) (*ClassifyTextResponse, error) { + out := new(ClassifyTextResponse) + err := grpc.Invoke(ctx, "/google.cloud.language.v1beta2.LanguageService/ClassifyText", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *languageServiceClient) AnnotateText(ctx context.Context, in *AnnotateTextRequest, opts ...grpc.CallOption) (*AnnotateTextResponse, error) { out := new(AnnotateTextResponse) err := grpc.Invoke(ctx, "/google.cloud.language.v1beta2.LanguageService/AnnotateText", in, out, c.cc, opts...) @@ -2123,8 +2222,10 @@ type LanguageServiceServer interface { // tokenization along with part of speech tags, dependency trees, and other // properties. AnalyzeSyntax(context.Context, *AnalyzeSyntaxRequest) (*AnalyzeSyntaxResponse, error) - // A convenience method that provides all syntax, sentiment, and entity - // features in one call. + // Classifies a document into categories. + ClassifyText(context.Context, *ClassifyTextRequest) (*ClassifyTextResponse, error) + // A convenience method that provides all syntax, sentiment, entity, and + // classification features in one call. AnnotateText(context.Context, *AnnotateTextRequest) (*AnnotateTextResponse, error) } @@ -2204,6 +2305,24 @@ func _LanguageService_AnalyzeSyntax_Handler(srv interface{}, ctx context.Context return interceptor(ctx, in, info, handler) } +func _LanguageService_ClassifyText_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ClassifyTextRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(LanguageServiceServer).ClassifyText(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.cloud.language.v1beta2.LanguageService/ClassifyText", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(LanguageServiceServer).ClassifyText(ctx, req.(*ClassifyTextRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _LanguageService_AnnotateText_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(AnnotateTextRequest) if err := dec(in); err != nil { @@ -2242,6 +2361,10 @@ var _LanguageService_serviceDesc = grpc.ServiceDesc{ MethodName: "AnalyzeSyntax", Handler: _LanguageService_AnalyzeSyntax_Handler, }, + { + MethodName: "ClassifyText", + Handler: _LanguageService_ClassifyText_Handler, + }, { MethodName: "AnnotateText", Handler: _LanguageService_AnnotateText_Handler, @@ -2256,185 +2379,193 @@ func init() { } var fileDescriptor0 = []byte{ - // 2873 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5a, 0x4d, 0x73, 0xdb, 0xc6, - 0xf9, 0x37, 0xf8, 0x26, 0x72, 0x29, 0xc9, 0x6b, 0xc4, 0x89, 0xf9, 0xd7, 0x3f, 0x2f, 0x0e, 0x12, - 0xd7, 0x8a, 0x9d, 0x50, 0xb1, 0xec, 0x38, 0xae, 0xed, 0xbc, 0x40, 0xc0, 0x92, 0x82, 0x4c, 0x02, - 0xc8, 0x02, 0xa0, 0xe5, 0x5c, 0x38, 0x30, 0xb9, 0x62, 0x38, 0x91, 0x00, 0x96, 0x80, 0x3c, 0x56, - 0x2f, 0x99, 0xc9, 0x4c, 0x8f, 0x99, 0x1e, 0x72, 0xe8, 0x07, 0xe8, 0xa1, 0xa7, 0x4e, 0x3a, 0xd3, - 0x99, 0x4e, 0xfb, 0x19, 0x7a, 0x4c, 0xa7, 0xa7, 0x1e, 0x7b, 0xec, 0xa1, 0x87, 0x1e, 0x7a, 0xec, - 0x3c, 0xbb, 0x0b, 0xbe, 0xc8, 0x8e, 0x25, 0x3a, 0x99, 0x4e, 0x7a, 0xdb, 0x7d, 0xf0, 0xfc, 0x9e, - 0x7d, 0xde, 0x9f, 0x05, 0x48, 0x74, 0x63, 0x10, 0xc7, 0x83, 0x7d, 0xb6, 0xd1, 0xdb, 0x8f, 0x0f, - 0xfb, 0x1b, 0xfb, 0x61, 0x34, 0x38, 0x0c, 0x07, 0x6c, 0xe3, 0xd1, 0xb5, 0x87, 0x2c, 0x0d, 0x37, - 0x27, 0x84, 0x6e, 0xc2, 0xc6, 0x8f, 0x86, 0x3d, 0x56, 0x1f, 0x8d, 0xe3, 0x34, 0x56, 0x5f, 0x11, - 0xa8, 0x3a, 0x47, 0xd5, 0x33, 0xa6, 0xba, 0x44, 0xad, 0xbd, 0x2c, 0x85, 0x86, 0xa3, 0xe1, 0x46, - 0x18, 0x45, 0x71, 0x1a, 0xa6, 0xc3, 0x38, 0x4a, 0x04, 0x78, 0xed, 0x0d, 0xf9, 0x74, 0x3f, 0x8e, - 0x06, 0xe3, 0xc3, 0x28, 0x1a, 0x46, 0x83, 0x8d, 0x78, 0xc4, 0xc6, 0x73, 0x4c, 0xaf, 0x49, 0x26, - 0xbe, 0x7b, 0x78, 0xb8, 0xb7, 0x91, 0x0e, 0x0f, 0x58, 0x92, 0x86, 0x07, 0x23, 0xc9, 0x70, 0x41, - 0x32, 0x8c, 0x47, 0xbd, 0x8d, 0x24, 0x0d, 0xd3, 0x43, 0x89, 0xd4, 0xfe, 0xa9, 0xa0, 0xb2, 0x19, - 0xf7, 0x0e, 0x0f, 0x58, 0x94, 0xaa, 0x1f, 0xa3, 0x42, 0x7a, 0x34, 0x62, 0x35, 0xe5, 0xa2, 0xb2, - 0xbe, 0xba, 0xf9, 0x76, 0xfd, 0x99, 0x7a, 0xd7, 0x33, 0x58, 0xdd, 0x3f, 0x1a, 0x31, 0xca, 0x91, - 0xea, 0x1a, 0x5a, 0xea, 0xc5, 0x51, 0xca, 0xa2, 0xb4, 0x96, 0xbb, 0xa8, 0xac, 0x57, 0xb6, 0xcf, - 0xd0, 0x8c, 0xa0, 0xae, 0xa3, 0xb3, 0x83, 0x5e, 0xd2, 0x95, 0xdb, 0xee, 0xe1, 0x78, 0x58, 0xcb, - 0x4b, 0x9e, 0x95, 0x41, 0x2f, 0x31, 0x04, 0x3d, 0x18, 0x0f, 0xd5, 0x35, 0x54, 0xce, 0x4e, 0xab, - 0x15, 0x80, 0x85, 0x4e, 0xf6, 0xda, 0x4d, 0x54, 0x80, 0xf3, 0xd4, 0xf3, 0x08, 0xfb, 0x0f, 0x5c, - 0xd2, 0x0d, 0x6c, 0xcf, 0x25, 0x86, 0xd5, 0xb0, 0x88, 0x89, 0xcf, 0xa8, 0xab, 0x08, 0xb9, 0x2d, - 0xdd, 0xb2, 0xbb, 0x3e, 0xd9, 0xf5, 0xb1, 0xa2, 0x96, 0x51, 0x61, 0xdb, 0x6f, 0xb7, 0x70, 0x6e, - 0xab, 0x8c, 0x4a, 0x49, 0x7c, 0x38, 0xee, 0x31, 0xed, 0x97, 0x0a, 0x2a, 0x7b, 0x0c, 0x0e, 0xeb, - 0x31, 0xf5, 0x0e, 0x2a, 0xa4, 0xec, 0x71, 0xca, 0x4d, 0xae, 0x6e, 0x5e, 0x3e, 0xc1, 0x64, 0x9f, - 0x3d, 0x4e, 0xbd, 0x51, 0x18, 0x51, 0x0e, 0x52, 0x1b, 0xa8, 0x92, 0xb0, 0x08, 0x7c, 0x2d, 0xed, - 0xad, 0x6e, 0xae, 0x9f, 0x20, 0xc1, 0xcb, 0xf8, 0xe9, 0x14, 0xaa, 0x7d, 0x5d, 0x40, 0x25, 0x12, - 0xa5, 0xc3, 0xf4, 0x48, 0x55, 0x51, 0x21, 0x0a, 0x0f, 0x44, 0x08, 0x2a, 0x94, 0xaf, 0xd5, 0x0f, - 0x65, 0x58, 0x72, 0x3c, 0x2c, 0x57, 0x4e, 0x38, 0x41, 0x08, 0x9a, 0x0d, 0x8a, 0x83, 0xca, 0x07, - 0x2c, 0x0d, 0xfb, 0x61, 0x1a, 0xd6, 0xf2, 0x17, 0xf3, 0xeb, 0xd5, 0xcd, 0xeb, 0xa7, 0x93, 0xd1, - 0x96, 0x28, 0x12, 0xa5, 0xe3, 0x23, 0x3a, 0x11, 0x02, 0xf1, 0x49, 0xc2, 0xfd, 0x21, 0x38, 0x90, - 0xc7, 0x27, 0x47, 0x27, 0x7b, 0x75, 0x1b, 0x0e, 0x8b, 0x78, 0x72, 0xd6, 0x8a, 0xfc, 0xb0, 0xb7, - 0x4f, 0x75, 0x58, 0x5b, 0x80, 0xe8, 0x04, 0x3d, 0xef, 0xdd, 0xd2, 0x73, 0x7b, 0x77, 0xed, 0x0e, - 0x5a, 0x99, 0x33, 0x44, 0xc5, 0x28, 0xff, 0x39, 0x3b, 0x92, 0x2e, 0x86, 0xa5, 0x7a, 0x1e, 0x15, - 0x1f, 0x85, 0xfb, 0x87, 0xc2, 0xc5, 0x15, 0x2a, 0x36, 0xb7, 0x73, 0xb7, 0x14, 0xed, 0x48, 0xa6, - 0x5b, 0x15, 0x2d, 0x05, 0xf6, 0x3d, 0xdb, 0xb9, 0x6f, 0xe3, 0x33, 0x2a, 0x42, 0x25, 0x97, 0x50, - 0xcf, 0xb1, 0xb1, 0xa2, 0x2e, 0xa3, 0x72, 0xcb, 0x31, 0x74, 0xdf, 0x72, 0x6c, 0x9c, 0x53, 0x31, - 0x5a, 0x76, 0x68, 0x53, 0xb7, 0xad, 0x4f, 0x05, 0x25, 0xaf, 0x56, 0x50, 0x91, 0x74, 0x88, 0xed, - 0xe3, 0x82, 0x7a, 0x16, 0x55, 0xef, 0x3b, 0xf4, 0x5e, 0xd7, 0x69, 0x74, 0x75, 0xea, 0xe3, 0xa2, - 0x7a, 0x0e, 0xad, 0x18, 0x8e, 0xed, 0x05, 0x6d, 0x42, 0xbb, 0x4d, 0xc7, 0x31, 0x71, 0x09, 0xd8, - 0x1d, 0x7f, 0x9b, 0x50, 0xbc, 0xa4, 0xfd, 0x22, 0x87, 0x8a, 0x7e, 0xfc, 0x39, 0x8b, 0xbe, 0x5f, - 0x92, 0x7e, 0x82, 0x56, 0x47, 0xe1, 0x38, 0xed, 0xc6, 0x7b, 0xdd, 0x64, 0xc4, 0x58, 0xef, 0x33, - 0x99, 0xa9, 0x57, 0x4f, 0x10, 0xe3, 0x86, 0xe3, 0xd4, 0xd9, 0xf3, 0x38, 0x84, 0x2e, 0x8f, 0x66, - 0x76, 0x6a, 0x07, 0x9d, 0xed, 0xb3, 0x11, 0x8b, 0xfa, 0x2c, 0xea, 0x1d, 0x75, 0x59, 0x7f, 0xc0, - 0x78, 0x25, 0x57, 0x37, 0xdf, 0x39, 0xa9, 0x65, 0x4c, 0x50, 0xa4, 0x3f, 0x60, 0x74, 0xb5, 0x3f, - 0xb7, 0x87, 0x30, 0xec, 0xb3, 0x83, 0x83, 0x50, 0x16, 0xbd, 0xd8, 0x68, 0x1f, 0xa1, 0xca, 0x24, - 0xae, 0xea, 0xcb, 0xa8, 0x72, 0x10, 0x0e, 0xa2, 0x61, 0x7a, 0xd8, 0x17, 0xd1, 0xca, 0xd1, 0x29, - 0x01, 0x04, 0x24, 0xbd, 0x78, 0x2c, 0xd4, 0xc9, 0x51, 0xb1, 0xd1, 0xfe, 0x74, 0x0e, 0x2d, 0xcf, - 0x5a, 0xa3, 0xea, 0x28, 0x9f, 0x86, 0x03, 0xd9, 0xe6, 0x36, 0x16, 0xf0, 0x43, 0xdd, 0x0f, 0x07, - 0x14, 0xb0, 0xea, 0x0e, 0x2a, 0x85, 0xc9, 0x88, 0xf5, 0x52, 0x59, 0x95, 0x9b, 0x8b, 0x48, 0xd1, - 0x39, 0x92, 0x4a, 0x09, 0xaa, 0x89, 0x0a, 0xbd, 0x30, 0x11, 0x4a, 0xaf, 0x6e, 0xbe, 0xbb, 0x88, - 0x24, 0x23, 0x4c, 0x18, 0xe5, 0x68, 0x90, 0xb2, 0x17, 0x8f, 0x0f, 0xb8, 0xef, 0x16, 0x94, 0xd2, - 0x88, 0xc7, 0x07, 0x94, 0xa3, 0xc1, 0xae, 0x01, 0x84, 0x64, 0x5c, 0x2b, 0x2e, 0x6e, 0x57, 0x93, - 0x23, 0xa9, 0x94, 0x00, 0x1a, 0x1d, 0xc4, 0x71, 0x9f, 0xd7, 0xee, 0x82, 0x1a, 0xb5, 0xe3, 0xb8, - 0x4f, 0x39, 0x1a, 0x34, 0x8a, 0x0e, 0x0f, 0x1e, 0xb2, 0x71, 0x6d, 0x69, 0x71, 0x8d, 0x6c, 0x8e, - 0xa4, 0x52, 0x02, 0xc8, 0x1a, 0xb1, 0x71, 0x12, 0x47, 0xb5, 0xf2, 0xe2, 0xb2, 0x5c, 0x8e, 0xa4, - 0x52, 0x02, 0x97, 0x35, 0x86, 0x49, 0x5c, 0xab, 0x3c, 0x87, 0x2c, 0x8e, 0xa4, 0x52, 0x82, 0xfa, - 0x00, 0x55, 0xc7, 0xac, 0x37, 0x1c, 0x8d, 0xe3, 0xde, 0x30, 0x3d, 0xaa, 0x21, 0x2e, 0xf0, 0xfd, - 0x45, 0x04, 0xd2, 0x29, 0x9c, 0xce, 0xca, 0x52, 0x9b, 0xa8, 0x98, 0xb2, 0x28, 0x61, 0xb5, 0x2a, - 0x17, 0x7a, 0x6d, 0xa1, 0x6c, 0x07, 0x20, 0x15, 0x78, 0x10, 0xf4, 0x28, 0x1e, 0xf6, 0x58, 0x6d, - 0x79, 0x71, 0x41, 0x1d, 0x00, 0x52, 0x81, 0xd7, 0xbe, 0x52, 0x50, 0xde, 0x0f, 0x07, 0xf3, 0x2d, - 0x75, 0x09, 0xe5, 0x75, 0x73, 0x07, 0x2b, 0x62, 0xe1, 0xe2, 0x9c, 0x58, 0x74, 0x70, 0x1e, 0x66, - 0xb8, 0xe1, 0xd8, 0x3b, 0xb8, 0x00, 0x24, 0x93, 0x40, 0xe3, 0x2c, 0xa3, 0x82, 0xed, 0x04, 0x36, - 0x2e, 0x01, 0xc9, 0x0e, 0xda, 0x78, 0x09, 0x48, 0x2e, 0x75, 0x6c, 0x5c, 0x06, 0x92, 0x4b, 0x7d, - 0x5c, 0x81, 0x5e, 0xea, 0x06, 0xb6, 0xe1, 0x63, 0x04, 0x4f, 0x3b, 0x84, 0x6e, 0xe1, 0xaa, 0x5a, - 0x44, 0xca, 0x2e, 0x5e, 0x86, 0x67, 0x7a, 0xa3, 0x61, 0xed, 0xe2, 0x15, 0xcd, 0x41, 0x25, 0x51, - 0x90, 0xaa, 0x8a, 0x56, 0x75, 0xb8, 0x4d, 0xf8, 0xdd, 0xa9, 0x62, 0x70, 0xa3, 0x20, 0xb4, 0x41, - 0x0c, 0xdf, 0xea, 0x10, 0xac, 0x40, 0x87, 0xb7, 0xda, 0x33, 0x94, 0x1c, 0xb4, 0x75, 0x97, 0x3a, - 0x4d, 0x4a, 0x3c, 0x0f, 0x08, 0x79, 0xed, 0xdf, 0x0a, 0x2a, 0x40, 0x61, 0x02, 0xaf, 0xa1, 0x7b, - 0x64, 0x5e, 0x9a, 0x6e, 0x18, 0x81, 0xa7, 0x4b, 0x69, 0x2b, 0xa8, 0xa2, 0x9b, 0xa0, 0x99, 0xa5, - 0xb7, 0x70, 0x4e, 0x0c, 0x84, 0xb6, 0xdb, 0x22, 0x6d, 0x62, 0x73, 0x8e, 0x3c, 0xcc, 0x1a, 0x53, - 0x70, 0x17, 0x60, 0xd6, 0x34, 0x89, 0x6d, 0xf1, 0x5d, 0x91, 0x6b, 0x62, 0x7b, 0x3e, 0x0d, 0x80, - 0x59, 0x6f, 0xe1, 0xd2, 0x74, 0x16, 0x75, 0x08, 0x5e, 0x82, 0xb3, 0x6c, 0xa7, 0x6d, 0xd9, 0x62, - 0x5f, 0x06, 0x7f, 0x3b, 0x5b, 0x2d, 0xeb, 0x93, 0x80, 0xe0, 0x0a, 0x1c, 0xec, 0xea, 0xd4, 0x17, - 0xb2, 0x10, 0x1c, 0xec, 0x52, 0xe2, 0x3a, 0x9e, 0x05, 0x63, 0x4b, 0x6f, 0xe1, 0x2a, 0x38, 0x83, - 0x92, 0x46, 0x8b, 0xec, 0x5a, 0x1d, 0xd2, 0x05, 0x33, 0xf0, 0x32, 0xb0, 0x51, 0xd2, 0xe2, 0x02, - 0x05, 0x69, 0x05, 0xce, 0xec, 0x64, 0x67, 0xae, 0x6a, 0xdf, 0x28, 0xa8, 0x00, 0xdd, 0x04, 0x94, - 0x6b, 0x38, 0xb4, 0x3d, 0x63, 0xfa, 0x32, 0x2a, 0xeb, 0x26, 0x28, 0xa4, 0xb7, 0xa4, 0xe1, 0xc1, - 0xae, 0xd5, 0xb2, 0x74, 0xfa, 0x00, 0xe7, 0xe0, 0xb0, 0x19, 0xc3, 0x3f, 0x25, 0x14, 0xe7, 0xb9, - 0x08, 0xcb, 0xd6, 0x5b, 0x5d, 0x62, 0x9b, 0x96, 0xdd, 0xc4, 0x05, 0xf0, 0x45, 0x93, 0xd0, 0xc0, - 0x36, 0x71, 0x11, 0xd6, 0x94, 0xe8, 0x2d, 0xcb, 0x13, 0x76, 0x5b, 0x54, 0xee, 0x96, 0x20, 0xb4, - 0xde, 0xb6, 0x43, 0x7d, 0x5c, 0x86, 0xb0, 0xb7, 0x1c, 0xbb, 0x29, 0x72, 0xc1, 0xa1, 0x26, 0xa1, - 0x18, 0x01, 0xb7, 0xbc, 0x32, 0x1a, 0xb8, 0xaa, 0x11, 0x54, 0x12, 0x6d, 0x0b, 0x74, 0x68, 0x12, - 0xdb, 0x24, 0x74, 0x5e, 0xe9, 0x06, 0x69, 0x5b, 0xb6, 0x65, 0xcb, 0x68, 0xb5, 0x75, 0xcf, 0x08, - 0x5a, 0xb0, 0xcd, 0x81, 0x0a, 0x36, 0x09, 0x7c, 0x50, 0x56, 0xfb, 0x02, 0x15, 0xa0, 0x67, 0x81, - 0xd2, 0x6d, 0xc7, 0x31, 0x67, 0x44, 0x9c, 0x47, 0xd8, 0x70, 0x6c, 0x53, 0x3a, 0xb6, 0x0b, 0x4f, - 0xb1, 0x02, 0xc1, 0xe1, 0x69, 0xa4, 0xcb, 0x24, 0x82, 0xbd, 0x6d, 0x5a, 0xd2, 0x91, 0x79, 0xf0, - 0xb4, 0x65, 0xfb, 0x84, 0x52, 0xa7, 0x99, 0x45, 0xbf, 0x8a, 0x96, 0x76, 0x02, 0x91, 0x63, 0x45, - 0x48, 0x3a, 0x2f, 0xd8, 0xda, 0x81, 0xf4, 0x06, 0x42, 0x49, 0xfb, 0x18, 0x95, 0x44, 0xb3, 0x03, - 0x3b, 0xec, 0xa0, 0xbd, 0x75, 0xdc, 0x0e, 0xcf, 0xb2, 0x9b, 0x41, 0x4b, 0xa7, 0x58, 0xe1, 0xf7, - 0x97, 0x56, 0x40, 0x79, 0xca, 0x95, 0x51, 0xc1, 0x0c, 0xf4, 0x16, 0xce, 0x6b, 0x3e, 0x2a, 0x89, - 0x16, 0x07, 0x12, 0xc4, 0xfd, 0x66, 0x46, 0x42, 0x05, 0x15, 0x1b, 0x16, 0xf5, 0x7c, 0x01, 0xf7, - 0x08, 0xd8, 0x84, 0x73, 0x40, 0xf6, 0xb7, 0x2d, 0x6a, 0xe2, 0x3c, 0x18, 0x3a, 0x4d, 0x18, 0x79, - 0x3f, 0x2a, 0x68, 0xb7, 0x50, 0x49, 0x34, 0x3b, 0x2e, 0x95, 0x3a, 0xee, 0x9c, 0x5e, 0xa0, 0x09, - 0xa7, 0x09, 0x97, 0xd8, 0x8e, 0xdf, 0x95, 0xfb, 0x9c, 0xb6, 0x83, 0xaa, 0x33, 0x5d, 0x4d, 0xbd, - 0x80, 0x5e, 0xa0, 0xc4, 0xb0, 0x5c, 0xea, 0x18, 0x96, 0xff, 0x60, 0xbe, 0xa6, 0xb2, 0x07, 0x3c, - 0xb5, 0xc0, 0x7e, 0xc7, 0xee, 0xce, 0xd0, 0x72, 0x5a, 0x82, 0x8a, 0xbc, 0x99, 0x81, 0x5f, 0x7d, - 0x62, 0xcf, 0xd5, 0xe4, 0x8b, 0xe8, 0xdc, 0x6c, 0x80, 0xf8, 0x63, 0x61, 0x65, 0x23, 0xf0, 0x03, - 0x4a, 0x84, 0x93, 0x5c, 0xdd, 0xf3, 0x71, 0x1e, 0x82, 0xe0, 0x52, 0xe2, 0x89, 0x0b, 0xdd, 0x0a, - 0xaa, 0x4c, 0x7a, 0x01, 0x2e, 0x8a, 0x97, 0x8f, 0x20, 0xdb, 0x97, 0xb4, 0x2d, 0x54, 0xe4, 0x8d, - 0x0f, 0x0e, 0xed, 0x38, 0x96, 0x41, 0xe6, 0x0d, 0xd7, 0x8d, 0x69, 0x13, 0x30, 0xf4, 0xac, 0x27, - 0xe4, 0xf8, 0x11, 0x7a, 0xd6, 0x4b, 0xfe, 0xb5, 0x84, 0x56, 0xe7, 0x6f, 0x4d, 0xea, 0x3a, 0xc2, - 0x9f, 0xb1, 0xb0, 0xdf, 0x4d, 0xe1, 0x6e, 0xd8, 0x1d, 0x46, 0x7d, 0xf6, 0x98, 0x5f, 0x65, 0x8a, - 0x74, 0x15, 0xe8, 0xfc, 0xca, 0x68, 0x01, 0x55, 0xb5, 0x50, 0x71, 0x3f, 0x7c, 0xc8, 0xf6, 0xe5, - 0x1d, 0xe5, 0xfa, 0x42, 0xb7, 0xb3, 0x7a, 0x0b, 0xa0, 0x54, 0x48, 0xd0, 0xfe, 0x51, 0x42, 0x45, - 0x4e, 0x78, 0xe2, 0x26, 0xac, 0x6f, 0x6d, 0x51, 0xd2, 0xc1, 0x0a, 0x6f, 0xa9, 0x50, 0xc4, 0x22, - 0x2b, 0x74, 0xb3, 0x63, 0xb4, 0x44, 0xff, 0xd2, 0xcd, 0x4e, 0xdb, 0x31, 0x71, 0x01, 0xdc, 0xa8, - 0xc3, 0xaa, 0xc8, 0x19, 0x5c, 0xd7, 0x81, 0xe2, 0x05, 0xa2, 0xef, 0x53, 0xbc, 0xc4, 0x3b, 0x7e, - 0xb0, 0x2b, 0x3a, 0x95, 0x1e, 0xec, 0x82, 0x13, 0x70, 0x45, 0x2d, 0xa1, 0x9c, 0x61, 0x60, 0x04, - 0x10, 0x83, 0x8b, 0xaf, 0x4e, 0x26, 0x02, 0x6f, 0xe3, 0x06, 0xd4, 0x01, 0x5e, 0xe1, 0x5e, 0x84, - 0x25, 0x87, 0xad, 0x8a, 0x59, 0xe1, 0xe2, 0xb3, 0xd9, 0xd0, 0xc0, 0xc0, 0x60, 0x5a, 0x9e, 0xe1, - 0x04, 0xd4, 0x23, 0xf8, 0x1c, 0x4f, 0x7c, 0x67, 0x6b, 0x07, 0xab, 0xb0, 0x22, 0xbb, 0x6e, 0x0b, - 0xbf, 0xc0, 0x1b, 0xac, 0x43, 0xbc, 0xfb, 0x96, 0xbf, 0x8d, 0xcf, 0x03, 0xdd, 0x02, 0x8e, 0x17, - 0x61, 0xd5, 0xd6, 0xe9, 0x3d, 0xfc, 0x12, 0x48, 0x6b, 0xdf, 0x27, 0xf8, 0x82, 0x58, 0x74, 0x70, - 0x8d, 0x4f, 0x20, 0xd2, 0xc4, 0xff, 0x07, 0x8a, 0xda, 0x36, 0x5e, 0x03, 0x21, 0xb6, 0x2b, 0x6d, - 0xfe, 0x7f, 0xd0, 0xd0, 0xe6, 0x1a, 0xbe, 0x0c, 0x0a, 0xd8, 0x13, 0x0d, 0x5f, 0xc9, 0x46, 0xd7, - 0xab, 0xbc, 0x8f, 0xf0, 0x82, 0xc5, 0xaf, 0xc1, 0x78, 0x72, 0xf1, 0x45, 0xd9, 0x9e, 0x75, 0x5f, - 0xdf, 0xb5, 0x3c, 0xfc, 0xba, 0x48, 0x09, 0xea, 0x83, 0x44, 0x8d, 0x8f, 0x35, 0xee, 0x88, 0x37, - 0x78, 0x5e, 0x82, 0x86, 0x6f, 0x8a, 0x95, 0xe7, 0xe1, 0x4b, 0x9c, 0xd7, 0xf1, 0x7c, 0xd0, 0xe9, - 0x27, 0x32, 0x5d, 0x39, 0xf7, 0xe5, 0xc9, 0xc6, 0xde, 0xc1, 0xeb, 0xa2, 0xf2, 0x08, 0x78, 0xe6, - 0x2d, 0x31, 0x3b, 0x49, 0x03, 0x5f, 0x91, 0x2b, 0x17, 0x5f, 0xe5, 0xa7, 0x50, 0xc7, 0x6e, 0xe1, - 0xb7, 0xb3, 0x81, 0xfa, 0x0e, 0x58, 0xe8, 0x7a, 0xb8, 0x0e, 0x16, 0x7e, 0x12, 0xe8, 0x36, 0xd7, - 0x67, 0x03, 0x38, 0xa9, 0x01, 0xcb, 0x77, 0xe1, 0x01, 0x5f, 0x52, 0xd2, 0xc2, 0xd7, 0xf8, 0x03, - 0x93, 0x3a, 0x2e, 0xde, 0x04, 0x11, 0x70, 0xc0, 0x75, 0xd0, 0x81, 0x92, 0xb6, 0xad, 0xdb, 0x3e, - 0xbe, 0x21, 0x2a, 0x17, 0xec, 0xb4, 0xcd, 0xa0, 0x8d, 0xdf, 0x83, 0xd3, 0xa9, 0xe3, 0xf8, 0xf8, - 0x26, 0xac, 0x3c, 0x70, 0xce, 0xfb, 0x7c, 0x15, 0x34, 0x1a, 0xf8, 0x16, 0xac, 0xf8, 0x89, 0x3f, - 0xe5, 0x4d, 0xc7, 0x71, 0x2d, 0x03, 0xdf, 0xe6, 0x83, 0x1d, 0x88, 0x77, 0xe6, 0x06, 0xd1, 0x5d, - 0x60, 0xd9, 0xe5, 0x66, 0x7f, 0xc0, 0xdb, 0x55, 0xc0, 0x67, 0xfd, 0x87, 0x1c, 0x69, 0xf9, 0x2d, - 0x82, 0x3f, 0x12, 0xf3, 0xa8, 0xe3, 0x6e, 0x03, 0xfa, 0x63, 0x99, 0x72, 0x50, 0x86, 0x58, 0xe7, - 0xd9, 0x19, 0xec, 0x76, 0x3a, 0x78, 0x0b, 0x96, 0x26, 0x3f, 0xd5, 0x00, 0x96, 0x86, 0x43, 0x89, - 0xd5, 0xb4, 0xb1, 0x09, 0xae, 0xb8, 0x77, 0x1f, 0x13, 0x3e, 0x61, 0x2c, 0xcf, 0xc7, 0x0d, 0x71, - 0x27, 0x69, 0x1b, 0xb8, 0xc9, 0x13, 0xc0, 0x69, 0x8b, 0xbc, 0xdc, 0x86, 0x89, 0x90, 0xed, 0x78, - 0xe0, 0x2d, 0xce, 0x19, 0xb4, 0x0d, 0xbc, 0x03, 0x6e, 0x31, 0x1c, 0x17, 0xdf, 0x03, 0x4f, 0x98, - 0x96, 0xc7, 0x87, 0x37, 0x31, 0x71, 0x4b, 0xfb, 0x2a, 0x87, 0x56, 0xe6, 0xde, 0x8b, 0xbf, 0xdf, - 0x3b, 0x20, 0x99, 0xfb, 0x82, 0x70, 0x6d, 0x91, 0x17, 0xf2, 0xd9, 0x0f, 0x09, 0x73, 0x6f, 0xe4, - 0xf9, 0xe7, 0xff, 0xde, 0xf1, 0xae, 0x7c, 0xa9, 0xc6, 0x68, 0x59, 0x7e, 0xc3, 0x79, 0xda, 0x3c, - 0x40, 0xa8, 0x64, 0x38, 0xed, 0x36, 0xbc, 0x57, 0x6b, 0x4d, 0x54, 0xce, 0x4c, 0x52, 0x6b, 0xd3, - 0x6f, 0x4c, 0xe2, 0x15, 0x7e, 0xf2, 0x85, 0xe9, 0x75, 0xb4, 0xfc, 0x90, 0x0d, 0x86, 0x51, 0x37, - 0xde, 0xdb, 0x4b, 0x98, 0x78, 0x35, 0x2b, 0xd2, 0x2a, 0xa7, 0x39, 0x9c, 0xa4, 0xfd, 0x4e, 0x41, - 0x17, 0xf4, 0x28, 0xdc, 0x3f, 0xfa, 0x39, 0x9b, 0xaa, 0xc6, 0x7e, 0x76, 0xc8, 0x92, 0x54, 0x35, - 0x50, 0xb9, 0x2f, 0xbf, 0x69, 0x9d, 0xd2, 0xcd, 0xd9, 0x27, 0x30, 0x3a, 0x01, 0xaa, 0x2e, 0x5a, - 0x61, 0x51, 0x2f, 0xee, 0x0f, 0xa3, 0x41, 0x77, 0xc6, 0xe7, 0x57, 0x4f, 0xf4, 0xb9, 0xc0, 0x70, - 0x6f, 0x2f, 0xb3, 0x99, 0x9d, 0xf6, 0x57, 0x05, 0xd5, 0x9e, 0x54, 0x39, 0x19, 0xc5, 0x30, 0xcf, - 0xee, 0x23, 0x35, 0x3b, 0xba, 0x3b, 0x8d, 0x8d, 0xb2, 0x60, 0x6c, 0xce, 0x65, 0x32, 0xa6, 0x2f, - 0xda, 0xb3, 0xdf, 0xe0, 0x72, 0xf3, 0xdf, 0xe0, 0x54, 0x22, 0xf2, 0x80, 0x45, 0x3d, 0x96, 0xc8, - 0x2f, 0x4a, 0x97, 0x4f, 0x71, 0x16, 0xf0, 0xd3, 0x29, 0x52, 0xfb, 0x83, 0x82, 0x5e, 0x91, 0x86, - 0x89, 0x94, 0xfb, 0x5f, 0x89, 0xc8, 0x17, 0xe8, 0xd5, 0xef, 0xd2, 0x5b, 0x86, 0x45, 0x47, 0x65, - 0xa0, 0xa5, 0x43, 0x96, 0xd4, 0x14, 0xee, 0xa0, 0x4b, 0xa7, 0x2a, 0x3a, 0x3a, 0x81, 0x3d, 0x2b, - 0x00, 0x70, 0xcd, 0x7e, 0x69, 0x56, 0x83, 0x21, 0x4b, 0x7e, 0xe4, 0x2e, 0x7b, 0x3c, 0x29, 0xbb, - 0xa9, 0xc2, 0xff, 0x1d, 0x5f, 0xfd, 0x56, 0x41, 0xe7, 0xb3, 0xf2, 0x39, 0x8a, 0xd2, 0xf0, 0xf1, - 0x8f, 0xdc, 0x53, 0x7f, 0x54, 0xd0, 0x8b, 0xc7, 0xf4, 0x95, 0x8e, 0x9a, 0x2b, 0x3b, 0xe5, 0x79, - 0xcb, 0x4e, 0xbd, 0x8b, 0x4a, 0xfc, 0xea, 0x98, 0xd4, 0x72, 0x5c, 0xc6, 0x9b, 0x27, 0xcd, 0x12, - 0x60, 0xa6, 0x12, 0x33, 0xe7, 0xea, 0xfc, 0x31, 0x57, 0xff, 0x2d, 0x8f, 0x5e, 0xd0, 0xc5, 0x2f, - 0x18, 0x0c, 0xda, 0xf5, 0x0f, 0xea, 0xe9, 0xfb, 0xa8, 0xbc, 0xc7, 0xc2, 0xf4, 0x70, 0xcc, 0x12, - 0xf9, 0x05, 0xf3, 0xce, 0x09, 0x42, 0x9e, 0xa2, 0x4a, 0xbd, 0x21, 0x45, 0xd0, 0x89, 0xb0, 0x27, - 0x43, 0x98, 0xff, 0x9e, 0x21, 0x5c, 0xfb, 0x8b, 0x82, 0xca, 0xd9, 0x41, 0xea, 0x25, 0xb4, 0xca, - 0x1e, 0xa7, 0xe3, 0xb0, 0x97, 0x76, 0x13, 0x1e, 0x4f, 0xee, 0x82, 0x32, 0x5d, 0x91, 0x54, 0x11, - 0x64, 0xf5, 0x2d, 0x84, 0x33, 0xb6, 0x49, 0x35, 0xe4, 0x38, 0xe3, 0x59, 0x49, 0xcf, 0x0a, 0x47, - 0xbd, 0x8b, 0xd6, 0x32, 0xd6, 0xa7, 0xf4, 0xfe, 0x3c, 0x07, 0xd5, 0x24, 0x87, 0xf9, 0x44, 0x63, - 0xbf, 0x85, 0x6a, 0x73, 0x07, 0x1d, 0xcd, 0x60, 0x0b, 0x1c, 0xfb, 0xd2, 0xec, 0x81, 0xd3, 0xe6, - 0xa6, 0x7d, 0x9b, 0x83, 0x4a, 0x9a, 0xf5, 0xe9, 0x8f, 0x29, 0x31, 0x67, 0xdb, 0x48, 0xfe, 0xf9, - 0xda, 0xc8, 0xd3, 0x87, 0x69, 0xe1, 0x87, 0x1d, 0xa6, 0xc5, 0xf9, 0xa2, 0xb9, 0x72, 0x0b, 0x2d, - 0xcf, 0xa6, 0x92, 0xb8, 0x47, 0xda, 0x04, 0x9f, 0x81, 0x55, 0xe0, 0x37, 0x6e, 0x89, 0x57, 0xab, - 0xc0, 0x6f, 0x5c, 0xbb, 0x29, 0x5e, 0xad, 0x02, 0xbf, 0x71, 0x7d, 0x13, 0xe7, 0x37, 0x7f, 0xb5, - 0x84, 0xce, 0xb6, 0xa4, 0x18, 0x4f, 0xfc, 0xe2, 0xa8, 0xfe, 0x5e, 0x41, 0xf8, 0xf8, 0x65, 0x41, - 0xbd, 0x79, 0x62, 0xa1, 0x3c, 0xf5, 0x42, 0xb4, 0xf6, 0xfe, 0xc2, 0x38, 0x91, 0x10, 0x5a, 0xfd, - 0xcb, 0x6f, 0xff, 0xfe, 0x75, 0x6e, 0x5d, 0x7b, 0x63, 0xf2, 0xd3, 0x68, 0xe6, 0x93, 0xe4, 0x76, - 0x78, 0x0c, 0x74, 0x5b, 0xb9, 0xa2, 0x7e, 0xa3, 0xa0, 0xb3, 0xc7, 0xc6, 0x83, 0xfa, 0xde, 0xe9, - 0x0e, 0x3f, 0x36, 0xff, 0xd6, 0x6e, 0x2e, 0x0a, 0x93, 0x2a, 0xbf, 0xc3, 0x55, 0xbe, 0xac, 0x69, - 0xdf, 0xad, 0x72, 0x86, 0x01, 0x8d, 0xff, 0x7c, 0x6c, 0x02, 0x4f, 0xcb, 0x44, 0xbd, 0xbb, 0x80, - 0x06, 0x4f, 0x5c, 0x79, 0xd6, 0x3e, 0x78, 0x4e, 0xb4, 0x34, 0xe3, 0x06, 0x37, 0xa3, 0xae, 0xbd, - 0x75, 0x82, 0x19, 0x47, 0x73, 0xfe, 0xff, 0x8d, 0x82, 0x56, 0xe6, 0x66, 0x8e, 0x7a, 0xfd, 0x94, - 0xa1, 0x9f, 0x9d, 0xa8, 0x6b, 0x37, 0x16, 0x03, 0x49, 0x95, 0xaf, 0x72, 0x95, 0x2f, 0x69, 0x17, - 0x9f, 0x91, 0x2c, 0x1c, 0x01, 0x9a, 0xfe, 0x5a, 0x41, 0xcb, 0xb3, 0x3d, 0x48, 0xdd, 0x5c, 0x7c, - 0x08, 0xac, 0x5d, 0x5f, 0x08, 0x23, 0xd5, 0xbc, 0xc2, 0xd5, 0x7c, 0x53, 0x7b, 0xed, 0xa9, 0x6a, - 0x4e, 0x01, 0xb7, 0x95, 0x2b, 0x5b, 0x5f, 0x2a, 0xe8, 0xf5, 0x5e, 0x7c, 0xf0, 0xec, 0x63, 0xb6, - 0xce, 0x1f, 0x2b, 0x5e, 0x77, 0x1c, 0xa7, 0xb1, 0xab, 0x7c, 0x4a, 0x24, 0x6c, 0x10, 0x03, 0xa4, - 0x1e, 0x8f, 0x07, 0x1b, 0x03, 0x16, 0xf1, 0xdf, 0xeb, 0x37, 0xc4, 0xa3, 0x70, 0x34, 0x4c, 0xbe, - 0xe3, 0x4f, 0x08, 0x77, 0x32, 0xc2, 0xc3, 0x12, 0x47, 0x5c, 0xff, 0x4f, 0x00, 0x00, 0x00, 0xff, - 0xff, 0x55, 0xc3, 0xe3, 0x00, 0xb5, 0x20, 0x00, 0x00, + // 2996 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5a, 0xcd, 0x6f, 0xdc, 0xd6, + 0xb5, 0x37, 0xe7, 0x4b, 0xa3, 0x3b, 0x92, 0x7c, 0x4d, 0x3b, 0xf6, 0x3c, 0xbd, 0x7c, 0x38, 0x74, + 0xfc, 0xac, 0xd8, 0x89, 0x14, 0x4b, 0x8e, 0xe3, 0x67, 0x3b, 0x1f, 0x14, 0x79, 0x67, 0x44, 0x99, + 0x43, 0x32, 0x97, 0xe4, 0x58, 0xf6, 0x66, 0x40, 0xcf, 0x50, 0x93, 0x41, 0x24, 0x72, 0xde, 0x90, + 0x32, 0xac, 0xb7, 0x09, 0x1a, 0xa0, 0xcb, 0xa0, 0x8b, 0xfc, 0x09, 0x5d, 0x14, 0x28, 0x50, 0xa4, + 0x40, 0x81, 0xa2, 0x5d, 0xf4, 0x2f, 0xe8, 0xb2, 0x40, 0xff, 0x82, 0x2e, 0xbb, 0xe8, 0xa2, 0x8b, + 0x76, 0x57, 0x9c, 0x7b, 0x2f, 0x67, 0x38, 0xb2, 0x62, 0x69, 0x1c, 0xa3, 0x48, 0x77, 0xf7, 0x9e, + 0x39, 0xbf, 0x73, 0xcf, 0xd7, 0x3d, 0xe7, 0xf0, 0x4a, 0xe8, 0x56, 0x3f, 0x8e, 0xfb, 0x7b, 0xe1, + 0x5a, 0x77, 0x2f, 0x3e, 0xe8, 0xad, 0xed, 0x05, 0x51, 0xff, 0x20, 0xe8, 0x87, 0x6b, 0x4f, 0x6f, + 0x3e, 0x09, 0xd3, 0x60, 0x7d, 0x4c, 0xe8, 0x24, 0xe1, 0xe8, 0xe9, 0xa0, 0x1b, 0xae, 0x0e, 0x47, + 0x71, 0x1a, 0xcb, 0x6f, 0x70, 0xd4, 0x2a, 0x43, 0xad, 0x66, 0x4c, 0xab, 0x02, 0xb5, 0xfc, 0xba, + 0x10, 0x1a, 0x0c, 0x07, 0x6b, 0x41, 0x14, 0xc5, 0x69, 0x90, 0x0e, 0xe2, 0x28, 0xe1, 0xe0, 0xe5, + 0x2b, 0xe2, 0xd7, 0xbd, 0x38, 0xea, 0x8f, 0x0e, 0xa2, 0x68, 0x10, 0xf5, 0xd7, 0xe2, 0x61, 0x38, + 0x9a, 0x62, 0x7a, 0x4b, 0x30, 0xb1, 0xdd, 0x93, 0x83, 0xdd, 0xb5, 0x74, 0xb0, 0x1f, 0x26, 0x69, + 0xb0, 0x3f, 0x14, 0x0c, 0x97, 0x04, 0xc3, 0x68, 0xd8, 0x5d, 0x4b, 0xd2, 0x20, 0x3d, 0x10, 0x48, + 0xe5, 0x6f, 0x12, 0xaa, 0xea, 0x71, 0xf7, 0x60, 0x3f, 0x8c, 0x52, 0xf9, 0x33, 0x54, 0x4a, 0x0f, + 0x87, 0x61, 0x5d, 0xba, 0x2c, 0xad, 0x2c, 0xad, 0xbf, 0xb7, 0xfa, 0x42, 0xbd, 0x57, 0x33, 0xd8, + 0xaa, 0x77, 0x38, 0x0c, 0x29, 0x43, 0xca, 0xcb, 0x68, 0xae, 0x1b, 0x47, 0x69, 0x18, 0xa5, 0xf5, + 0xc2, 0x65, 0x69, 0x65, 0x7e, 0xeb, 0x0c, 0xcd, 0x08, 0xf2, 0x0a, 0x3a, 0xdb, 0xef, 0x26, 0x1d, + 0xb1, 0xed, 0x1c, 0x8c, 0x06, 0xf5, 0xa2, 0xe0, 0x59, 0xec, 0x77, 0x13, 0x8d, 0xd3, 0xfd, 0xd1, + 0x40, 0x5e, 0x46, 0xd5, 0xec, 0xb4, 0x7a, 0x09, 0x58, 0xe8, 0x78, 0xaf, 0xdc, 0x46, 0x25, 0x38, + 0x4f, 0xbe, 0x80, 0xb0, 0xf7, 0xc8, 0x21, 0x1d, 0xdf, 0x72, 0x1d, 0xa2, 0x19, 0x0d, 0x83, 0xe8, + 0xf8, 0x8c, 0xbc, 0x84, 0x90, 0x63, 0xaa, 0x86, 0xd5, 0xf1, 0xc8, 0x8e, 0x87, 0x25, 0xb9, 0x8a, + 0x4a, 0x5b, 0x5e, 0xcb, 0xc4, 0x85, 0xcd, 0x2a, 0xaa, 0x24, 0xf1, 0xc1, 0xa8, 0x1b, 0x2a, 0x3f, + 0x93, 0x50, 0xd5, 0x0d, 0xe1, 0xb0, 0x6e, 0x28, 0xdf, 0x43, 0xa5, 0x34, 0x7c, 0x96, 0x32, 0x93, + 0x6b, 0xeb, 0xd7, 0x4e, 0x30, 0xd9, 0x0b, 0x9f, 0xa5, 0xee, 0x30, 0x88, 0x28, 0x03, 0xc9, 0x0d, + 0x34, 0x9f, 0x84, 0x11, 0xf8, 0x5a, 0xd8, 0x5b, 0x5b, 0x5f, 0x39, 0x41, 0x82, 0x9b, 0xf1, 0xd3, + 0x09, 0x54, 0xf9, 0xb6, 0x84, 0x2a, 0x24, 0x4a, 0x07, 0xe9, 0xa1, 0x2c, 0xa3, 0x52, 0x14, 0xec, + 0xf3, 0x10, 0xcc, 0x53, 0xb6, 0x96, 0x3f, 0x11, 0x61, 0x29, 0xb0, 0xb0, 0x5c, 0x3f, 0xe1, 0x04, + 0x2e, 0x28, 0x1f, 0x14, 0x1b, 0x55, 0xf7, 0xc3, 0x34, 0xe8, 0x05, 0x69, 0x50, 0x2f, 0x5e, 0x2e, + 0xae, 0xd4, 0xd6, 0x37, 0x4e, 0x27, 0xa3, 0x25, 0x50, 0x24, 0x4a, 0x47, 0x87, 0x74, 0x2c, 0x04, + 0xe2, 0x93, 0x04, 0x7b, 0x03, 0x70, 0x20, 0x8b, 0x4f, 0x81, 0x8e, 0xf7, 0xf2, 0x16, 0x1c, 0x16, + 0xb1, 0xe4, 0xac, 0x97, 0xd9, 0x61, 0xef, 0x9d, 0xea, 0xb0, 0x16, 0x07, 0xd1, 0x31, 0x7a, 0xda, + 0xbb, 0x95, 0x97, 0xf6, 0xee, 0xf2, 0x3d, 0xb4, 0x38, 0x65, 0x88, 0x8c, 0x51, 0xf1, 0xcb, 0xf0, + 0x50, 0xb8, 0x18, 0x96, 0xf2, 0x05, 0x54, 0x7e, 0x1a, 0xec, 0x1d, 0x70, 0x17, 0xcf, 0x53, 0xbe, + 0xb9, 0x5b, 0xb8, 0x23, 0x29, 0x87, 0x22, 0xdd, 0x6a, 0x68, 0xce, 0xb7, 0x1e, 0x58, 0xf6, 0x43, + 0x0b, 0x9f, 0x91, 0x11, 0xaa, 0x38, 0x84, 0xba, 0xb6, 0x85, 0x25, 0x79, 0x01, 0x55, 0x4d, 0x5b, + 0x53, 0x3d, 0xc3, 0xb6, 0x70, 0x41, 0xc6, 0x68, 0xc1, 0xa6, 0x4d, 0xd5, 0x32, 0x1e, 0x73, 0x4a, + 0x51, 0x9e, 0x47, 0x65, 0xd2, 0x26, 0x96, 0x87, 0x4b, 0xf2, 0x59, 0x54, 0x7b, 0x68, 0xd3, 0x07, + 0x1d, 0xbb, 0xd1, 0x51, 0xa9, 0x87, 0xcb, 0xf2, 0x39, 0xb4, 0xa8, 0xd9, 0x96, 0xeb, 0xb7, 0x08, + 0xed, 0x34, 0x6d, 0x5b, 0xc7, 0x15, 0x60, 0xb7, 0xbd, 0x2d, 0x42, 0xf1, 0x9c, 0xf2, 0xd3, 0x02, + 0x2a, 0x7b, 0xf1, 0x97, 0x61, 0xf4, 0xc3, 0x92, 0xf4, 0x73, 0xb4, 0x34, 0x0c, 0x46, 0x69, 0x27, + 0xde, 0xed, 0x24, 0xc3, 0x30, 0xec, 0x7e, 0x21, 0x32, 0xf5, 0xc6, 0x09, 0x62, 0x9c, 0x60, 0x94, + 0xda, 0xbb, 0x2e, 0x83, 0xd0, 0x85, 0x61, 0x6e, 0x27, 0xb7, 0xd1, 0xd9, 0x5e, 0x38, 0x0c, 0xa3, + 0x5e, 0x18, 0x75, 0x0f, 0x3b, 0x61, 0xaf, 0x1f, 0xb2, 0x9b, 0x5c, 0x5b, 0x7f, 0xff, 0xa4, 0x92, + 0x31, 0x46, 0x91, 0x5e, 0x3f, 0xa4, 0x4b, 0xbd, 0xa9, 0x3d, 0x84, 0x61, 0x2f, 0xdc, 0xdf, 0x0f, + 0xc4, 0xa5, 0xe7, 0x1b, 0xe5, 0x53, 0x34, 0x3f, 0x8e, 0xab, 0xfc, 0x3a, 0x9a, 0xdf, 0x0f, 0xfa, + 0xd1, 0x20, 0x3d, 0xe8, 0xf1, 0x68, 0x15, 0xe8, 0x84, 0x00, 0x02, 0x92, 0x6e, 0x3c, 0xe2, 0xea, + 0x14, 0x28, 0xdf, 0x28, 0xbf, 0x3f, 0x87, 0x16, 0xf2, 0xd6, 0xc8, 0x2a, 0x2a, 0xa6, 0x41, 0x5f, + 0x94, 0xb9, 0xb5, 0x19, 0xfc, 0xb0, 0xea, 0x05, 0x7d, 0x0a, 0x58, 0x79, 0x1b, 0x55, 0x82, 0x64, + 0x18, 0x76, 0x53, 0x71, 0x2b, 0xd7, 0x67, 0x91, 0xa2, 0x32, 0x24, 0x15, 0x12, 0x64, 0x1d, 0x95, + 0xba, 0x41, 0xc2, 0x95, 0x5e, 0x5a, 0xff, 0x60, 0x16, 0x49, 0x5a, 0x90, 0x84, 0x94, 0xa1, 0x41, + 0xca, 0x6e, 0x3c, 0xda, 0x67, 0xbe, 0x9b, 0x51, 0x4a, 0x23, 0x1e, 0xed, 0x53, 0x86, 0x06, 0xbb, + 0xfa, 0x10, 0x92, 0x51, 0xbd, 0x3c, 0xbb, 0x5d, 0x4d, 0x86, 0xa4, 0x42, 0x02, 0x68, 0xb4, 0x1f, + 0xc7, 0x3d, 0x76, 0x77, 0x67, 0xd4, 0xa8, 0x15, 0xc7, 0x3d, 0xca, 0xd0, 0xa0, 0x51, 0x74, 0xb0, + 0xff, 0x24, 0x1c, 0xd5, 0xe7, 0x66, 0xd7, 0xc8, 0x62, 0x48, 0x2a, 0x24, 0x80, 0xac, 0x61, 0x38, + 0x4a, 0xe2, 0xa8, 0x5e, 0x9d, 0x5d, 0x96, 0xc3, 0x90, 0x54, 0x48, 0x60, 0xb2, 0x46, 0xd0, 0x89, + 0xeb, 0xf3, 0x2f, 0x21, 0x8b, 0x21, 0xa9, 0x90, 0x20, 0x3f, 0x42, 0xb5, 0x51, 0xd8, 0x1d, 0x0c, + 0x47, 0x71, 0x77, 0x90, 0x1e, 0xd6, 0x11, 0x13, 0xf8, 0xd1, 0x2c, 0x02, 0xe9, 0x04, 0x4e, 0xf3, + 0xb2, 0xe4, 0x26, 0x2a, 0xa7, 0x61, 0x94, 0x84, 0xf5, 0x1a, 0x13, 0x7a, 0x73, 0xa6, 0x6c, 0x07, + 0x20, 0xe5, 0x78, 0x10, 0xf4, 0x34, 0x1e, 0x74, 0xc3, 0xfa, 0xc2, 0xec, 0x82, 0xda, 0x00, 0xa4, + 0x1c, 0xaf, 0x7c, 0x23, 0xa1, 0xa2, 0x17, 0xf4, 0xa7, 0x4b, 0xea, 0x1c, 0x2a, 0xaa, 0xfa, 0x36, + 0x96, 0xf8, 0xc2, 0xc1, 0x05, 0xbe, 0x68, 0xe3, 0x22, 0xf4, 0x70, 0xcd, 0xb6, 0xb6, 0x71, 0x09, + 0x48, 0x3a, 0x81, 0xc2, 0x59, 0x45, 0x25, 0xcb, 0xf6, 0x2d, 0x5c, 0x01, 0x92, 0xe5, 0xb7, 0xf0, + 0x1c, 0x90, 0x1c, 0x6a, 0x5b, 0xb8, 0x0a, 0x24, 0x87, 0x7a, 0x78, 0x1e, 0x6a, 0xa9, 0xe3, 0x5b, + 0x9a, 0x87, 0x11, 0xfc, 0xda, 0x26, 0x74, 0x13, 0xd7, 0xe4, 0x32, 0x92, 0x76, 0xf0, 0x02, 0xfc, + 0xa6, 0x36, 0x1a, 0xc6, 0x0e, 0x5e, 0x54, 0x6c, 0x54, 0xe1, 0x17, 0x52, 0x96, 0xd1, 0x92, 0x0a, + 0xd3, 0x84, 0xd7, 0x99, 0x28, 0x06, 0x13, 0x05, 0xa1, 0x0d, 0xa2, 0x79, 0x46, 0x9b, 0x60, 0x09, + 0x2a, 0xbc, 0xd1, 0xca, 0x51, 0x0a, 0x50, 0xd6, 0x1d, 0x6a, 0x37, 0x29, 0x71, 0x5d, 0x20, 0x14, + 0x95, 0x7f, 0x48, 0xa8, 0x04, 0x17, 0x13, 0x78, 0x35, 0xd5, 0x25, 0xd3, 0xd2, 0x54, 0x4d, 0xf3, + 0x5d, 0x55, 0x48, 0x5b, 0x44, 0xf3, 0xaa, 0x0e, 0x9a, 0x19, 0xaa, 0x89, 0x0b, 0xbc, 0x21, 0xb4, + 0x1c, 0x93, 0xb4, 0x88, 0xc5, 0x38, 0x8a, 0xd0, 0x6b, 0x74, 0xce, 0x5d, 0x82, 0x5e, 0xd3, 0x24, + 0x96, 0xc1, 0x76, 0x65, 0xa6, 0x89, 0xe5, 0x7a, 0xd4, 0x07, 0x66, 0xd5, 0xc4, 0x95, 0x49, 0x2f, + 0x6a, 0x13, 0x3c, 0x07, 0x67, 0x59, 0x76, 0xcb, 0xb0, 0xf8, 0xbe, 0x0a, 0xfe, 0xb6, 0x37, 0x4d, + 0xe3, 0x73, 0x9f, 0xe0, 0x79, 0x38, 0xd8, 0x51, 0xa9, 0xc7, 0x65, 0x21, 0x38, 0xd8, 0xa1, 0xc4, + 0xb1, 0x5d, 0x03, 0xda, 0x96, 0x6a, 0xe2, 0x1a, 0x38, 0x83, 0x92, 0x86, 0x49, 0x76, 0x8c, 0x36, + 0xe9, 0x80, 0x19, 0x78, 0x01, 0xd8, 0x28, 0x31, 0x99, 0x40, 0x4e, 0x5a, 0x84, 0x33, 0xdb, 0xd9, + 0x99, 0x4b, 0xca, 0x77, 0x12, 0x2a, 0x41, 0x35, 0x01, 0xe5, 0x1a, 0x36, 0x6d, 0xe5, 0x4c, 0x5f, + 0x40, 0x55, 0x55, 0x07, 0x85, 0x54, 0x53, 0x18, 0xee, 0xef, 0x18, 0xa6, 0xa1, 0xd2, 0x47, 0xb8, + 0x00, 0x87, 0xe5, 0x0c, 0x7f, 0x4c, 0x28, 0x2e, 0x32, 0x11, 0x86, 0xa5, 0x9a, 0x1d, 0x62, 0xe9, + 0x86, 0xd5, 0xc4, 0x25, 0xf0, 0x45, 0x93, 0x50, 0xdf, 0xd2, 0x71, 0x19, 0xd6, 0x94, 0xa8, 0xa6, + 0xe1, 0x72, 0xbb, 0x0d, 0x2a, 0x76, 0x73, 0x10, 0x5a, 0x77, 0xcb, 0xa6, 0x1e, 0xae, 0x42, 0xd8, + 0x4d, 0xdb, 0x6a, 0xf2, 0x5c, 0xb0, 0xa9, 0x4e, 0x28, 0x46, 0xc0, 0x2d, 0x46, 0x46, 0x0d, 0xd7, + 0x14, 0x82, 0x2a, 0xbc, 0x6c, 0x81, 0x0e, 0x4d, 0x62, 0xe9, 0x84, 0x4e, 0x2b, 0xdd, 0x20, 0x2d, + 0xc3, 0x32, 0x2c, 0x11, 0xad, 0x96, 0xea, 0x6a, 0xbe, 0x09, 0xdb, 0x02, 0xa8, 0x60, 0x11, 0xdf, + 0x03, 0x65, 0x95, 0xaf, 0x50, 0x09, 0x6a, 0x16, 0x28, 0xdd, 0xb2, 0x6d, 0x3d, 0x27, 0xe2, 0x02, + 0xc2, 0x9a, 0x6d, 0xe9, 0xc2, 0xb1, 0x1d, 0xf8, 0x15, 0x4b, 0x10, 0x1c, 0x96, 0x46, 0xaa, 0x48, + 0x22, 0xd8, 0x5b, 0xba, 0x21, 0x1c, 0x59, 0x04, 0x4f, 0x1b, 0x96, 0x47, 0x28, 0xb5, 0x9b, 0x59, + 0xf4, 0x6b, 0x68, 0x6e, 0xdb, 0xe7, 0x39, 0x56, 0x86, 0xa4, 0x73, 0xfd, 0xcd, 0x6d, 0x48, 0x6f, + 0x20, 0x54, 0x94, 0xcf, 0x50, 0x85, 0x17, 0x3b, 0xb0, 0xc3, 0xf2, 0x5b, 0x9b, 0x47, 0xed, 0x70, + 0x0d, 0xab, 0xe9, 0x9b, 0x2a, 0xc5, 0x12, 0x9b, 0x5f, 0x4c, 0x9f, 0xb2, 0x94, 0xab, 0xa2, 0x92, + 0xee, 0xab, 0x26, 0x2e, 0x2a, 0x1e, 0xaa, 0xf0, 0x12, 0x07, 0x12, 0xf8, 0x7c, 0x93, 0x93, 0x30, + 0x8f, 0xca, 0x0d, 0x83, 0xba, 0x1e, 0x87, 0xbb, 0x04, 0x6c, 0xc2, 0x05, 0x20, 0x7b, 0x5b, 0x06, + 0xd5, 0x71, 0x11, 0x0c, 0x9d, 0x24, 0x8c, 0x98, 0x8f, 0x4a, 0xca, 0x1d, 0x54, 0xe1, 0xc5, 0x8e, + 0x49, 0xa5, 0xb6, 0x33, 0xa5, 0x17, 0x68, 0xc2, 0x68, 0xdc, 0x25, 0x96, 0xed, 0x75, 0xc4, 0xbe, + 0xa0, 0x6c, 0xa3, 0x5a, 0xae, 0xaa, 0xc9, 0x97, 0xd0, 0x79, 0x4a, 0x34, 0xc3, 0xa1, 0xb6, 0x66, + 0x78, 0x8f, 0xa6, 0xef, 0x54, 0xf6, 0x03, 0x4b, 0x2d, 0xb0, 0xdf, 0xb6, 0x3a, 0x39, 0x5a, 0x41, + 0x49, 0x50, 0x99, 0x15, 0x33, 0xf0, 0xab, 0x47, 0xac, 0xa9, 0x3b, 0xf9, 0x1a, 0x3a, 0x97, 0x0f, + 0x10, 0xfb, 0x99, 0x5b, 0xd9, 0xf0, 0x3d, 0x9f, 0x12, 0xee, 0x24, 0x47, 0x75, 0x3d, 0x5c, 0x84, + 0x20, 0x38, 0x94, 0xb8, 0x7c, 0xa0, 0x5b, 0x44, 0xf3, 0xe3, 0x5a, 0x80, 0xcb, 0xfc, 0xe3, 0xc3, + 0xcf, 0xf6, 0x15, 0x65, 0x13, 0x95, 0x59, 0xe1, 0x83, 0x43, 0xdb, 0xb6, 0xa1, 0x91, 0x69, 0xc3, + 0x55, 0x6d, 0x52, 0x04, 0x34, 0x35, 0xab, 0x09, 0x05, 0x76, 0x84, 0x9a, 0xd5, 0x92, 0xbf, 0xcf, + 0xa1, 0xa5, 0xe9, 0xa9, 0x49, 0x5e, 0x41, 0xf8, 0x8b, 0x30, 0xe8, 0x75, 0x52, 0x98, 0x0d, 0x3b, + 0x83, 0xa8, 0x17, 0x3e, 0x63, 0xa3, 0x4c, 0x99, 0x2e, 0x01, 0x9d, 0x8d, 0x8c, 0x06, 0x50, 0x65, + 0x03, 0x95, 0xf7, 0x82, 0x27, 0xe1, 0x9e, 0x98, 0x51, 0x36, 0x66, 0x9a, 0xce, 0x56, 0x4d, 0x80, + 0x52, 0x2e, 0x41, 0xf9, 0x6b, 0x05, 0x95, 0x19, 0xe1, 0xb9, 0x49, 0x58, 0xdd, 0xdc, 0xa4, 0xa4, + 0x8d, 0x25, 0x56, 0x52, 0xe1, 0x12, 0xf3, 0xac, 0x50, 0xf5, 0xb6, 0x66, 0xf2, 0xfa, 0xa5, 0xea, + 0xed, 0x96, 0xad, 0xe3, 0x12, 0xb8, 0x51, 0x85, 0x55, 0x99, 0x31, 0x38, 0x8e, 0x0d, 0x97, 0x17, + 0x88, 0x9e, 0x47, 0xf1, 0x1c, 0xab, 0xf8, 0xfe, 0x0e, 0xaf, 0x54, 0xaa, 0xbf, 0x03, 0x4e, 0xc0, + 0xf3, 0x72, 0x05, 0x15, 0x34, 0x0d, 0x23, 0x80, 0x68, 0x4c, 0x7c, 0x6d, 0xdc, 0x11, 0x58, 0x19, + 0xd7, 0xe0, 0x1e, 0xe0, 0x45, 0xe6, 0x45, 0x58, 0x32, 0xd8, 0x12, 0xef, 0x15, 0x0e, 0x3e, 0x9b, + 0x35, 0x0d, 0x0c, 0x0c, 0xba, 0xe1, 0x6a, 0xb6, 0x4f, 0x5d, 0x82, 0xcf, 0xb1, 0xc4, 0xb7, 0x37, + 0xb7, 0xb1, 0x0c, 0x2b, 0xb2, 0xe3, 0x98, 0xf8, 0x3c, 0x2b, 0xb0, 0x36, 0x71, 0x1f, 0x1a, 0xde, + 0x16, 0xbe, 0x00, 0x74, 0x03, 0x38, 0x5e, 0x83, 0x55, 0x4b, 0xa5, 0x0f, 0xf0, 0x45, 0x90, 0xd6, + 0x7a, 0x48, 0xf0, 0x25, 0xbe, 0x68, 0xe3, 0x3a, 0xeb, 0x40, 0xa4, 0x89, 0xff, 0x0b, 0x14, 0xb5, + 0x2c, 0xbc, 0x0c, 0x42, 0x2c, 0x47, 0xd8, 0xfc, 0xdf, 0xa0, 0xa1, 0xc5, 0x34, 0x7c, 0x1d, 0x14, + 0xb0, 0xc6, 0x1a, 0xbe, 0x91, 0xb5, 0xae, 0x37, 0x59, 0x1d, 0x61, 0x17, 0x16, 0xbf, 0x05, 0xed, + 0xc9, 0xc1, 0x97, 0x45, 0x79, 0x56, 0x3d, 0x75, 0xc7, 0x70, 0xf1, 0xdb, 0x3c, 0x25, 0xa8, 0x07, + 0x12, 0x15, 0xd6, 0xd6, 0x98, 0x23, 0xae, 0xb0, 0xbc, 0x04, 0x0d, 0xdf, 0xe1, 0x2b, 0xd7, 0xc5, + 0x57, 0x19, 0xaf, 0xed, 0x7a, 0xa0, 0xd3, 0xff, 0x88, 0x74, 0x65, 0xdc, 0xd7, 0xc6, 0x1b, 0x6b, + 0x1b, 0xaf, 0xf0, 0x9b, 0x47, 0xc0, 0x33, 0xef, 0xf2, 0xde, 0x49, 0x1a, 0xf8, 0xba, 0x58, 0x39, + 0xf8, 0x06, 0x3b, 0x85, 0xda, 0x96, 0x89, 0xdf, 0xcb, 0x1a, 0xea, 0xfb, 0x60, 0xa1, 0xe3, 0xe2, + 0x55, 0xb0, 0xf0, 0x73, 0x5f, 0xb5, 0x98, 0x3e, 0x6b, 0xc0, 0x49, 0x35, 0x58, 0x7e, 0x00, 0x3f, + 0xb0, 0x25, 0x25, 0x26, 0xbe, 0xc9, 0x7e, 0xd0, 0xa9, 0xed, 0xe0, 0x75, 0x10, 0x01, 0x07, 0x6c, + 0x80, 0x0e, 0x94, 0xb4, 0x2c, 0xd5, 0xf2, 0xf0, 0x2d, 0x7e, 0x73, 0xc1, 0x4e, 0x4b, 0xf7, 0x5b, + 0xf8, 0x43, 0x38, 0x9d, 0xda, 0xb6, 0x87, 0x6f, 0xc3, 0xca, 0x05, 0xe7, 0x7c, 0xc4, 0x56, 0x7e, + 0xa3, 0x81, 0xef, 0xc0, 0x8a, 0x9d, 0xf8, 0xbf, 0xac, 0xe8, 0xd8, 0x8e, 0xa1, 0xe1, 0xbb, 0xac, + 0xb1, 0x03, 0xf1, 0xde, 0x54, 0x23, 0xba, 0x0f, 0x2c, 0x3b, 0xcc, 0xec, 0x8f, 0x59, 0xb9, 0xf2, + 0x59, 0xaf, 0xff, 0x84, 0x21, 0x0d, 0xcf, 0x24, 0xf8, 0x53, 0xde, 0x8f, 0xda, 0xce, 0x16, 0xa0, + 0x3f, 0x13, 0x29, 0x07, 0xd7, 0x10, 0xab, 0x2c, 0x3b, 0xfd, 0x9d, 0x76, 0x1b, 0x6f, 0xc2, 0x52, + 0x67, 0xa7, 0x6a, 0xc0, 0xd2, 0xb0, 0x29, 0x31, 0x9a, 0x16, 0xd6, 0xc1, 0x15, 0x0f, 0x1e, 0x62, + 0xc2, 0x3a, 0x8c, 0xe1, 0x7a, 0xb8, 0xc1, 0x67, 0x92, 0x96, 0x86, 0x9b, 0x2c, 0x01, 0xec, 0x16, + 0xcf, 0xcb, 0x2d, 0xe8, 0x08, 0xd9, 0x8e, 0x05, 0xde, 0x60, 0x9c, 0x7e, 0x4b, 0xc3, 0xdb, 0xe0, + 0x16, 0xcd, 0x76, 0xf0, 0x03, 0xf0, 0x84, 0x6e, 0xb8, 0xac, 0x79, 0x13, 0x1d, 0x9b, 0xca, 0x37, + 0x05, 0xb4, 0x38, 0xf5, 0x5d, 0xfc, 0xc3, 0xbe, 0x01, 0xc9, 0xd4, 0x0b, 0xc2, 0xcd, 0x59, 0x3e, + 0xc8, 0xf3, 0x0f, 0x09, 0x53, 0x5f, 0xe4, 0xc5, 0x97, 0x7f, 0xef, 0xf8, 0x40, 0x7c, 0x54, 0x63, + 0xb4, 0x20, 0xde, 0x70, 0x8e, 0xeb, 0x07, 0x08, 0x55, 0x34, 0xbb, 0xd5, 0x82, 0xef, 0x6a, 0xa5, + 0x89, 0xaa, 0x99, 0x49, 0x72, 0x7d, 0xf2, 0xc6, 0xc4, 0x3f, 0xe1, 0xc7, 0x2f, 0x4c, 0x6f, 0xa3, + 0x85, 0x27, 0x61, 0x7f, 0x10, 0x75, 0xe2, 0xdd, 0xdd, 0x24, 0xe4, 0x9f, 0x66, 0x65, 0x5a, 0x63, + 0x34, 0x9b, 0x91, 0x14, 0x13, 0x5d, 0xd4, 0xf6, 0x82, 0x24, 0x19, 0xec, 0x0e, 0xba, 0xec, 0x09, + 0x4d, 0x0b, 0xd2, 0xb0, 0x1f, 0x8f, 0x8e, 0x7f, 0x79, 0x79, 0x13, 0xa1, 0x6e, 0x1c, 0xed, 0x0e, + 0x7a, 0xec, 0xa9, 0x83, 0x7f, 0x6e, 0xe6, 0x28, 0xca, 0xaf, 0x25, 0x74, 0x49, 0x8d, 0x82, 0xbd, + 0xc3, 0xff, 0x0f, 0x27, 0x86, 0x86, 0xff, 0x77, 0x10, 0x26, 0xa9, 0xac, 0xa1, 0x6a, 0x4f, 0xbc, + 0x90, 0x9d, 0x32, 0x68, 0xd9, 0x83, 0x1a, 0x1d, 0x03, 0x65, 0x07, 0x2d, 0x86, 0x51, 0x37, 0xee, + 0x0d, 0xa2, 0x7e, 0x27, 0x17, 0xc1, 0x1b, 0x27, 0x46, 0x90, 0x63, 0x58, 0xec, 0x16, 0xc2, 0xdc, + 0x4e, 0xf9, 0xb3, 0x84, 0xea, 0xcf, 0xab, 0x9c, 0x0c, 0x63, 0xe8, 0x8e, 0x0f, 0x91, 0x9c, 0x1d, + 0xdd, 0x99, 0x44, 0x5a, 0x9a, 0x31, 0xd2, 0xe7, 0x32, 0x19, 0x93, 0xcf, 0xf6, 0xfc, 0x8b, 0x5e, + 0x61, 0xfa, 0x45, 0x4f, 0x26, 0x3c, 0xab, 0xc0, 0xa1, 0x89, 0x78, 0x9f, 0xba, 0x76, 0x8a, 0xb3, + 0x80, 0x9f, 0x4e, 0x90, 0xca, 0x6f, 0x25, 0xf4, 0x86, 0x30, 0x8c, 0x27, 0xf0, 0x7f, 0x4a, 0x44, + 0xbe, 0x42, 0x6f, 0x7e, 0x9f, 0xde, 0x22, 0x2c, 0x2a, 0xaa, 0x02, 0x2d, 0x1d, 0x84, 0x49, 0x5d, + 0x62, 0x0e, 0xba, 0x7a, 0xaa, 0x2b, 0x4c, 0xc7, 0xb0, 0x17, 0x05, 0x00, 0x86, 0xf6, 0x8b, 0x79, + 0x0d, 0x06, 0x61, 0xf2, 0x23, 0x77, 0xd9, 0xb3, 0xf1, 0xb5, 0x9b, 0x28, 0xfc, 0xef, 0xf1, 0xd5, + 0xaf, 0x24, 0x74, 0x21, 0xbb, 0x3e, 0x87, 0x51, 0x1a, 0x3c, 0xfb, 0x91, 0x7b, 0xea, 0x77, 0x12, + 0x7a, 0xed, 0x88, 0xbe, 0xc2, 0x51, 0x53, 0xd7, 0x4e, 0x7a, 0xd9, 0x6b, 0x27, 0xdf, 0x47, 0x15, + 0x36, 0x88, 0x26, 0xf5, 0x02, 0x93, 0xf1, 0xce, 0x49, 0x9d, 0x09, 0x98, 0xa9, 0xc0, 0x4c, 0xb9, + 0xba, 0x78, 0xc4, 0xd5, 0x8f, 0xd1, 0x79, 0x51, 0xaa, 0x0f, 0xa1, 0xf6, 0xbf, 0x4a, 0x47, 0x2b, + 0xfb, 0xe8, 0xc2, 0xb4, 0x6c, 0xe1, 0x14, 0x1f, 0xa1, 0x2e, 0x6f, 0x08, 0x93, 0xfc, 0xf9, 0xf0, + 0x04, 0xf1, 0xc7, 0xf7, 0x13, 0x9a, 0x13, 0xa4, 0xfc, 0xa4, 0x84, 0xce, 0xab, 0xfc, 0x4f, 0x3b, + 0xe1, 0xab, 0xb6, 0x45, 0x7e, 0x88, 0xaa, 0xbb, 0x61, 0x90, 0x1e, 0x8c, 0xc2, 0x44, 0x3c, 0xed, + 0xde, 0x3b, 0x41, 0xc8, 0x31, 0xaa, 0xac, 0x36, 0x84, 0x08, 0x3a, 0x16, 0xf6, 0x7c, 0x36, 0x16, + 0x7f, 0x60, 0x36, 0x2e, 0xff, 0x53, 0x42, 0xd5, 0xec, 0x20, 0xf9, 0x2a, 0x5a, 0x0a, 0x9f, 0xa5, + 0xa3, 0xa0, 0x9b, 0x76, 0x12, 0x96, 0x9a, 0xcc, 0x05, 0x55, 0xba, 0x28, 0xa8, 0x3c, 0x5f, 0xe5, + 0x77, 0x11, 0xce, 0xd8, 0xc6, 0x17, 0xbb, 0xc0, 0x18, 0xcf, 0x0a, 0x7a, 0x56, 0x03, 0xe4, 0xfb, + 0x68, 0x39, 0x63, 0x3d, 0xa6, 0x8d, 0x15, 0x19, 0xa8, 0x2e, 0x38, 0xf4, 0xe7, 0x7a, 0xd4, 0x1d, + 0x54, 0x9f, 0x3a, 0xe8, 0x30, 0x87, 0x2d, 0x31, 0xec, 0xc5, 0xfc, 0x81, 0x93, 0x3a, 0x2d, 0x5f, + 0x41, 0x8b, 0x5d, 0x91, 0x4d, 0x1d, 0x36, 0xa4, 0x55, 0x18, 0xfb, 0x42, 0x37, 0x97, 0x62, 0xca, + 0x2f, 0x8b, 0x50, 0x39, 0xf2, 0x8e, 0xff, 0x31, 0x5d, 0xc4, 0x7c, 0xd9, 0x2c, 0xbe, 0x5c, 0xd9, + 0x3c, 0x7e, 0x78, 0x28, 0xbd, 0xda, 0xe1, 0xa1, 0x7c, 0x64, 0x78, 0x98, 0xbe, 0xb0, 0x95, 0x57, + 0x74, 0x61, 0xaf, 0xdf, 0x41, 0x0b, 0xf9, 0x34, 0xe6, 0xc3, 0xbd, 0x45, 0xf0, 0x19, 0x58, 0xf9, + 0x5e, 0xe3, 0x0e, 0xff, 0xde, 0xf5, 0xbd, 0xc6, 0xcd, 0xdb, 0xfc, 0x7b, 0xd7, 0xf7, 0x1a, 0x1b, + 0xeb, 0xb8, 0xb8, 0xfe, 0x87, 0x2a, 0x3a, 0x6b, 0x8a, 0x13, 0x5d, 0xfe, 0x67, 0x60, 0xf9, 0x37, + 0x12, 0xc2, 0x47, 0x67, 0x2e, 0xf9, 0xf6, 0x89, 0x97, 0xf4, 0xd8, 0xb9, 0x72, 0xf9, 0xa3, 0x99, + 0x71, 0x3c, 0xcf, 0x94, 0xd5, 0xaf, 0xff, 0xf4, 0x97, 0x6f, 0x0b, 0x2b, 0xca, 0x95, 0xf1, 0xdf, + 0xab, 0x33, 0x57, 0x27, 0x77, 0x83, 0x23, 0xa0, 0xbb, 0xd2, 0x75, 0xf9, 0x3b, 0x09, 0x9d, 0x3d, + 0xd2, 0x65, 0xe5, 0x0f, 0x4f, 0x77, 0xf8, 0x91, 0x31, 0x62, 0xf9, 0xf6, 0xac, 0x30, 0xa1, 0xf2, + 0xfb, 0x4c, 0xe5, 0x6b, 0x8a, 0xf2, 0xfd, 0x2a, 0x67, 0x18, 0xd0, 0xf8, 0x8f, 0x47, 0x06, 0x99, + 0xdc, 0x15, 0xbd, 0x3f, 0x83, 0x06, 0xcf, 0x4d, 0x8e, 0xcb, 0x1f, 0xbf, 0x24, 0x5a, 0x98, 0x71, + 0x8b, 0x99, 0xb1, 0xaa, 0xbc, 0x7b, 0x82, 0x19, 0x87, 0x53, 0xfe, 0xff, 0x85, 0x84, 0x16, 0xa7, + 0x5a, 0xb7, 0xbc, 0x71, 0xca, 0xd0, 0xe7, 0x07, 0x93, 0xe5, 0x5b, 0xb3, 0x81, 0x84, 0xca, 0x37, + 0x98, 0xca, 0x57, 0x95, 0xcb, 0x2f, 0x48, 0x16, 0x86, 0x00, 0x4d, 0x7f, 0x2e, 0xa1, 0x85, 0x7c, + 0x3b, 0x95, 0xd7, 0x4f, 0x77, 0x03, 0xf3, 0x7d, 0x7d, 0x79, 0x63, 0x26, 0x8c, 0x50, 0xf3, 0x3a, + 0x53, 0xf3, 0x1d, 0xe5, 0xad, 0x63, 0xd4, 0xcc, 0x57, 0xdf, 0x4c, 0xcb, 0x7c, 0x01, 0x3e, 0x51, + 0xcb, 0x63, 0xda, 0xe4, 0xf2, 0xc6, 0x4c, 0x98, 0x53, 0x68, 0x19, 0xe4, 0x00, 0x77, 0xa5, 0xeb, + 0x9b, 0x5f, 0x4b, 0xe8, 0xed, 0x6e, 0xbc, 0xff, 0xe2, 0x63, 0x36, 0x2f, 0x1c, 0x29, 0x31, 0xce, + 0x28, 0x4e, 0x63, 0x47, 0x7a, 0x4c, 0x04, 0xac, 0x1f, 0x03, 0x64, 0x35, 0x1e, 0xf5, 0xd7, 0xfa, + 0x61, 0xc4, 0xfe, 0xd5, 0x63, 0x8d, 0xff, 0x14, 0x0c, 0x07, 0xc9, 0xf7, 0xfc, 0xff, 0xca, 0xbd, + 0x8c, 0xf0, 0xa4, 0xc2, 0x10, 0x1b, 0xff, 0x0a, 0x00, 0x00, 0xff, 0xff, 0x72, 0x26, 0xce, 0x5b, + 0xf0, 0x22, 0x00, 0x00, } diff --git a/vendor/google.golang.org/genproto/googleapis/cloud/videointelligence/v1beta2/video_intelligence.pb.go b/vendor/google.golang.org/genproto/googleapis/cloud/videointelligence/v1beta2/video_intelligence.pb.go new file mode 100644 index 00000000..fdace134 --- /dev/null +++ b/vendor/google.golang.org/genproto/googleapis/cloud/videointelligence/v1beta2/video_intelligence.pb.go @@ -0,0 +1,1157 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: google/cloud/videointelligence/v1beta2/video_intelligence.proto + +/* +Package videointelligence is a generated protocol buffer package. + +It is generated from these files: + google/cloud/videointelligence/v1beta2/video_intelligence.proto + +It has these top-level messages: + AnnotateVideoRequest + VideoContext + LabelDetectionConfig + ShotChangeDetectionConfig + ExplicitContentDetectionConfig + FaceDetectionConfig + VideoSegment + LabelSegment + LabelFrame + Entity + LabelAnnotation + ExplicitContentFrame + ExplicitContentAnnotation + NormalizedBoundingBox + FaceSegment + FaceFrame + FaceAnnotation + VideoAnnotationResults + AnnotateVideoResponse + VideoAnnotationProgress + AnnotateVideoProgress +*/ +package videointelligence + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import _ "google.golang.org/genproto/googleapis/api/annotations" +import google_longrunning "google.golang.org/genproto/googleapis/longrunning" +import google_protobuf3 "github.com/golang/protobuf/ptypes/duration" +import google_protobuf4 "github.com/golang/protobuf/ptypes/timestamp" +import google_rpc "google.golang.org/genproto/googleapis/rpc/status" + +import ( + context "golang.org/x/net/context" + grpc "google.golang.org/grpc" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +// Video annotation feature. +type Feature int32 + +const ( + // Unspecified. + Feature_FEATURE_UNSPECIFIED Feature = 0 + // Label detection. Detect objects, such as dog or flower. + Feature_LABEL_DETECTION Feature = 1 + // Shot change detection. + Feature_SHOT_CHANGE_DETECTION Feature = 2 + // Explicit content detection. + Feature_EXPLICIT_CONTENT_DETECTION Feature = 3 + // Human face detection and tracking. + Feature_FACE_DETECTION Feature = 4 +) + +var Feature_name = map[int32]string{ + 0: "FEATURE_UNSPECIFIED", + 1: "LABEL_DETECTION", + 2: "SHOT_CHANGE_DETECTION", + 3: "EXPLICIT_CONTENT_DETECTION", + 4: "FACE_DETECTION", +} +var Feature_value = map[string]int32{ + "FEATURE_UNSPECIFIED": 0, + "LABEL_DETECTION": 1, + "SHOT_CHANGE_DETECTION": 2, + "EXPLICIT_CONTENT_DETECTION": 3, + "FACE_DETECTION": 4, +} + +func (x Feature) String() string { + return proto.EnumName(Feature_name, int32(x)) +} +func (Feature) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } + +// Label detection mode. +type LabelDetectionMode int32 + +const ( + // Unspecified. + LabelDetectionMode_LABEL_DETECTION_MODE_UNSPECIFIED LabelDetectionMode = 0 + // Detect shot-level labels. + LabelDetectionMode_SHOT_MODE LabelDetectionMode = 1 + // Detect frame-level labels. + LabelDetectionMode_FRAME_MODE LabelDetectionMode = 2 + // Detect both shot-level and frame-level labels. + LabelDetectionMode_SHOT_AND_FRAME_MODE LabelDetectionMode = 3 +) + +var LabelDetectionMode_name = map[int32]string{ + 0: "LABEL_DETECTION_MODE_UNSPECIFIED", + 1: "SHOT_MODE", + 2: "FRAME_MODE", + 3: "SHOT_AND_FRAME_MODE", +} +var LabelDetectionMode_value = map[string]int32{ + "LABEL_DETECTION_MODE_UNSPECIFIED": 0, + "SHOT_MODE": 1, + "FRAME_MODE": 2, + "SHOT_AND_FRAME_MODE": 3, +} + +func (x LabelDetectionMode) String() string { + return proto.EnumName(LabelDetectionMode_name, int32(x)) +} +func (LabelDetectionMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } + +// Bucketized representation of likelihood. +type Likelihood int32 + +const ( + // Unspecified likelihood. + Likelihood_LIKELIHOOD_UNSPECIFIED Likelihood = 0 + // Very unlikely. + Likelihood_VERY_UNLIKELY Likelihood = 1 + // Unlikely. + Likelihood_UNLIKELY Likelihood = 2 + // Possible. + Likelihood_POSSIBLE Likelihood = 3 + // Likely. + Likelihood_LIKELY Likelihood = 4 + // Very likely. + Likelihood_VERY_LIKELY Likelihood = 5 +) + +var Likelihood_name = map[int32]string{ + 0: "LIKELIHOOD_UNSPECIFIED", + 1: "VERY_UNLIKELY", + 2: "UNLIKELY", + 3: "POSSIBLE", + 4: "LIKELY", + 5: "VERY_LIKELY", +} +var Likelihood_value = map[string]int32{ + "LIKELIHOOD_UNSPECIFIED": 0, + "VERY_UNLIKELY": 1, + "UNLIKELY": 2, + "POSSIBLE": 3, + "LIKELY": 4, + "VERY_LIKELY": 5, +} + +func (x Likelihood) String() string { + return proto.EnumName(Likelihood_name, int32(x)) +} +func (Likelihood) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } + +// Video annotation request. +type AnnotateVideoRequest struct { + // Input video location. Currently, only + // [Google Cloud Storage](https://cloud.google.com/storage/) URIs are + // supported, which must be specified in the following format: + // `gs://bucket-id/object-id` (other URI formats return + // [google.rpc.Code.INVALID_ARGUMENT][google.rpc.Code.INVALID_ARGUMENT]). For more information, see + // [Request URIs](/storage/docs/reference-uris). + // A video URI may include wildcards in `object-id`, and thus identify + // multiple videos. Supported wildcards: '*' to match 0 or more characters; + // '?' to match 1 character. If unset, the input video should be embedded + // in the request as `input_content`. If set, `input_content` should be unset. + InputUri string `protobuf:"bytes,1,opt,name=input_uri,json=inputUri" json:"input_uri,omitempty"` + // The video data bytes. Encoding: base64. If unset, the input video(s) + // should be specified via `input_uri`. If set, `input_uri` should be unset. + InputContent []byte `protobuf:"bytes,6,opt,name=input_content,json=inputContent,proto3" json:"input_content,omitempty"` + // Requested video annotation features. + Features []Feature `protobuf:"varint,2,rep,packed,name=features,enum=google.cloud.videointelligence.v1beta2.Feature" json:"features,omitempty"` + // Additional video context and/or feature-specific parameters. + VideoContext *VideoContext `protobuf:"bytes,3,opt,name=video_context,json=videoContext" json:"video_context,omitempty"` + // Optional location where the output (in JSON format) should be stored. + // Currently, only [Google Cloud Storage](https://cloud.google.com/storage/) + // URIs are supported, which must be specified in the following format: + // `gs://bucket-id/object-id` (other URI formats return + // [google.rpc.Code.INVALID_ARGUMENT][google.rpc.Code.INVALID_ARGUMENT]). For more information, see + // [Request URIs](/storage/docs/reference-uris). + OutputUri string `protobuf:"bytes,4,opt,name=output_uri,json=outputUri" json:"output_uri,omitempty"` + // Optional cloud region where annotation should take place. Supported cloud + // regions: `us-east1`, `us-west1`, `europe-west1`, `asia-east1`. If no region + // is specified, a region will be determined based on video file location. + LocationId string `protobuf:"bytes,5,opt,name=location_id,json=locationId" json:"location_id,omitempty"` +} + +func (m *AnnotateVideoRequest) Reset() { *m = AnnotateVideoRequest{} } +func (m *AnnotateVideoRequest) String() string { return proto.CompactTextString(m) } +func (*AnnotateVideoRequest) ProtoMessage() {} +func (*AnnotateVideoRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } + +func (m *AnnotateVideoRequest) GetInputUri() string { + if m != nil { + return m.InputUri + } + return "" +} + +func (m *AnnotateVideoRequest) GetInputContent() []byte { + if m != nil { + return m.InputContent + } + return nil +} + +func (m *AnnotateVideoRequest) GetFeatures() []Feature { + if m != nil { + return m.Features + } + return nil +} + +func (m *AnnotateVideoRequest) GetVideoContext() *VideoContext { + if m != nil { + return m.VideoContext + } + return nil +} + +func (m *AnnotateVideoRequest) GetOutputUri() string { + if m != nil { + return m.OutputUri + } + return "" +} + +func (m *AnnotateVideoRequest) GetLocationId() string { + if m != nil { + return m.LocationId + } + return "" +} + +// Video context and/or feature-specific parameters. +type VideoContext struct { + // Video segments to annotate. The segments may overlap and are not required + // to be contiguous or span the whole video. If unspecified, each video + // is treated as a single segment. + Segments []*VideoSegment `protobuf:"bytes,1,rep,name=segments" json:"segments,omitempty"` + // Config for LABEL_DETECTION. + LabelDetectionConfig *LabelDetectionConfig `protobuf:"bytes,2,opt,name=label_detection_config,json=labelDetectionConfig" json:"label_detection_config,omitempty"` + // Config for SHOT_CHANGE_DETECTION. + ShotChangeDetectionConfig *ShotChangeDetectionConfig `protobuf:"bytes,3,opt,name=shot_change_detection_config,json=shotChangeDetectionConfig" json:"shot_change_detection_config,omitempty"` + // Config for EXPLICIT_CONTENT_DETECTION. + ExplicitContentDetectionConfig *ExplicitContentDetectionConfig `protobuf:"bytes,4,opt,name=explicit_content_detection_config,json=explicitContentDetectionConfig" json:"explicit_content_detection_config,omitempty"` + // Config for FACE_DETECTION. + FaceDetectionConfig *FaceDetectionConfig `protobuf:"bytes,5,opt,name=face_detection_config,json=faceDetectionConfig" json:"face_detection_config,omitempty"` +} + +func (m *VideoContext) Reset() { *m = VideoContext{} } +func (m *VideoContext) String() string { return proto.CompactTextString(m) } +func (*VideoContext) ProtoMessage() {} +func (*VideoContext) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } + +func (m *VideoContext) GetSegments() []*VideoSegment { + if m != nil { + return m.Segments + } + return nil +} + +func (m *VideoContext) GetLabelDetectionConfig() *LabelDetectionConfig { + if m != nil { + return m.LabelDetectionConfig + } + return nil +} + +func (m *VideoContext) GetShotChangeDetectionConfig() *ShotChangeDetectionConfig { + if m != nil { + return m.ShotChangeDetectionConfig + } + return nil +} + +func (m *VideoContext) GetExplicitContentDetectionConfig() *ExplicitContentDetectionConfig { + if m != nil { + return m.ExplicitContentDetectionConfig + } + return nil +} + +func (m *VideoContext) GetFaceDetectionConfig() *FaceDetectionConfig { + if m != nil { + return m.FaceDetectionConfig + } + return nil +} + +// Config for LABEL_DETECTION. +type LabelDetectionConfig struct { + // What labels should be detected with LABEL_DETECTION, in addition to + // video-level labels or segment-level labels. + // If unspecified, defaults to `SHOT_MODE`. + LabelDetectionMode LabelDetectionMode `protobuf:"varint,1,opt,name=label_detection_mode,json=labelDetectionMode,enum=google.cloud.videointelligence.v1beta2.LabelDetectionMode" json:"label_detection_mode,omitempty"` + // Whether the video has been shot from a stationary (i.e. non-moving) camera. + // When set to true, might improve detection accuracy for moving objects. + // Should be used with `SHOT_AND_FRAME_MODE` enabled. + StationaryCamera bool `protobuf:"varint,2,opt,name=stationary_camera,json=stationaryCamera" json:"stationary_camera,omitempty"` + // Model to use for label detection. + // Supported values: "builtin/stable" (the default if unset) and + // "builtin/latest". + Model string `protobuf:"bytes,3,opt,name=model" json:"model,omitempty"` +} + +func (m *LabelDetectionConfig) Reset() { *m = LabelDetectionConfig{} } +func (m *LabelDetectionConfig) String() string { return proto.CompactTextString(m) } +func (*LabelDetectionConfig) ProtoMessage() {} +func (*LabelDetectionConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } + +func (m *LabelDetectionConfig) GetLabelDetectionMode() LabelDetectionMode { + if m != nil { + return m.LabelDetectionMode + } + return LabelDetectionMode_LABEL_DETECTION_MODE_UNSPECIFIED +} + +func (m *LabelDetectionConfig) GetStationaryCamera() bool { + if m != nil { + return m.StationaryCamera + } + return false +} + +func (m *LabelDetectionConfig) GetModel() string { + if m != nil { + return m.Model + } + return "" +} + +// Config for SHOT_CHANGE_DETECTION. +type ShotChangeDetectionConfig struct { + // Model to use for shot change detection. + // Supported values: "builtin/stable" (the default if unset) and + // "builtin/latest". + Model string `protobuf:"bytes,1,opt,name=model" json:"model,omitempty"` +} + +func (m *ShotChangeDetectionConfig) Reset() { *m = ShotChangeDetectionConfig{} } +func (m *ShotChangeDetectionConfig) String() string { return proto.CompactTextString(m) } +func (*ShotChangeDetectionConfig) ProtoMessage() {} +func (*ShotChangeDetectionConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } + +func (m *ShotChangeDetectionConfig) GetModel() string { + if m != nil { + return m.Model + } + return "" +} + +// Config for EXPLICIT_CONTENT_DETECTION. +type ExplicitContentDetectionConfig struct { + // Model to use for explicit content detection. + // Supported values: "builtin/stable" (the default if unset) and + // "builtin/latest". + Model string `protobuf:"bytes,1,opt,name=model" json:"model,omitempty"` +} + +func (m *ExplicitContentDetectionConfig) Reset() { *m = ExplicitContentDetectionConfig{} } +func (m *ExplicitContentDetectionConfig) String() string { return proto.CompactTextString(m) } +func (*ExplicitContentDetectionConfig) ProtoMessage() {} +func (*ExplicitContentDetectionConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } + +func (m *ExplicitContentDetectionConfig) GetModel() string { + if m != nil { + return m.Model + } + return "" +} + +// Config for FACE_DETECTION. +type FaceDetectionConfig struct { + // Model to use for face detection. + // Supported values: "builtin/stable" (the default if unset) and + // "builtin/latest". + Model string `protobuf:"bytes,1,opt,name=model" json:"model,omitempty"` + // Whether bounding boxes be included in the face annotation output. + IncludeBoundingBoxes bool `protobuf:"varint,2,opt,name=include_bounding_boxes,json=includeBoundingBoxes" json:"include_bounding_boxes,omitempty"` +} + +func (m *FaceDetectionConfig) Reset() { *m = FaceDetectionConfig{} } +func (m *FaceDetectionConfig) String() string { return proto.CompactTextString(m) } +func (*FaceDetectionConfig) ProtoMessage() {} +func (*FaceDetectionConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } + +func (m *FaceDetectionConfig) GetModel() string { + if m != nil { + return m.Model + } + return "" +} + +func (m *FaceDetectionConfig) GetIncludeBoundingBoxes() bool { + if m != nil { + return m.IncludeBoundingBoxes + } + return false +} + +// Video segment. +type VideoSegment struct { + // Time-offset, relative to the beginning of the video, + // corresponding to the start of the segment (inclusive). + StartTimeOffset *google_protobuf3.Duration `protobuf:"bytes,1,opt,name=start_time_offset,json=startTimeOffset" json:"start_time_offset,omitempty"` + // Time-offset, relative to the beginning of the video, + // corresponding to the end of the segment (inclusive). + EndTimeOffset *google_protobuf3.Duration `protobuf:"bytes,2,opt,name=end_time_offset,json=endTimeOffset" json:"end_time_offset,omitempty"` +} + +func (m *VideoSegment) Reset() { *m = VideoSegment{} } +func (m *VideoSegment) String() string { return proto.CompactTextString(m) } +func (*VideoSegment) ProtoMessage() {} +func (*VideoSegment) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } + +func (m *VideoSegment) GetStartTimeOffset() *google_protobuf3.Duration { + if m != nil { + return m.StartTimeOffset + } + return nil +} + +func (m *VideoSegment) GetEndTimeOffset() *google_protobuf3.Duration { + if m != nil { + return m.EndTimeOffset + } + return nil +} + +// Video segment level annotation results for label detection. +type LabelSegment struct { + // Video segment where a label was detected. + Segment *VideoSegment `protobuf:"bytes,1,opt,name=segment" json:"segment,omitempty"` + // Confidence that the label is accurate. Range: [0, 1]. + Confidence float32 `protobuf:"fixed32,2,opt,name=confidence" json:"confidence,omitempty"` +} + +func (m *LabelSegment) Reset() { *m = LabelSegment{} } +func (m *LabelSegment) String() string { return proto.CompactTextString(m) } +func (*LabelSegment) ProtoMessage() {} +func (*LabelSegment) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } + +func (m *LabelSegment) GetSegment() *VideoSegment { + if m != nil { + return m.Segment + } + return nil +} + +func (m *LabelSegment) GetConfidence() float32 { + if m != nil { + return m.Confidence + } + return 0 +} + +// Video frame level annotation results for label detection. +type LabelFrame struct { + // Time-offset, relative to the beginning of the video, corresponding to the + // video frame for this location. + TimeOffset *google_protobuf3.Duration `protobuf:"bytes,1,opt,name=time_offset,json=timeOffset" json:"time_offset,omitempty"` + // Confidence that the label is accurate. Range: [0, 1]. + Confidence float32 `protobuf:"fixed32,2,opt,name=confidence" json:"confidence,omitempty"` +} + +func (m *LabelFrame) Reset() { *m = LabelFrame{} } +func (m *LabelFrame) String() string { return proto.CompactTextString(m) } +func (*LabelFrame) ProtoMessage() {} +func (*LabelFrame) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } + +func (m *LabelFrame) GetTimeOffset() *google_protobuf3.Duration { + if m != nil { + return m.TimeOffset + } + return nil +} + +func (m *LabelFrame) GetConfidence() float32 { + if m != nil { + return m.Confidence + } + return 0 +} + +// Detected entity from video analysis. +type Entity struct { + // Opaque entity ID. Some IDs may be available in + // [Google Knowledge Graph Search + // API](https://developers.google.com/knowledge-graph/). + EntityId string `protobuf:"bytes,1,opt,name=entity_id,json=entityId" json:"entity_id,omitempty"` + // Textual description, e.g. `Fixed-gear bicycle`. + Description string `protobuf:"bytes,2,opt,name=description" json:"description,omitempty"` + // Language code for `description` in BCP-47 format. + LanguageCode string `protobuf:"bytes,3,opt,name=language_code,json=languageCode" json:"language_code,omitempty"` +} + +func (m *Entity) Reset() { *m = Entity{} } +func (m *Entity) String() string { return proto.CompactTextString(m) } +func (*Entity) ProtoMessage() {} +func (*Entity) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } + +func (m *Entity) GetEntityId() string { + if m != nil { + return m.EntityId + } + return "" +} + +func (m *Entity) GetDescription() string { + if m != nil { + return m.Description + } + return "" +} + +func (m *Entity) GetLanguageCode() string { + if m != nil { + return m.LanguageCode + } + return "" +} + +// Label annotation. +type LabelAnnotation struct { + // Detected entity. + Entity *Entity `protobuf:"bytes,1,opt,name=entity" json:"entity,omitempty"` + // Common categories for the detected entity. + // E.g. when the label is `Terrier` the category is likely `dog`. And in some + // cases there might be more than one categories e.g. `Terrier` could also be + // a `pet`. + CategoryEntities []*Entity `protobuf:"bytes,2,rep,name=category_entities,json=categoryEntities" json:"category_entities,omitempty"` + // All video segments where a label was detected. + Segments []*LabelSegment `protobuf:"bytes,3,rep,name=segments" json:"segments,omitempty"` + // All video frames where a label was detected. + Frames []*LabelFrame `protobuf:"bytes,4,rep,name=frames" json:"frames,omitempty"` +} + +func (m *LabelAnnotation) Reset() { *m = LabelAnnotation{} } +func (m *LabelAnnotation) String() string { return proto.CompactTextString(m) } +func (*LabelAnnotation) ProtoMessage() {} +func (*LabelAnnotation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } + +func (m *LabelAnnotation) GetEntity() *Entity { + if m != nil { + return m.Entity + } + return nil +} + +func (m *LabelAnnotation) GetCategoryEntities() []*Entity { + if m != nil { + return m.CategoryEntities + } + return nil +} + +func (m *LabelAnnotation) GetSegments() []*LabelSegment { + if m != nil { + return m.Segments + } + return nil +} + +func (m *LabelAnnotation) GetFrames() []*LabelFrame { + if m != nil { + return m.Frames + } + return nil +} + +// Video frame level annotation results for explicit content. +type ExplicitContentFrame struct { + // Time-offset, relative to the beginning of the video, corresponding to the + // video frame for this location. + TimeOffset *google_protobuf3.Duration `protobuf:"bytes,1,opt,name=time_offset,json=timeOffset" json:"time_offset,omitempty"` + // Likelihood of the pornography content.. + PornographyLikelihood Likelihood `protobuf:"varint,2,opt,name=pornography_likelihood,json=pornographyLikelihood,enum=google.cloud.videointelligence.v1beta2.Likelihood" json:"pornography_likelihood,omitempty"` +} + +func (m *ExplicitContentFrame) Reset() { *m = ExplicitContentFrame{} } +func (m *ExplicitContentFrame) String() string { return proto.CompactTextString(m) } +func (*ExplicitContentFrame) ProtoMessage() {} +func (*ExplicitContentFrame) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } + +func (m *ExplicitContentFrame) GetTimeOffset() *google_protobuf3.Duration { + if m != nil { + return m.TimeOffset + } + return nil +} + +func (m *ExplicitContentFrame) GetPornographyLikelihood() Likelihood { + if m != nil { + return m.PornographyLikelihood + } + return Likelihood_LIKELIHOOD_UNSPECIFIED +} + +// Explicit content annotation (based on per-frame visual signals only). +// If no explicit content has been detected in a frame, no annotations are +// present for that frame. +type ExplicitContentAnnotation struct { + // All video frames where explicit content was detected. + Frames []*ExplicitContentFrame `protobuf:"bytes,1,rep,name=frames" json:"frames,omitempty"` +} + +func (m *ExplicitContentAnnotation) Reset() { *m = ExplicitContentAnnotation{} } +func (m *ExplicitContentAnnotation) String() string { return proto.CompactTextString(m) } +func (*ExplicitContentAnnotation) ProtoMessage() {} +func (*ExplicitContentAnnotation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } + +func (m *ExplicitContentAnnotation) GetFrames() []*ExplicitContentFrame { + if m != nil { + return m.Frames + } + return nil +} + +// Normalized bounding box. +// The normalized vertex coordinates are relative to the original image. +// Range: [0, 1]. +type NormalizedBoundingBox struct { + // Left X coordinate. + Left float32 `protobuf:"fixed32,1,opt,name=left" json:"left,omitempty"` + // Top Y coordinate. + Top float32 `protobuf:"fixed32,2,opt,name=top" json:"top,omitempty"` + // Right X coordinate. + Right float32 `protobuf:"fixed32,3,opt,name=right" json:"right,omitempty"` + // Bottom Y coordinate. + Bottom float32 `protobuf:"fixed32,4,opt,name=bottom" json:"bottom,omitempty"` +} + +func (m *NormalizedBoundingBox) Reset() { *m = NormalizedBoundingBox{} } +func (m *NormalizedBoundingBox) String() string { return proto.CompactTextString(m) } +func (*NormalizedBoundingBox) ProtoMessage() {} +func (*NormalizedBoundingBox) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } + +func (m *NormalizedBoundingBox) GetLeft() float32 { + if m != nil { + return m.Left + } + return 0 +} + +func (m *NormalizedBoundingBox) GetTop() float32 { + if m != nil { + return m.Top + } + return 0 +} + +func (m *NormalizedBoundingBox) GetRight() float32 { + if m != nil { + return m.Right + } + return 0 +} + +func (m *NormalizedBoundingBox) GetBottom() float32 { + if m != nil { + return m.Bottom + } + return 0 +} + +// Video segment level annotation results for face detection. +type FaceSegment struct { + // Video segment where a face was detected. + Segment *VideoSegment `protobuf:"bytes,1,opt,name=segment" json:"segment,omitempty"` +} + +func (m *FaceSegment) Reset() { *m = FaceSegment{} } +func (m *FaceSegment) String() string { return proto.CompactTextString(m) } +func (*FaceSegment) ProtoMessage() {} +func (*FaceSegment) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} } + +func (m *FaceSegment) GetSegment() *VideoSegment { + if m != nil { + return m.Segment + } + return nil +} + +// Video frame level annotation results for face detection. +type FaceFrame struct { + // Normalized Bounding boxes in a frame. + // There can be more than one boxes if the same face is detected in multiple + // locations within the current frame. + NormalizedBoundingBoxes []*NormalizedBoundingBox `protobuf:"bytes,1,rep,name=normalized_bounding_boxes,json=normalizedBoundingBoxes" json:"normalized_bounding_boxes,omitempty"` + // Time-offset, relative to the beginning of the video, + // corresponding to the video frame for this location. + TimeOffset *google_protobuf3.Duration `protobuf:"bytes,2,opt,name=time_offset,json=timeOffset" json:"time_offset,omitempty"` +} + +func (m *FaceFrame) Reset() { *m = FaceFrame{} } +func (m *FaceFrame) String() string { return proto.CompactTextString(m) } +func (*FaceFrame) ProtoMessage() {} +func (*FaceFrame) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } + +func (m *FaceFrame) GetNormalizedBoundingBoxes() []*NormalizedBoundingBox { + if m != nil { + return m.NormalizedBoundingBoxes + } + return nil +} + +func (m *FaceFrame) GetTimeOffset() *google_protobuf3.Duration { + if m != nil { + return m.TimeOffset + } + return nil +} + +// Face annotation. +type FaceAnnotation struct { + // Thumbnail of a representative face view (in JPEG format). Encoding: base64. + Thumbnail []byte `protobuf:"bytes,1,opt,name=thumbnail,proto3" json:"thumbnail,omitempty"` + // All video segments where a face was detected. + Segments []*FaceSegment `protobuf:"bytes,2,rep,name=segments" json:"segments,omitempty"` + // All video frames where a face was detected. + Frames []*FaceFrame `protobuf:"bytes,3,rep,name=frames" json:"frames,omitempty"` +} + +func (m *FaceAnnotation) Reset() { *m = FaceAnnotation{} } +func (m *FaceAnnotation) String() string { return proto.CompactTextString(m) } +func (*FaceAnnotation) ProtoMessage() {} +func (*FaceAnnotation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } + +func (m *FaceAnnotation) GetThumbnail() []byte { + if m != nil { + return m.Thumbnail + } + return nil +} + +func (m *FaceAnnotation) GetSegments() []*FaceSegment { + if m != nil { + return m.Segments + } + return nil +} + +func (m *FaceAnnotation) GetFrames() []*FaceFrame { + if m != nil { + return m.Frames + } + return nil +} + +// Annotation results for a single video. +type VideoAnnotationResults struct { + // Video file location in + // [Google Cloud Storage](https://cloud.google.com/storage/). + InputUri string `protobuf:"bytes,1,opt,name=input_uri,json=inputUri" json:"input_uri,omitempty"` + // Label annotations on video level or user specified segment level. + // There is exactly one element for each unique label. + SegmentLabelAnnotations []*LabelAnnotation `protobuf:"bytes,2,rep,name=segment_label_annotations,json=segmentLabelAnnotations" json:"segment_label_annotations,omitempty"` + // Label annotations on shot level. + // There is exactly one element for each unique label. + ShotLabelAnnotations []*LabelAnnotation `protobuf:"bytes,3,rep,name=shot_label_annotations,json=shotLabelAnnotations" json:"shot_label_annotations,omitempty"` + // Label annotations on frame level. + // There is exactly one element for each unique label. + FrameLabelAnnotations []*LabelAnnotation `protobuf:"bytes,4,rep,name=frame_label_annotations,json=frameLabelAnnotations" json:"frame_label_annotations,omitempty"` + // Face annotations. There is exactly one element for each unique face. + FaceAnnotations []*FaceAnnotation `protobuf:"bytes,5,rep,name=face_annotations,json=faceAnnotations" json:"face_annotations,omitempty"` + // Shot annotations. Each shot is represented as a video segment. + ShotAnnotations []*VideoSegment `protobuf:"bytes,6,rep,name=shot_annotations,json=shotAnnotations" json:"shot_annotations,omitempty"` + // Explicit content annotation. + ExplicitAnnotation *ExplicitContentAnnotation `protobuf:"bytes,7,opt,name=explicit_annotation,json=explicitAnnotation" json:"explicit_annotation,omitempty"` + // If set, indicates an error. Note that for a single `AnnotateVideoRequest` + // some videos may succeed and some may fail. + Error *google_rpc.Status `protobuf:"bytes,9,opt,name=error" json:"error,omitempty"` +} + +func (m *VideoAnnotationResults) Reset() { *m = VideoAnnotationResults{} } +func (m *VideoAnnotationResults) String() string { return proto.CompactTextString(m) } +func (*VideoAnnotationResults) ProtoMessage() {} +func (*VideoAnnotationResults) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } + +func (m *VideoAnnotationResults) GetInputUri() string { + if m != nil { + return m.InputUri + } + return "" +} + +func (m *VideoAnnotationResults) GetSegmentLabelAnnotations() []*LabelAnnotation { + if m != nil { + return m.SegmentLabelAnnotations + } + return nil +} + +func (m *VideoAnnotationResults) GetShotLabelAnnotations() []*LabelAnnotation { + if m != nil { + return m.ShotLabelAnnotations + } + return nil +} + +func (m *VideoAnnotationResults) GetFrameLabelAnnotations() []*LabelAnnotation { + if m != nil { + return m.FrameLabelAnnotations + } + return nil +} + +func (m *VideoAnnotationResults) GetFaceAnnotations() []*FaceAnnotation { + if m != nil { + return m.FaceAnnotations + } + return nil +} + +func (m *VideoAnnotationResults) GetShotAnnotations() []*VideoSegment { + if m != nil { + return m.ShotAnnotations + } + return nil +} + +func (m *VideoAnnotationResults) GetExplicitAnnotation() *ExplicitContentAnnotation { + if m != nil { + return m.ExplicitAnnotation + } + return nil +} + +func (m *VideoAnnotationResults) GetError() *google_rpc.Status { + if m != nil { + return m.Error + } + return nil +} + +// Video annotation response. Included in the `response` +// field of the `Operation` returned by the `GetOperation` +// call of the `google::longrunning::Operations` service. +type AnnotateVideoResponse struct { + // Annotation results for all videos specified in `AnnotateVideoRequest`. + AnnotationResults []*VideoAnnotationResults `protobuf:"bytes,1,rep,name=annotation_results,json=annotationResults" json:"annotation_results,omitempty"` +} + +func (m *AnnotateVideoResponse) Reset() { *m = AnnotateVideoResponse{} } +func (m *AnnotateVideoResponse) String() string { return proto.CompactTextString(m) } +func (*AnnotateVideoResponse) ProtoMessage() {} +func (*AnnotateVideoResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } + +func (m *AnnotateVideoResponse) GetAnnotationResults() []*VideoAnnotationResults { + if m != nil { + return m.AnnotationResults + } + return nil +} + +// Annotation progress for a single video. +type VideoAnnotationProgress struct { + // Video file location in + // [Google Cloud Storage](https://cloud.google.com/storage/). + InputUri string `protobuf:"bytes,1,opt,name=input_uri,json=inputUri" json:"input_uri,omitempty"` + // Approximate percentage processed thus far. + // Guaranteed to be 100 when fully processed. + ProgressPercent int32 `protobuf:"varint,2,opt,name=progress_percent,json=progressPercent" json:"progress_percent,omitempty"` + // Time when the request was received. + StartTime *google_protobuf4.Timestamp `protobuf:"bytes,3,opt,name=start_time,json=startTime" json:"start_time,omitempty"` + // Time of the most recent update. + UpdateTime *google_protobuf4.Timestamp `protobuf:"bytes,4,opt,name=update_time,json=updateTime" json:"update_time,omitempty"` +} + +func (m *VideoAnnotationProgress) Reset() { *m = VideoAnnotationProgress{} } +func (m *VideoAnnotationProgress) String() string { return proto.CompactTextString(m) } +func (*VideoAnnotationProgress) ProtoMessage() {} +func (*VideoAnnotationProgress) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } + +func (m *VideoAnnotationProgress) GetInputUri() string { + if m != nil { + return m.InputUri + } + return "" +} + +func (m *VideoAnnotationProgress) GetProgressPercent() int32 { + if m != nil { + return m.ProgressPercent + } + return 0 +} + +func (m *VideoAnnotationProgress) GetStartTime() *google_protobuf4.Timestamp { + if m != nil { + return m.StartTime + } + return nil +} + +func (m *VideoAnnotationProgress) GetUpdateTime() *google_protobuf4.Timestamp { + if m != nil { + return m.UpdateTime + } + return nil +} + +// Video annotation progress. Included in the `metadata` +// field of the `Operation` returned by the `GetOperation` +// call of the `google::longrunning::Operations` service. +type AnnotateVideoProgress struct { + // Progress metadata for all videos specified in `AnnotateVideoRequest`. + AnnotationProgress []*VideoAnnotationProgress `protobuf:"bytes,1,rep,name=annotation_progress,json=annotationProgress" json:"annotation_progress,omitempty"` +} + +func (m *AnnotateVideoProgress) Reset() { *m = AnnotateVideoProgress{} } +func (m *AnnotateVideoProgress) String() string { return proto.CompactTextString(m) } +func (*AnnotateVideoProgress) ProtoMessage() {} +func (*AnnotateVideoProgress) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} } + +func (m *AnnotateVideoProgress) GetAnnotationProgress() []*VideoAnnotationProgress { + if m != nil { + return m.AnnotationProgress + } + return nil +} + +func init() { + proto.RegisterType((*AnnotateVideoRequest)(nil), "google.cloud.videointelligence.v1beta2.AnnotateVideoRequest") + proto.RegisterType((*VideoContext)(nil), "google.cloud.videointelligence.v1beta2.VideoContext") + proto.RegisterType((*LabelDetectionConfig)(nil), "google.cloud.videointelligence.v1beta2.LabelDetectionConfig") + proto.RegisterType((*ShotChangeDetectionConfig)(nil), "google.cloud.videointelligence.v1beta2.ShotChangeDetectionConfig") + proto.RegisterType((*ExplicitContentDetectionConfig)(nil), "google.cloud.videointelligence.v1beta2.ExplicitContentDetectionConfig") + proto.RegisterType((*FaceDetectionConfig)(nil), "google.cloud.videointelligence.v1beta2.FaceDetectionConfig") + proto.RegisterType((*VideoSegment)(nil), "google.cloud.videointelligence.v1beta2.VideoSegment") + proto.RegisterType((*LabelSegment)(nil), "google.cloud.videointelligence.v1beta2.LabelSegment") + proto.RegisterType((*LabelFrame)(nil), "google.cloud.videointelligence.v1beta2.LabelFrame") + proto.RegisterType((*Entity)(nil), "google.cloud.videointelligence.v1beta2.Entity") + proto.RegisterType((*LabelAnnotation)(nil), "google.cloud.videointelligence.v1beta2.LabelAnnotation") + proto.RegisterType((*ExplicitContentFrame)(nil), "google.cloud.videointelligence.v1beta2.ExplicitContentFrame") + proto.RegisterType((*ExplicitContentAnnotation)(nil), "google.cloud.videointelligence.v1beta2.ExplicitContentAnnotation") + proto.RegisterType((*NormalizedBoundingBox)(nil), "google.cloud.videointelligence.v1beta2.NormalizedBoundingBox") + proto.RegisterType((*FaceSegment)(nil), "google.cloud.videointelligence.v1beta2.FaceSegment") + proto.RegisterType((*FaceFrame)(nil), "google.cloud.videointelligence.v1beta2.FaceFrame") + proto.RegisterType((*FaceAnnotation)(nil), "google.cloud.videointelligence.v1beta2.FaceAnnotation") + proto.RegisterType((*VideoAnnotationResults)(nil), "google.cloud.videointelligence.v1beta2.VideoAnnotationResults") + proto.RegisterType((*AnnotateVideoResponse)(nil), "google.cloud.videointelligence.v1beta2.AnnotateVideoResponse") + proto.RegisterType((*VideoAnnotationProgress)(nil), "google.cloud.videointelligence.v1beta2.VideoAnnotationProgress") + proto.RegisterType((*AnnotateVideoProgress)(nil), "google.cloud.videointelligence.v1beta2.AnnotateVideoProgress") + proto.RegisterEnum("google.cloud.videointelligence.v1beta2.Feature", Feature_name, Feature_value) + proto.RegisterEnum("google.cloud.videointelligence.v1beta2.LabelDetectionMode", LabelDetectionMode_name, LabelDetectionMode_value) + proto.RegisterEnum("google.cloud.videointelligence.v1beta2.Likelihood", Likelihood_name, Likelihood_value) +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// Client API for VideoIntelligenceService service + +type VideoIntelligenceServiceClient interface { + // Performs asynchronous video annotation. Progress and results can be + // retrieved through the `google.longrunning.Operations` interface. + // `Operation.metadata` contains `AnnotateVideoProgress` (progress). + // `Operation.response` contains `AnnotateVideoResponse` (results). + AnnotateVideo(ctx context.Context, in *AnnotateVideoRequest, opts ...grpc.CallOption) (*google_longrunning.Operation, error) +} + +type videoIntelligenceServiceClient struct { + cc *grpc.ClientConn +} + +func NewVideoIntelligenceServiceClient(cc *grpc.ClientConn) VideoIntelligenceServiceClient { + return &videoIntelligenceServiceClient{cc} +} + +func (c *videoIntelligenceServiceClient) AnnotateVideo(ctx context.Context, in *AnnotateVideoRequest, opts ...grpc.CallOption) (*google_longrunning.Operation, error) { + out := new(google_longrunning.Operation) + err := grpc.Invoke(ctx, "/google.cloud.videointelligence.v1beta2.VideoIntelligenceService/AnnotateVideo", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Server API for VideoIntelligenceService service + +type VideoIntelligenceServiceServer interface { + // Performs asynchronous video annotation. Progress and results can be + // retrieved through the `google.longrunning.Operations` interface. + // `Operation.metadata` contains `AnnotateVideoProgress` (progress). + // `Operation.response` contains `AnnotateVideoResponse` (results). + AnnotateVideo(context.Context, *AnnotateVideoRequest) (*google_longrunning.Operation, error) +} + +func RegisterVideoIntelligenceServiceServer(s *grpc.Server, srv VideoIntelligenceServiceServer) { + s.RegisterService(&_VideoIntelligenceService_serviceDesc, srv) +} + +func _VideoIntelligenceService_AnnotateVideo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AnnotateVideoRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(VideoIntelligenceServiceServer).AnnotateVideo(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.cloud.videointelligence.v1beta2.VideoIntelligenceService/AnnotateVideo", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(VideoIntelligenceServiceServer).AnnotateVideo(ctx, req.(*AnnotateVideoRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _VideoIntelligenceService_serviceDesc = grpc.ServiceDesc{ + ServiceName: "google.cloud.videointelligence.v1beta2.VideoIntelligenceService", + HandlerType: (*VideoIntelligenceServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "AnnotateVideo", + Handler: _VideoIntelligenceService_AnnotateVideo_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "google/cloud/videointelligence/v1beta2/video_intelligence.proto", +} + +func init() { + proto.RegisterFile("google/cloud/videointelligence/v1beta2/video_intelligence.proto", fileDescriptor0) +} + +var fileDescriptor0 = []byte{ + // 1702 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0x4f, 0x6f, 0xdb, 0xc8, + 0x15, 0x2f, 0x25, 0x59, 0xb1, 0x9e, 0x64, 0x4b, 0x19, 0xcb, 0xb6, 0xec, 0x26, 0x5e, 0x97, 0x29, + 0x16, 0xae, 0x0b, 0x48, 0x88, 0x77, 0xb1, 0x45, 0x93, 0x6d, 0x17, 0xb2, 0x4c, 0x6d, 0xd4, 0x75, + 0x24, 0x81, 0x52, 0xd2, 0xa6, 0x45, 0x41, 0x50, 0xe4, 0x88, 0x22, 0x96, 0xe2, 0x70, 0xc9, 0x61, + 0x10, 0xf7, 0xd0, 0xc3, 0x1e, 0x16, 0xe8, 0xb1, 0xe8, 0xa5, 0x9f, 0xa1, 0x87, 0x7e, 0x83, 0x02, + 0x45, 0x2f, 0x05, 0x7a, 0xe9, 0xa1, 0xbd, 0xf4, 0xd2, 0x53, 0x8f, 0xfd, 0x10, 0x05, 0x67, 0x86, + 0x12, 0x45, 0xc9, 0xb1, 0x94, 0xa0, 0x37, 0xce, 0x7b, 0xf3, 0x7e, 0xef, 0xff, 0x9b, 0x19, 0xc2, + 0x67, 0x16, 0x21, 0x96, 0x83, 0x1b, 0x86, 0x43, 0x42, 0xb3, 0xf1, 0xda, 0x36, 0x31, 0xb1, 0x5d, + 0x8a, 0x1d, 0xc7, 0xb6, 0xb0, 0x6b, 0xe0, 0xc6, 0xeb, 0xc7, 0x23, 0x4c, 0xf5, 0x0b, 0xce, 0xd1, + 0x92, 0xac, 0xba, 0xe7, 0x13, 0x4a, 0xd0, 0x87, 0x1c, 0xa0, 0xce, 0x00, 0xea, 0x4b, 0x00, 0x75, + 0x01, 0x70, 0xfc, 0x40, 0x28, 0xd2, 0x3d, 0xbb, 0xa1, 0xbb, 0x2e, 0xa1, 0x3a, 0xb5, 0x89, 0x1b, + 0x70, 0x94, 0xe3, 0x47, 0x82, 0xeb, 0x10, 0xd7, 0xf2, 0x43, 0xd7, 0xb5, 0x5d, 0xab, 0x41, 0x3c, + 0xec, 0x2f, 0x6c, 0x3a, 0x11, 0x9b, 0xd8, 0x6a, 0x14, 0x8e, 0x1b, 0x66, 0xc8, 0x37, 0x08, 0xfe, + 0x07, 0x69, 0x3e, 0xb5, 0xa7, 0x38, 0xa0, 0xfa, 0xd4, 0x13, 0x1b, 0x0e, 0xc5, 0x06, 0xdf, 0x33, + 0x1a, 0x01, 0xd5, 0x69, 0x28, 0x90, 0xe5, 0x3f, 0x67, 0xa0, 0xda, 0xe4, 0x46, 0xe1, 0x97, 0x91, + 0x0b, 0x2a, 0xfe, 0x2a, 0xc4, 0x01, 0x45, 0xdf, 0x86, 0x82, 0xed, 0x7a, 0x21, 0xd5, 0x42, 0xdf, + 0xae, 0x49, 0xa7, 0xd2, 0x59, 0x41, 0xdd, 0x66, 0x84, 0x17, 0xbe, 0x8d, 0x1e, 0xc1, 0x0e, 0x67, + 0x1a, 0xc4, 0xa5, 0xd8, 0xa5, 0xb5, 0xfc, 0xa9, 0x74, 0x56, 0x52, 0x4b, 0x8c, 0xd8, 0xe2, 0x34, + 0xf4, 0x05, 0x6c, 0x8f, 0xb1, 0x4e, 0x43, 0x1f, 0x07, 0xb5, 0xcc, 0x69, 0xf6, 0x6c, 0xf7, 0xa2, + 0x51, 0x5f, 0x2f, 0x64, 0xf5, 0x36, 0x97, 0x53, 0x67, 0x00, 0xe8, 0x15, 0xec, 0xf0, 0x44, 0x30, + 0x8d, 0x6f, 0x68, 0x2d, 0x7b, 0x2a, 0x9d, 0x15, 0x2f, 0x3e, 0x5e, 0x17, 0x91, 0xf9, 0xd6, 0xe2, + 0xb2, 0x6a, 0xe9, 0x75, 0x62, 0x85, 0x1e, 0x02, 0x90, 0x90, 0xc6, 0xae, 0xe6, 0x98, 0xab, 0x05, + 0x4e, 0x89, 0x7c, 0xfd, 0x00, 0x8a, 0x0e, 0x31, 0x58, 0xb4, 0x35, 0xdb, 0xac, 0x6d, 0x31, 0x3e, + 0xc4, 0xa4, 0x8e, 0x29, 0xff, 0x3b, 0x07, 0xa5, 0x24, 0x3c, 0xea, 0xc3, 0x76, 0x80, 0xad, 0x29, + 0x76, 0x69, 0x50, 0x93, 0x4e, 0xb3, 0x1b, 0x9b, 0x39, 0xe0, 0xc2, 0xea, 0x0c, 0x05, 0xf9, 0x70, + 0xe0, 0xe8, 0x23, 0xec, 0x68, 0x26, 0xa6, 0xd8, 0x60, 0xa6, 0x18, 0xc4, 0x1d, 0xdb, 0x56, 0x2d, + 0xc3, 0xc2, 0xf0, 0xe9, 0xba, 0xf8, 0xd7, 0x11, 0xca, 0x55, 0x0c, 0xd2, 0x62, 0x18, 0x6a, 0xd5, + 0x59, 0x41, 0x45, 0x5f, 0x4b, 0xf0, 0x20, 0x98, 0x10, 0xaa, 0x19, 0x13, 0xdd, 0xb5, 0xf0, 0xb2, + 0x6a, 0x9e, 0x81, 0xe6, 0xba, 0xaa, 0x07, 0x13, 0x42, 0x5b, 0x0c, 0x2a, 0xad, 0xff, 0x28, 0xb8, + 0x8d, 0x85, 0x7e, 0x2b, 0xc1, 0x77, 0xf0, 0x1b, 0xcf, 0xb1, 0x0d, 0x7b, 0x56, 0x6c, 0xcb, 0x96, + 0xe4, 0x98, 0x25, 0xed, 0x75, 0x2d, 0x51, 0x04, 0xa0, 0x28, 0xd4, 0xb4, 0x39, 0x27, 0xf8, 0xad, + 0x7c, 0x44, 0x60, 0x7f, 0xac, 0x1b, 0x2b, 0x02, 0xb2, 0xc5, 0xcc, 0x78, 0xba, 0x76, 0x91, 0xeb, + 0xc6, 0x52, 0x28, 0xf6, 0xc6, 0xcb, 0x44, 0xf9, 0xaf, 0x12, 0x54, 0x57, 0x25, 0x0e, 0x39, 0x50, + 0x4d, 0x97, 0xc5, 0x94, 0x98, 0x98, 0xb5, 0xeb, 0xee, 0xc5, 0x93, 0x77, 0x2b, 0x8a, 0xe7, 0xc4, + 0xc4, 0x2a, 0x72, 0x96, 0x68, 0xe8, 0xfb, 0x70, 0x3f, 0xe0, 0xb3, 0x4b, 0xf7, 0x6f, 0x34, 0x43, + 0x9f, 0x62, 0x5f, 0x67, 0xf5, 0xb7, 0xad, 0x56, 0xe6, 0x8c, 0x16, 0xa3, 0xa3, 0x2a, 0x6c, 0x45, + 0xa6, 0x38, 0xac, 0x4a, 0x0a, 0x2a, 0x5f, 0xc8, 0x8f, 0xe1, 0xe8, 0xd6, 0x32, 0x98, 0x8b, 0x48, + 0x49, 0x91, 0x4f, 0xe0, 0xe4, 0xed, 0xf9, 0xba, 0x45, 0x4e, 0x87, 0xbd, 0x15, 0x01, 0x5e, 0xbd, + 0x19, 0x7d, 0x0c, 0x07, 0xb6, 0x6b, 0x38, 0xa1, 0x89, 0xb5, 0x11, 0x09, 0x5d, 0xd3, 0x76, 0x2d, + 0x6d, 0x44, 0xde, 0xb0, 0xc1, 0x15, 0xf9, 0x57, 0x15, 0xdc, 0x4b, 0xc1, 0xbc, 0x8c, 0x78, 0xf2, + 0xef, 0x25, 0xd1, 0xf8, 0xa2, 0x61, 0x91, 0xc2, 0x22, 0xe4, 0x53, 0x2d, 0x1a, 0xbf, 0x1a, 0x19, + 0x8f, 0x03, 0x4c, 0x99, 0xa2, 0xe2, 0xc5, 0x51, 0x9c, 0x8c, 0x78, 0x44, 0xd7, 0xaf, 0xc4, 0x08, + 0x57, 0xcb, 0x4c, 0x66, 0x68, 0x4f, 0x71, 0x8f, 0x49, 0xa0, 0x26, 0x94, 0xb1, 0x6b, 0x2e, 0x80, + 0x64, 0xee, 0x02, 0xd9, 0xc1, 0xae, 0x39, 0x87, 0x90, 0x7f, 0x0d, 0x25, 0x96, 0xd5, 0xd8, 0xb2, + 0x2e, 0xdc, 0x13, 0xc3, 0x44, 0xd8, 0xf3, 0x6e, 0x13, 0x29, 0x06, 0x41, 0x27, 0x00, 0xac, 0xe8, + 0xcd, 0x68, 0x2f, 0xb3, 0x2e, 0xa3, 0x26, 0x28, 0xf2, 0x04, 0x80, 0xe9, 0x6f, 0xfb, 0xfa, 0x14, + 0xa3, 0x27, 0x50, 0xdc, 0x28, 0x22, 0x40, 0xe7, 0xc1, 0xb8, 0x4b, 0x93, 0x03, 0x79, 0xc5, 0xa5, + 0x36, 0xbd, 0x89, 0x4e, 0x2c, 0xcc, 0xbe, 0xa2, 0x31, 0x2d, 0x4e, 0x2c, 0x4e, 0xe8, 0x98, 0xe8, + 0x14, 0x8a, 0x26, 0x0e, 0x0c, 0xdf, 0xf6, 0x22, 0x0d, 0x0c, 0xa7, 0xa0, 0x26, 0x49, 0xd1, 0x99, + 0xe6, 0xe8, 0xae, 0x15, 0xea, 0x16, 0xd6, 0x8c, 0xa8, 0x8b, 0x78, 0xe5, 0x96, 0x62, 0x62, 0x8b, + 0x98, 0x58, 0xfe, 0x67, 0x06, 0xca, 0xcc, 0xb1, 0xe6, 0xec, 0x20, 0x47, 0x6d, 0xc8, 0x73, 0x35, + 0xc2, 0xb1, 0xfa, 0xda, 0x73, 0x88, 0x49, 0xa9, 0x42, 0x1a, 0xfd, 0x02, 0xee, 0x1b, 0x3a, 0xc5, + 0x16, 0xf1, 0x6f, 0x34, 0x46, 0xb2, 0xc5, 0xc1, 0xb9, 0x39, 0x64, 0x25, 0x06, 0x52, 0x04, 0xce, + 0xc2, 0x99, 0x94, 0xdd, 0xec, 0x4c, 0x4a, 0x16, 0x52, 0xe2, 0x4c, 0xfa, 0x09, 0xe4, 0xc7, 0x51, + 0x76, 0x83, 0x5a, 0x8e, 0xe1, 0x5d, 0x6c, 0x84, 0xc7, 0x0a, 0x43, 0x15, 0x08, 0xf2, 0x9f, 0x24, + 0xa8, 0xa6, 0xba, 0xfc, 0xfd, 0x2b, 0xc7, 0x86, 0x03, 0x8f, 0xf8, 0x2e, 0xb1, 0x7c, 0xdd, 0x9b, + 0xdc, 0x68, 0x8e, 0xfd, 0x25, 0x76, 0xec, 0x09, 0x21, 0x26, 0xcb, 0xfe, 0xee, 0x06, 0x06, 0xcf, + 0x24, 0xd5, 0xfd, 0x04, 0xe2, 0x9c, 0x2c, 0x7f, 0x05, 0x47, 0x29, 0xf3, 0x13, 0xf5, 0x31, 0x9c, + 0x05, 0x8a, 0x5f, 0x06, 0x3e, 0x7d, 0xc7, 0x73, 0x6a, 0x31, 0x64, 0x5f, 0xc2, 0x7e, 0x97, 0xf8, + 0x53, 0xdd, 0xb1, 0x7f, 0x85, 0xcd, 0xc4, 0x5c, 0x42, 0x08, 0x72, 0x0e, 0x1e, 0xf3, 0x58, 0x65, + 0x54, 0xf6, 0x8d, 0x2a, 0x90, 0xa5, 0xc4, 0x13, 0xdd, 0x13, 0x7d, 0x46, 0x73, 0xd0, 0xb7, 0xad, + 0x09, 0xbf, 0x47, 0x65, 0x54, 0xbe, 0x40, 0x07, 0x90, 0x1f, 0x11, 0x4a, 0xc9, 0x94, 0x1d, 0xa9, + 0x19, 0x55, 0xac, 0xe4, 0x5f, 0x42, 0x31, 0x1a, 0xa6, 0xff, 0xa7, 0x69, 0x22, 0xff, 0x45, 0x82, + 0x42, 0x84, 0xcf, 0x73, 0x7e, 0x03, 0x47, 0xee, 0xcc, 0xb3, 0xf4, 0x3c, 0xe6, 0x21, 0xfc, 0xd1, + 0xba, 0xfa, 0x56, 0x86, 0x48, 0x3d, 0x74, 0x57, 0x91, 0x71, 0x90, 0x2e, 0xb7, 0xcc, 0x06, 0xe5, + 0x26, 0xff, 0x4d, 0x82, 0xdd, 0xc8, 0x89, 0x44, 0xe6, 0x1f, 0x40, 0x81, 0x4e, 0xc2, 0xe9, 0xc8, + 0xd5, 0x6d, 0x7e, 0xe0, 0x94, 0xd4, 0x39, 0x01, 0xf5, 0x12, 0x2d, 0xc9, 0xdb, 0xfc, 0xa3, 0x4d, + 0xae, 0x0e, 0xcb, 0x1d, 0xd9, 0x99, 0x15, 0x1a, 0xef, 0xf0, 0xc7, 0x9b, 0xc0, 0x2d, 0x56, 0xd7, + 0x7f, 0xb7, 0xe0, 0x80, 0xe5, 0x6a, 0xee, 0x8d, 0x8a, 0x83, 0xd0, 0xa1, 0xc1, 0xdb, 0x1f, 0x06, + 0x01, 0x1c, 0x09, 0x73, 0x34, 0x7e, 0x33, 0x49, 0x3c, 0x78, 0x84, 0x93, 0x3f, 0xd8, 0x68, 0x4e, + 0x24, 0xf4, 0x1f, 0x0a, 0xe4, 0x14, 0x3d, 0x40, 0x53, 0x38, 0x60, 0x17, 0xd5, 0x65, 0x8d, 0xd9, + 0xf7, 0xd3, 0x58, 0x8d, 0x60, 0x97, 0xd4, 0x11, 0x38, 0x64, 0x51, 0x5a, 0xa1, 0x2f, 0xf7, 0x7e, + 0xfa, 0xf6, 0x19, 0xee, 0x92, 0x42, 0x1d, 0x2a, 0xec, 0xc2, 0x99, 0xd4, 0xb4, 0xc5, 0x34, 0x7d, + 0xb2, 0x49, 0x86, 0x13, 0x8a, 0xca, 0xe3, 0x85, 0x75, 0x80, 0x34, 0xa8, 0xb0, 0x10, 0x26, 0x55, + 0xe4, 0xdf, 0xe3, 0xe9, 0x52, 0x8e, 0xd0, 0x92, 0x0a, 0x7c, 0xd8, 0x9b, 0xdd, 0xe3, 0xe7, 0x4a, + 0x6a, 0xf7, 0x36, 0x7b, 0x43, 0xdc, 0x3a, 0x64, 0x55, 0x14, 0xa3, 0x27, 0xda, 0xef, 0x0c, 0xb6, + 0xb0, 0xef, 0x13, 0xbf, 0x56, 0x60, 0x5a, 0x50, 0xac, 0xc5, 0xf7, 0x8c, 0xfa, 0x80, 0x3d, 0x82, + 0x55, 0xbe, 0x41, 0xfe, 0x46, 0x82, 0xfd, 0xd4, 0x2b, 0x38, 0xf0, 0x88, 0x1b, 0x60, 0x34, 0x05, + 0x34, 0x37, 0x57, 0xf3, 0x79, 0x0f, 0x88, 0x29, 0xf4, 0xe3, 0x8d, 0x42, 0xb3, 0xd4, 0x49, 0xea, + 0x7d, 0x3d, 0x4d, 0x92, 0xff, 0x25, 0xc1, 0x61, 0x6a, 0x77, 0xdf, 0x27, 0x96, 0x8f, 0x83, 0x3b, + 0x1a, 0xef, 0x7b, 0x50, 0xf1, 0xc4, 0x46, 0xcd, 0xc3, 0xbe, 0x11, 0xcd, 0xe6, 0x68, 0x7c, 0x6d, + 0xa9, 0xe5, 0x98, 0xde, 0xe7, 0x64, 0xf4, 0x43, 0x80, 0xf9, 0x2d, 0x55, 0xbc, 0xe2, 0x8e, 0x97, + 0x66, 0xdc, 0x30, 0xfe, 0x83, 0xa0, 0x16, 0x66, 0xf7, 0x53, 0xf4, 0x14, 0x8a, 0xa1, 0x67, 0xea, + 0x14, 0x73, 0xd9, 0xdc, 0x9d, 0xb2, 0xc0, 0xb7, 0x47, 0x04, 0xf9, 0x37, 0xe9, 0x20, 0xcf, 0x3c, + 0xf3, 0x60, 0x2f, 0x11, 0xe4, 0xd8, 0x5e, 0x11, 0xe5, 0xcf, 0xde, 0x31, 0xca, 0x31, 0xba, 0x9a, + 0x48, 0x60, 0x4c, 0x3b, 0xff, 0x46, 0x82, 0x7b, 0xe2, 0x27, 0x03, 0x3a, 0x84, 0xbd, 0xb6, 0xd2, + 0x1c, 0xbe, 0x50, 0x15, 0xed, 0x45, 0x77, 0xd0, 0x57, 0x5a, 0x9d, 0x76, 0x47, 0xb9, 0xaa, 0x7c, + 0x0b, 0xed, 0x41, 0xf9, 0xba, 0x79, 0xa9, 0x5c, 0x6b, 0x57, 0xca, 0x50, 0x69, 0x0d, 0x3b, 0xbd, + 0x6e, 0x45, 0x42, 0x47, 0xb0, 0x3f, 0x78, 0xd6, 0x1b, 0x6a, 0xad, 0x67, 0xcd, 0xee, 0xe7, 0x4a, + 0x82, 0x95, 0x41, 0x27, 0x70, 0xac, 0xfc, 0xac, 0x7f, 0xdd, 0x69, 0x75, 0x86, 0x5a, 0xab, 0xd7, + 0x1d, 0x2a, 0xdd, 0x61, 0x82, 0x9f, 0x45, 0x08, 0x76, 0xdb, 0xcd, 0x56, 0x52, 0x26, 0x77, 0xee, + 0x03, 0x5a, 0x7e, 0x7e, 0xa1, 0xef, 0xc2, 0x69, 0x4a, 0xb3, 0xf6, 0xbc, 0x77, 0x95, 0xb6, 0x6f, + 0x07, 0x0a, 0xcc, 0x94, 0x88, 0x55, 0x91, 0xd0, 0x2e, 0x40, 0x5b, 0x6d, 0x3e, 0x57, 0xf8, 0x3a, + 0x13, 0xf9, 0xc5, 0xd8, 0xcd, 0xee, 0x95, 0x96, 0x60, 0x64, 0xcf, 0x29, 0xc0, 0xfc, 0xee, 0x82, + 0x8e, 0xe1, 0xe0, 0xba, 0xf3, 0x85, 0x72, 0xdd, 0x79, 0xd6, 0xeb, 0x5d, 0xa5, 0x34, 0xdc, 0x87, + 0x9d, 0x97, 0x8a, 0xfa, 0x4a, 0x7b, 0xd1, 0x65, 0x5b, 0x5e, 0x55, 0x24, 0x54, 0x82, 0xed, 0xd9, + 0x2a, 0x13, 0xad, 0xfa, 0xbd, 0xc1, 0xa0, 0x73, 0x79, 0xad, 0x54, 0xb2, 0x08, 0x20, 0x2f, 0x38, + 0x39, 0x54, 0x86, 0x22, 0x13, 0x15, 0x84, 0xad, 0x8b, 0x3f, 0x4a, 0x50, 0x63, 0x29, 0xea, 0x24, + 0x92, 0x37, 0xc0, 0xfe, 0x6b, 0xdb, 0xc0, 0xd1, 0x3b, 0x7f, 0x67, 0xa1, 0x36, 0xd0, 0xda, 0xb7, + 0xa4, 0x55, 0x7f, 0xaf, 0x8e, 0x1f, 0xc6, 0xd2, 0x89, 0xdf, 0x6a, 0xf5, 0x5e, 0xfc, 0x5b, 0x4d, + 0x7e, 0xf4, 0xf5, 0x3f, 0xfe, 0xf3, 0xbb, 0xcc, 0x43, 0xb9, 0xb6, 0xf8, 0x97, 0x2f, 0x78, 0x22, + 0x4a, 0x05, 0x3f, 0x91, 0xce, 0x2f, 0xff, 0x2e, 0xc1, 0xb9, 0x41, 0xa6, 0x6b, 0xda, 0x71, 0xf9, + 0xf0, 0x36, 0xe7, 0xfa, 0x51, 0x5b, 0xf4, 0xa5, 0x9f, 0xff, 0x54, 0x00, 0x59, 0x24, 0x7a, 0x52, + 0xd4, 0x89, 0x6f, 0x35, 0x2c, 0xec, 0xb2, 0xa6, 0x69, 0x70, 0x96, 0xee, 0xd9, 0xc1, 0x5d, 0xff, + 0x23, 0x9f, 0x2e, 0x71, 0xfe, 0x90, 0xf9, 0xf0, 0x73, 0x8e, 0xdc, 0x62, 0x26, 0x2e, 0xd9, 0x51, + 0x7f, 0xc9, 0x45, 0x47, 0x79, 0xa6, 0xec, 0xa3, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0x5d, 0x2f, + 0xdf, 0xfc, 0xfb, 0x14, 0x00, 0x00, +} diff --git a/vendor/google.golang.org/genproto/googleapis/container/v1/cluster_service.pb.go b/vendor/google.golang.org/genproto/googleapis/container/v1/cluster_service.pb.go index 44b1d560..a5b58321 100644 --- a/vendor/google.golang.org/genproto/googleapis/container/v1/cluster_service.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/container/v1/cluster_service.pb.go @@ -10,16 +10,28 @@ It is generated from these files: It has these top-level messages: NodeConfig MasterAuth + ClientCertificateConfig AddonsConfig HttpLoadBalancing HorizontalPodAutoscaling + KubernetesDashboard + MasterAuthorizedNetworksConfig LegacyAbac + NetworkPolicy + IPAllocationPolicy Cluster ClusterUpdate Operation CreateClusterRequest GetClusterRequest UpdateClusterRequest + UpdateNodePoolRequest + SetNodePoolAutoscalingRequest + SetLoggingServiceRequest + SetMonitoringServiceRequest + SetAddonsConfigRequest + SetLocationsRequest + UpdateMasterRequest SetMasterAuthRequest DeleteClusterRequest ListClustersRequest @@ -38,6 +50,7 @@ It has these top-level messages: NodeManagement AutoUpgradeOptions SetNodePoolManagementRequest + SetNodePoolSizeRequest RollbackNodePoolUpgradeRequest ListNodePoolsResponse NodePoolAutoscaling @@ -45,6 +58,8 @@ It has these top-level messages: SetLegacyAbacRequest StartIPRotationRequest CompleteIPRotationRequest + AcceleratorConfig + SetNetworkPolicyRequest */ package container @@ -70,6 +85,30 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package +// Allowed Network Policy providers. +type NetworkPolicy_Provider int32 + +const ( + // Not set + NetworkPolicy_PROVIDER_UNSPECIFIED NetworkPolicy_Provider = 0 + // Tigera (Calico Felix). + NetworkPolicy_CALICO NetworkPolicy_Provider = 1 +) + +var NetworkPolicy_Provider_name = map[int32]string{ + 0: "PROVIDER_UNSPECIFIED", + 1: "CALICO", +} +var NetworkPolicy_Provider_value = map[string]int32{ + "PROVIDER_UNSPECIFIED": 0, + "CALICO": 1, +} + +func (x NetworkPolicy_Provider) String() string { + return proto.EnumName(NetworkPolicy_Provider_name, int32(x)) +} +func (NetworkPolicy_Provider) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{9, 0} } + // The current status of the cluster. type Cluster_Status int32 @@ -112,7 +151,7 @@ var Cluster_Status_value = map[string]int32{ func (x Cluster_Status) String() string { return proto.EnumName(Cluster_Status_name, int32(x)) } -func (Cluster_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{6, 0} } +func (Cluster_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{11, 0} } // Current status of the operation. type Operation_Status int32 @@ -148,7 +187,7 @@ var Operation_Status_value = map[string]int32{ func (x Operation_Status) String() string { return proto.EnumName(Operation_Status_name, int32(x)) } -func (Operation_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{8, 0} } +func (Operation_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{13, 0} } // Operation type. type Operation_Type int32 @@ -182,6 +221,10 @@ const ( Operation_SET_LABELS Operation_Type = 12 // Set/generate master auth materials Operation_SET_MASTER_AUTH Operation_Type = 13 + // Set node pool size. + Operation_SET_NODE_POOL_SIZE Operation_Type = 14 + // Updates network policy for a cluster. + Operation_SET_NETWORK_POLICY Operation_Type = 15 ) var Operation_Type_name = map[int32]string{ @@ -199,6 +242,8 @@ var Operation_Type_name = map[int32]string{ 11: "AUTO_UPGRADE_NODES", 12: "SET_LABELS", 13: "SET_MASTER_AUTH", + 14: "SET_NODE_POOL_SIZE", + 15: "SET_NETWORK_POLICY", } var Operation_Type_value = map[string]int32{ "TYPE_UNSPECIFIED": 0, @@ -215,12 +260,14 @@ var Operation_Type_value = map[string]int32{ "AUTO_UPGRADE_NODES": 11, "SET_LABELS": 12, "SET_MASTER_AUTH": 13, + "SET_NODE_POOL_SIZE": 14, + "SET_NETWORK_POLICY": 15, } func (x Operation_Type) String() string { return proto.EnumName(Operation_Type_name, int32(x)) } -func (Operation_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{8, 1} } +func (Operation_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{13, 1} } // operation type - what type of key rotation are we performing type SetMasterAuthRequest_Action int32 @@ -249,7 +296,7 @@ func (x SetMasterAuthRequest_Action) String() string { return proto.EnumName(SetMasterAuthRequest_Action_name, int32(x)) } func (SetMasterAuthRequest_Action) EnumDescriptor() ([]byte, []int) { - return fileDescriptor0, []int{12, 0} + return fileDescriptor0, []int{24, 0} } // The current status of the node pool instance. @@ -301,7 +348,7 @@ var NodePool_Status_value = map[string]int32{ func (x NodePool_Status) String() string { return proto.EnumName(NodePool_Status_name, int32(x)) } -func (NodePool_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{26, 0} } +func (NodePool_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{38, 0} } // Parameters that describe the nodes in a cluster. type NodeConfig struct { @@ -377,6 +424,10 @@ type NodeConfig struct { // https://cloud.google.com/compute/docs/instances/preemptible for more // information about preemptible VM instances. Preemptible bool `protobuf:"varint,10,opt,name=preemptible" json:"preemptible,omitempty"` + // A list of hardware accelerators to be attached to each node. + // See https://cloud.google.com/compute/docs/gpus for more information about + // support for GPUs. + Accelerators []*AcceleratorConfig `protobuf:"bytes,11,rep,name=accelerators" json:"accelerators,omitempty"` } func (m *NodeConfig) Reset() { *m = NodeConfig{} } @@ -454,6 +505,13 @@ func (m *NodeConfig) GetPreemptible() bool { return false } +func (m *NodeConfig) GetAccelerators() []*AcceleratorConfig { + if m != nil { + return m.Accelerators + } + return nil +} + // The authentication information for accessing the master endpoint. // Authentication can be done using HTTP basic auth or using client // certificates. @@ -467,6 +525,9 @@ type MasterAuth struct { // strong password. If a password is provided for cluster creation, username // must be non-empty. Password string `protobuf:"bytes,2,opt,name=password" json:"password,omitempty"` + // Configuration for client certificate authentication on the cluster. If no + // configuration is specified, a client certificate is issued. + ClientCertificateConfig *ClientCertificateConfig `protobuf:"bytes,3,opt,name=client_certificate_config,json=clientCertificateConfig" json:"client_certificate_config,omitempty"` // [Output only] Base64-encoded public certificate that is the root of // trust for the cluster. ClusterCaCertificate string `protobuf:"bytes,100,opt,name=cluster_ca_certificate,json=clusterCaCertificate" json:"cluster_ca_certificate,omitempty"` @@ -497,6 +558,13 @@ func (m *MasterAuth) GetPassword() string { return "" } +func (m *MasterAuth) GetClientCertificateConfig() *ClientCertificateConfig { + if m != nil { + return m.ClientCertificateConfig + } + return nil +} + func (m *MasterAuth) GetClusterCaCertificate() string { if m != nil { return m.ClusterCaCertificate @@ -518,6 +586,24 @@ func (m *MasterAuth) GetClientKey() string { return "" } +// Configuration for client certificates on the cluster. +type ClientCertificateConfig struct { + // Issue a client certificate. + IssueClientCertificate bool `protobuf:"varint,1,opt,name=issue_client_certificate,json=issueClientCertificate" json:"issue_client_certificate,omitempty"` +} + +func (m *ClientCertificateConfig) Reset() { *m = ClientCertificateConfig{} } +func (m *ClientCertificateConfig) String() string { return proto.CompactTextString(m) } +func (*ClientCertificateConfig) ProtoMessage() {} +func (*ClientCertificateConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } + +func (m *ClientCertificateConfig) GetIssueClientCertificate() bool { + if m != nil { + return m.IssueClientCertificate + } + return false +} + // Configuration for the addons that can be automatically spun up in the // cluster, enabling additional functionality. type AddonsConfig struct { @@ -528,12 +614,14 @@ type AddonsConfig struct { // increases or decreases the number of replica pods a replication controller // has based on the resource usage of the existing pods. HorizontalPodAutoscaling *HorizontalPodAutoscaling `protobuf:"bytes,2,opt,name=horizontal_pod_autoscaling,json=horizontalPodAutoscaling" json:"horizontal_pod_autoscaling,omitempty"` + // Configuration for the Kubernetes Dashboard. + KubernetesDashboard *KubernetesDashboard `protobuf:"bytes,3,opt,name=kubernetes_dashboard,json=kubernetesDashboard" json:"kubernetes_dashboard,omitempty"` } func (m *AddonsConfig) Reset() { *m = AddonsConfig{} } func (m *AddonsConfig) String() string { return proto.CompactTextString(m) } func (*AddonsConfig) ProtoMessage() {} -func (*AddonsConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } +func (*AddonsConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } func (m *AddonsConfig) GetHttpLoadBalancing() *HttpLoadBalancing { if m != nil { @@ -549,6 +637,13 @@ func (m *AddonsConfig) GetHorizontalPodAutoscaling() *HorizontalPodAutoscaling { return nil } +func (m *AddonsConfig) GetKubernetesDashboard() *KubernetesDashboard { + if m != nil { + return m.KubernetesDashboard + } + return nil +} + // Configuration options for the HTTP (L7) load balancing controller addon, // which makes it easy to set up HTTP load balancers for services in a cluster. type HttpLoadBalancing struct { @@ -561,7 +656,7 @@ type HttpLoadBalancing struct { func (m *HttpLoadBalancing) Reset() { *m = HttpLoadBalancing{} } func (m *HttpLoadBalancing) String() string { return proto.CompactTextString(m) } func (*HttpLoadBalancing) ProtoMessage() {} -func (*HttpLoadBalancing) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } +func (*HttpLoadBalancing) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } func (m *HttpLoadBalancing) GetDisabled() bool { if m != nil { @@ -583,7 +678,7 @@ type HorizontalPodAutoscaling struct { func (m *HorizontalPodAutoscaling) Reset() { *m = HorizontalPodAutoscaling{} } func (m *HorizontalPodAutoscaling) String() string { return proto.CompactTextString(m) } func (*HorizontalPodAutoscaling) ProtoMessage() {} -func (*HorizontalPodAutoscaling) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } +func (*HorizontalPodAutoscaling) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } func (m *HorizontalPodAutoscaling) GetDisabled() bool { if m != nil { @@ -592,6 +687,87 @@ func (m *HorizontalPodAutoscaling) GetDisabled() bool { return false } +// Configuration for the Kubernetes Dashboard. +type KubernetesDashboard struct { + // Whether the Kubernetes Dashboard is enabled for this cluster. + Disabled bool `protobuf:"varint,1,opt,name=disabled" json:"disabled,omitempty"` +} + +func (m *KubernetesDashboard) Reset() { *m = KubernetesDashboard{} } +func (m *KubernetesDashboard) String() string { return proto.CompactTextString(m) } +func (*KubernetesDashboard) ProtoMessage() {} +func (*KubernetesDashboard) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } + +func (m *KubernetesDashboard) GetDisabled() bool { + if m != nil { + return m.Disabled + } + return false +} + +// Master authorized networks is a Beta feature. +// Configuration options for the master authorized networks feature. Enabled +// master authorized networks will disallow all external traffic to access +// Kubernetes master through HTTPS except traffic from the given CIDR blocks, +// Google Compute Engine Public IPs and Google Prod IPs. +type MasterAuthorizedNetworksConfig struct { + // Whether or not master authorized networks is enabled. + Enabled bool `protobuf:"varint,1,opt,name=enabled" json:"enabled,omitempty"` + // cidr_blocks define up to 10 external networks that could access + // Kubernetes master through HTTPS. + CidrBlocks []*MasterAuthorizedNetworksConfig_CidrBlock `protobuf:"bytes,2,rep,name=cidr_blocks,json=cidrBlocks" json:"cidr_blocks,omitempty"` +} + +func (m *MasterAuthorizedNetworksConfig) Reset() { *m = MasterAuthorizedNetworksConfig{} } +func (m *MasterAuthorizedNetworksConfig) String() string { return proto.CompactTextString(m) } +func (*MasterAuthorizedNetworksConfig) ProtoMessage() {} +func (*MasterAuthorizedNetworksConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } + +func (m *MasterAuthorizedNetworksConfig) GetEnabled() bool { + if m != nil { + return m.Enabled + } + return false +} + +func (m *MasterAuthorizedNetworksConfig) GetCidrBlocks() []*MasterAuthorizedNetworksConfig_CidrBlock { + if m != nil { + return m.CidrBlocks + } + return nil +} + +// CidrBlock contains an optional name and one CIDR block. +type MasterAuthorizedNetworksConfig_CidrBlock struct { + // display_name is an optional field for users to identify CIDR blocks. + DisplayName string `protobuf:"bytes,1,opt,name=display_name,json=displayName" json:"display_name,omitempty"` + // cidr_block must be specified in CIDR notation. + CidrBlock string `protobuf:"bytes,2,opt,name=cidr_block,json=cidrBlock" json:"cidr_block,omitempty"` +} + +func (m *MasterAuthorizedNetworksConfig_CidrBlock) Reset() { + *m = MasterAuthorizedNetworksConfig_CidrBlock{} +} +func (m *MasterAuthorizedNetworksConfig_CidrBlock) String() string { return proto.CompactTextString(m) } +func (*MasterAuthorizedNetworksConfig_CidrBlock) ProtoMessage() {} +func (*MasterAuthorizedNetworksConfig_CidrBlock) Descriptor() ([]byte, []int) { + return fileDescriptor0, []int{7, 0} +} + +func (m *MasterAuthorizedNetworksConfig_CidrBlock) GetDisplayName() string { + if m != nil { + return m.DisplayName + } + return "" +} + +func (m *MasterAuthorizedNetworksConfig_CidrBlock) GetCidrBlock() string { + if m != nil { + return m.CidrBlock + } + return "" +} + // Configuration for the legacy Attribute Based Access Control authorization // mode. type LegacyAbac struct { @@ -605,7 +781,7 @@ type LegacyAbac struct { func (m *LegacyAbac) Reset() { *m = LegacyAbac{} } func (m *LegacyAbac) String() string { return proto.CompactTextString(m) } func (*LegacyAbac) ProtoMessage() {} -func (*LegacyAbac) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } +func (*LegacyAbac) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } func (m *LegacyAbac) GetEnabled() bool { if m != nil { @@ -614,6 +790,139 @@ func (m *LegacyAbac) GetEnabled() bool { return false } +// Configuration options for the NetworkPolicy feature. +// https://kubernetes.io/docs/concepts/services-networking/networkpolicies/ +type NetworkPolicy struct { + // The selected network policy provider. + Provider NetworkPolicy_Provider `protobuf:"varint,1,opt,name=provider,enum=google.container.v1.NetworkPolicy_Provider" json:"provider,omitempty"` + // Whether network policy is enabled on the cluster. + Enabled bool `protobuf:"varint,2,opt,name=enabled" json:"enabled,omitempty"` +} + +func (m *NetworkPolicy) Reset() { *m = NetworkPolicy{} } +func (m *NetworkPolicy) String() string { return proto.CompactTextString(m) } +func (*NetworkPolicy) ProtoMessage() {} +func (*NetworkPolicy) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } + +func (m *NetworkPolicy) GetProvider() NetworkPolicy_Provider { + if m != nil { + return m.Provider + } + return NetworkPolicy_PROVIDER_UNSPECIFIED +} + +func (m *NetworkPolicy) GetEnabled() bool { + if m != nil { + return m.Enabled + } + return false +} + +// Configuration for controlling how IPs are allocated in the cluster. +type IPAllocationPolicy struct { + // Whether alias IPs will be used for pod IPs in the cluster. + UseIpAliases bool `protobuf:"varint,1,opt,name=use_ip_aliases,json=useIpAliases" json:"use_ip_aliases,omitempty"` + // Whether a new subnetwork will be created automatically for the cluster. + // + // This field is only applicable when `use_ip_aliases` is true. + CreateSubnetwork bool `protobuf:"varint,2,opt,name=create_subnetwork,json=createSubnetwork" json:"create_subnetwork,omitempty"` + // A custom subnetwork name to be used if `create_subnetwork` is true. If + // this field is empty, then an automatic name will be chosen for the new + // subnetwork. + SubnetworkName string `protobuf:"bytes,3,opt,name=subnetwork_name,json=subnetworkName" json:"subnetwork_name,omitempty"` + // The IP address range for the cluster pod IPs. If this field is set, then + // `cluster.cluster_ipv4_cidr` must be left blank. + // + // This field is only applicable when `use_ip_aliases` is true. + // + // Set to blank to have a range will be chosen with the default size. + // + // Set to /netmask (e.g. `/14`) to have a range be chosen with a specific + // netmask. + // + // Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) + // notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. + // `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range + // to use. + ClusterIpv4Cidr string `protobuf:"bytes,4,opt,name=cluster_ipv4_cidr,json=clusterIpv4Cidr" json:"cluster_ipv4_cidr,omitempty"` + // The IP address range of the instance IPs in this cluster. + // + // This is applicable only if `create_subnetwork` is true. + // + // Set to blank to have a range will be chosen with the default size. + // + // Set to /netmask (e.g. `/14`) to have a range be chosen with a specific + // netmask. + // + // Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) + // notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. + // `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range + // to use. + NodeIpv4Cidr string `protobuf:"bytes,5,opt,name=node_ipv4_cidr,json=nodeIpv4Cidr" json:"node_ipv4_cidr,omitempty"` + // The IP address range of the services IPs in this cluster. If blank, a range + // will be automatically chosen with the default size. + // + // This field is only applicable when `use_ip_aliases` is true. + // + // Set to blank to have a range will be chosen with the default size. + // + // Set to /netmask (e.g. `/14`) to have a range be chosen with a specific + // netmask. + // + // Set to a [CIDR](http://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) + // notation (e.g. `10.96.0.0/14`) from the RFC-1918 private networks (e.g. + // `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`) to pick a specific range + // to use. + ServicesIpv4Cidr string `protobuf:"bytes,6,opt,name=services_ipv4_cidr,json=servicesIpv4Cidr" json:"services_ipv4_cidr,omitempty"` +} + +func (m *IPAllocationPolicy) Reset() { *m = IPAllocationPolicy{} } +func (m *IPAllocationPolicy) String() string { return proto.CompactTextString(m) } +func (*IPAllocationPolicy) ProtoMessage() {} +func (*IPAllocationPolicy) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } + +func (m *IPAllocationPolicy) GetUseIpAliases() bool { + if m != nil { + return m.UseIpAliases + } + return false +} + +func (m *IPAllocationPolicy) GetCreateSubnetwork() bool { + if m != nil { + return m.CreateSubnetwork + } + return false +} + +func (m *IPAllocationPolicy) GetSubnetworkName() string { + if m != nil { + return m.SubnetworkName + } + return "" +} + +func (m *IPAllocationPolicy) GetClusterIpv4Cidr() string { + if m != nil { + return m.ClusterIpv4Cidr + } + return "" +} + +func (m *IPAllocationPolicy) GetNodeIpv4Cidr() string { + if m != nil { + return m.NodeIpv4Cidr + } + return "" +} + +func (m *IPAllocationPolicy) GetServicesIpv4Cidr() string { + if m != nil { + return m.ServicesIpv4Cidr + } + return "" +} + // A Google Container Engine cluster. type Cluster struct { // The name of this cluster. The name must be unique within this project @@ -699,6 +1008,13 @@ type Cluster struct { LabelFingerprint string `protobuf:"bytes,16,opt,name=label_fingerprint,json=labelFingerprint" json:"label_fingerprint,omitempty"` // Configuration for the legacy ABAC authorization mode. LegacyAbac *LegacyAbac `protobuf:"bytes,18,opt,name=legacy_abac,json=legacyAbac" json:"legacy_abac,omitempty"` + // Configuration options for the NetworkPolicy feature. + NetworkPolicy *NetworkPolicy `protobuf:"bytes,19,opt,name=network_policy,json=networkPolicy" json:"network_policy,omitempty"` + // Configuration for cluster IP allocation. + IpAllocationPolicy *IPAllocationPolicy `protobuf:"bytes,20,opt,name=ip_allocation_policy,json=ipAllocationPolicy" json:"ip_allocation_policy,omitempty"` + // Master authorized networks is a Beta feature. + // The configuration options for master authorized networks feature. + MasterAuthorizedNetworksConfig *MasterAuthorizedNetworksConfig `protobuf:"bytes,22,opt,name=master_authorized_networks_config,json=masterAuthorizedNetworksConfig" json:"master_authorized_networks_config,omitempty"` // [Output only] Server-defined URL for the resource. SelfLink string `protobuf:"bytes,100,opt,name=self_link,json=selfLink" json:"self_link,omitempty"` // [Output only] The name of the Google Compute Engine @@ -755,7 +1071,7 @@ type Cluster struct { func (m *Cluster) Reset() { *m = Cluster{} } func (m *Cluster) String() string { return proto.CompactTextString(m) } func (*Cluster) ProtoMessage() {} -func (*Cluster) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } +func (*Cluster) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } func (m *Cluster) GetName() string { if m != nil { @@ -876,6 +1192,27 @@ func (m *Cluster) GetLegacyAbac() *LegacyAbac { return nil } +func (m *Cluster) GetNetworkPolicy() *NetworkPolicy { + if m != nil { + return m.NetworkPolicy + } + return nil +} + +func (m *Cluster) GetIpAllocationPolicy() *IPAllocationPolicy { + if m != nil { + return m.IpAllocationPolicy + } + return nil +} + +func (m *Cluster) GetMasterAuthorizedNetworksConfig() *MasterAuthorizedNetworksConfig { + if m != nil { + return m.MasterAuthorizedNetworksConfig + } + return nil +} + func (m *Cluster) GetSelfLink() string { if m != nil { return m.SelfLink @@ -1011,6 +1348,9 @@ type ClusterUpdate struct { // // This list must always include the cluster's primary zone. DesiredLocations []string `protobuf:"bytes,10,rep,name=desired_locations,json=desiredLocations" json:"desired_locations,omitempty"` + // Master authorized networks is a Beta feature. + // The desired configuration options for master authorized networks feature. + DesiredMasterAuthorizedNetworksConfig *MasterAuthorizedNetworksConfig `protobuf:"bytes,12,opt,name=desired_master_authorized_networks_config,json=desiredMasterAuthorizedNetworksConfig" json:"desired_master_authorized_networks_config,omitempty"` // The Kubernetes version to change the master to. The only valid value is the // latest supported version. Use "-" to have the server automatically select // the latest version. @@ -1020,7 +1360,7 @@ type ClusterUpdate struct { func (m *ClusterUpdate) Reset() { *m = ClusterUpdate{} } func (m *ClusterUpdate) String() string { return proto.CompactTextString(m) } func (*ClusterUpdate) ProtoMessage() {} -func (*ClusterUpdate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } +func (*ClusterUpdate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } func (m *ClusterUpdate) GetDesiredNodeVersion() string { if m != nil { @@ -1071,6 +1411,13 @@ func (m *ClusterUpdate) GetDesiredLocations() []string { return nil } +func (m *ClusterUpdate) GetDesiredMasterAuthorizedNetworksConfig() *MasterAuthorizedNetworksConfig { + if m != nil { + return m.DesiredMasterAuthorizedNetworksConfig + } + return nil +} + func (m *ClusterUpdate) GetDesiredMasterVersion() string { if m != nil { return m.DesiredMasterVersion @@ -1099,12 +1446,18 @@ type Operation struct { SelfLink string `protobuf:"bytes,6,opt,name=self_link,json=selfLink" json:"self_link,omitempty"` // Server-defined URL for the target of the operation. TargetLink string `protobuf:"bytes,7,opt,name=target_link,json=targetLink" json:"target_link,omitempty"` + // [Output only] The time the operation started, in + // [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format. + StartTime string `protobuf:"bytes,10,opt,name=start_time,json=startTime" json:"start_time,omitempty"` + // [Output only] The time the operation completed, in + // [RFC3339](https://www.ietf.org/rfc/rfc3339.txt) text format. + EndTime string `protobuf:"bytes,11,opt,name=end_time,json=endTime" json:"end_time,omitempty"` } func (m *Operation) Reset() { *m = Operation{} } func (m *Operation) String() string { return proto.CompactTextString(m) } func (*Operation) ProtoMessage() {} -func (*Operation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } +func (*Operation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } func (m *Operation) GetName() string { if m != nil { @@ -1162,6 +1515,20 @@ func (m *Operation) GetTargetLink() string { return "" } +func (m *Operation) GetStartTime() string { + if m != nil { + return m.StartTime + } + return "" +} + +func (m *Operation) GetEndTime() string { + if m != nil { + return m.EndTime + } + return "" +} + // CreateClusterRequest creates a cluster. type CreateClusterRequest struct { // The Google Developers Console [project ID or project @@ -1179,7 +1546,7 @@ type CreateClusterRequest struct { func (m *CreateClusterRequest) Reset() { *m = CreateClusterRequest{} } func (m *CreateClusterRequest) String() string { return proto.CompactTextString(m) } func (*CreateClusterRequest) ProtoMessage() {} -func (*CreateClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } +func (*CreateClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} } func (m *CreateClusterRequest) GetProjectId() string { if m != nil { @@ -1218,7 +1585,7 @@ type GetClusterRequest struct { func (m *GetClusterRequest) Reset() { *m = GetClusterRequest{} } func (m *GetClusterRequest) String() string { return proto.CompactTextString(m) } func (*GetClusterRequest) ProtoMessage() {} -func (*GetClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } +func (*GetClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } func (m *GetClusterRequest) GetProjectId() string { if m != nil { @@ -1259,7 +1626,7 @@ type UpdateClusterRequest struct { func (m *UpdateClusterRequest) Reset() { *m = UpdateClusterRequest{} } func (m *UpdateClusterRequest) String() string { return proto.CompactTextString(m) } func (*UpdateClusterRequest) ProtoMessage() {} -func (*UpdateClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } +func (*UpdateClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } func (m *UpdateClusterRequest) GetProjectId() string { if m != nil { @@ -1289,6 +1656,388 @@ func (m *UpdateClusterRequest) GetUpdate() *ClusterUpdate { return nil } +// UpdateNodePoolRequests update a node pool's image and/or version. +type UpdateNodePoolRequest struct { + // The Google Developers Console [project ID or project + // number](https://support.google.com/cloud/answer/6158840). + ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId" json:"project_id,omitempty"` + // The name of the Google Compute Engine + // [zone](/compute/docs/zones#available) in which the cluster + // resides. + Zone string `protobuf:"bytes,2,opt,name=zone" json:"zone,omitempty"` + // The name of the cluster to upgrade. + ClusterId string `protobuf:"bytes,3,opt,name=cluster_id,json=clusterId" json:"cluster_id,omitempty"` + // The name of the node pool to upgrade. + NodePoolId string `protobuf:"bytes,4,opt,name=node_pool_id,json=nodePoolId" json:"node_pool_id,omitempty"` + // The Kubernetes version to change the nodes to (typically an + // upgrade). Use `-` to upgrade to the latest version supported by + // the server. + NodeVersion string `protobuf:"bytes,5,opt,name=node_version,json=nodeVersion" json:"node_version,omitempty"` + // The desired image type for the node pool. + ImageType string `protobuf:"bytes,6,opt,name=image_type,json=imageType" json:"image_type,omitempty"` +} + +func (m *UpdateNodePoolRequest) Reset() { *m = UpdateNodePoolRequest{} } +func (m *UpdateNodePoolRequest) String() string { return proto.CompactTextString(m) } +func (*UpdateNodePoolRequest) ProtoMessage() {} +func (*UpdateNodePoolRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } + +func (m *UpdateNodePoolRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *UpdateNodePoolRequest) GetZone() string { + if m != nil { + return m.Zone + } + return "" +} + +func (m *UpdateNodePoolRequest) GetClusterId() string { + if m != nil { + return m.ClusterId + } + return "" +} + +func (m *UpdateNodePoolRequest) GetNodePoolId() string { + if m != nil { + return m.NodePoolId + } + return "" +} + +func (m *UpdateNodePoolRequest) GetNodeVersion() string { + if m != nil { + return m.NodeVersion + } + return "" +} + +func (m *UpdateNodePoolRequest) GetImageType() string { + if m != nil { + return m.ImageType + } + return "" +} + +// SetNodePoolAutoscalingRequest sets the autoscaler settings of a node pool. +type SetNodePoolAutoscalingRequest struct { + // The Google Developers Console [project ID or project + // number](https://support.google.com/cloud/answer/6158840). + ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId" json:"project_id,omitempty"` + // The name of the Google Compute Engine + // [zone](/compute/docs/zones#available) in which the cluster + // resides. + Zone string `protobuf:"bytes,2,opt,name=zone" json:"zone,omitempty"` + // The name of the cluster to upgrade. + ClusterId string `protobuf:"bytes,3,opt,name=cluster_id,json=clusterId" json:"cluster_id,omitempty"` + // The name of the node pool to upgrade. + NodePoolId string `protobuf:"bytes,4,opt,name=node_pool_id,json=nodePoolId" json:"node_pool_id,omitempty"` + // Autoscaling configuration for the node pool. + Autoscaling *NodePoolAutoscaling `protobuf:"bytes,5,opt,name=autoscaling" json:"autoscaling,omitempty"` +} + +func (m *SetNodePoolAutoscalingRequest) Reset() { *m = SetNodePoolAutoscalingRequest{} } +func (m *SetNodePoolAutoscalingRequest) String() string { return proto.CompactTextString(m) } +func (*SetNodePoolAutoscalingRequest) ProtoMessage() {} +func (*SetNodePoolAutoscalingRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } + +func (m *SetNodePoolAutoscalingRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *SetNodePoolAutoscalingRequest) GetZone() string { + if m != nil { + return m.Zone + } + return "" +} + +func (m *SetNodePoolAutoscalingRequest) GetClusterId() string { + if m != nil { + return m.ClusterId + } + return "" +} + +func (m *SetNodePoolAutoscalingRequest) GetNodePoolId() string { + if m != nil { + return m.NodePoolId + } + return "" +} + +func (m *SetNodePoolAutoscalingRequest) GetAutoscaling() *NodePoolAutoscaling { + if m != nil { + return m.Autoscaling + } + return nil +} + +// SetLoggingServiceRequest sets the logging service of a cluster. +type SetLoggingServiceRequest struct { + // The Google Developers Console [project ID or project + // number](https://support.google.com/cloud/answer/6158840). + ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId" json:"project_id,omitempty"` + // The name of the Google Compute Engine + // [zone](/compute/docs/zones#available) in which the cluster + // resides. + Zone string `protobuf:"bytes,2,opt,name=zone" json:"zone,omitempty"` + // The name of the cluster to upgrade. + ClusterId string `protobuf:"bytes,3,opt,name=cluster_id,json=clusterId" json:"cluster_id,omitempty"` + // The logging service the cluster should use to write metrics. + // Currently available options: + // + // * "logging.googleapis.com" - the Google Cloud Logging service + // * "none" - no metrics will be exported from the cluster + LoggingService string `protobuf:"bytes,4,opt,name=logging_service,json=loggingService" json:"logging_service,omitempty"` +} + +func (m *SetLoggingServiceRequest) Reset() { *m = SetLoggingServiceRequest{} } +func (m *SetLoggingServiceRequest) String() string { return proto.CompactTextString(m) } +func (*SetLoggingServiceRequest) ProtoMessage() {} +func (*SetLoggingServiceRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } + +func (m *SetLoggingServiceRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *SetLoggingServiceRequest) GetZone() string { + if m != nil { + return m.Zone + } + return "" +} + +func (m *SetLoggingServiceRequest) GetClusterId() string { + if m != nil { + return m.ClusterId + } + return "" +} + +func (m *SetLoggingServiceRequest) GetLoggingService() string { + if m != nil { + return m.LoggingService + } + return "" +} + +// SetMonitoringServiceRequest sets the monitoring service of a cluster. +type SetMonitoringServiceRequest struct { + // The Google Developers Console [project ID or project + // number](https://support.google.com/cloud/answer/6158840). + ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId" json:"project_id,omitempty"` + // The name of the Google Compute Engine + // [zone](/compute/docs/zones#available) in which the cluster + // resides. + Zone string `protobuf:"bytes,2,opt,name=zone" json:"zone,omitempty"` + // The name of the cluster to upgrade. + ClusterId string `protobuf:"bytes,3,opt,name=cluster_id,json=clusterId" json:"cluster_id,omitempty"` + // The monitoring service the cluster should use to write metrics. + // Currently available options: + // + // * "monitoring.googleapis.com" - the Google Cloud Monitoring service + // * "none" - no metrics will be exported from the cluster + MonitoringService string `protobuf:"bytes,4,opt,name=monitoring_service,json=monitoringService" json:"monitoring_service,omitempty"` +} + +func (m *SetMonitoringServiceRequest) Reset() { *m = SetMonitoringServiceRequest{} } +func (m *SetMonitoringServiceRequest) String() string { return proto.CompactTextString(m) } +func (*SetMonitoringServiceRequest) ProtoMessage() {} +func (*SetMonitoringServiceRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} } + +func (m *SetMonitoringServiceRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *SetMonitoringServiceRequest) GetZone() string { + if m != nil { + return m.Zone + } + return "" +} + +func (m *SetMonitoringServiceRequest) GetClusterId() string { + if m != nil { + return m.ClusterId + } + return "" +} + +func (m *SetMonitoringServiceRequest) GetMonitoringService() string { + if m != nil { + return m.MonitoringService + } + return "" +} + +// SetAddonsConfigRequest sets the addons associated with the cluster. +type SetAddonsConfigRequest struct { + // The Google Developers Console [project ID or project + // number](https://support.google.com/cloud/answer/6158840). + ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId" json:"project_id,omitempty"` + // The name of the Google Compute Engine + // [zone](/compute/docs/zones#available) in which the cluster + // resides. + Zone string `protobuf:"bytes,2,opt,name=zone" json:"zone,omitempty"` + // The name of the cluster to upgrade. + ClusterId string `protobuf:"bytes,3,opt,name=cluster_id,json=clusterId" json:"cluster_id,omitempty"` + // The desired configurations for the various addons available to run in the + // cluster. + AddonsConfig *AddonsConfig `protobuf:"bytes,4,opt,name=addons_config,json=addonsConfig" json:"addons_config,omitempty"` +} + +func (m *SetAddonsConfigRequest) Reset() { *m = SetAddonsConfigRequest{} } +func (m *SetAddonsConfigRequest) String() string { return proto.CompactTextString(m) } +func (*SetAddonsConfigRequest) ProtoMessage() {} +func (*SetAddonsConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} } + +func (m *SetAddonsConfigRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *SetAddonsConfigRequest) GetZone() string { + if m != nil { + return m.Zone + } + return "" +} + +func (m *SetAddonsConfigRequest) GetClusterId() string { + if m != nil { + return m.ClusterId + } + return "" +} + +func (m *SetAddonsConfigRequest) GetAddonsConfig() *AddonsConfig { + if m != nil { + return m.AddonsConfig + } + return nil +} + +// SetLocationsRequest sets the locations of the cluster. +type SetLocationsRequest struct { + // The Google Developers Console [project ID or project + // number](https://support.google.com/cloud/answer/6158840). + ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId" json:"project_id,omitempty"` + // The name of the Google Compute Engine + // [zone](/compute/docs/zones#available) in which the cluster + // resides. + Zone string `protobuf:"bytes,2,opt,name=zone" json:"zone,omitempty"` + // The name of the cluster to upgrade. + ClusterId string `protobuf:"bytes,3,opt,name=cluster_id,json=clusterId" json:"cluster_id,omitempty"` + // The desired list of Google Compute Engine + // [locations](/compute/docs/zones#available) in which the cluster's nodes + // should be located. Changing the locations a cluster is in will result + // in nodes being either created or removed from the cluster, depending on + // whether locations are being added or removed. + // + // This list must always include the cluster's primary zone. + Locations []string `protobuf:"bytes,4,rep,name=locations" json:"locations,omitempty"` +} + +func (m *SetLocationsRequest) Reset() { *m = SetLocationsRequest{} } +func (m *SetLocationsRequest) String() string { return proto.CompactTextString(m) } +func (*SetLocationsRequest) ProtoMessage() {} +func (*SetLocationsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} } + +func (m *SetLocationsRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *SetLocationsRequest) GetZone() string { + if m != nil { + return m.Zone + } + return "" +} + +func (m *SetLocationsRequest) GetClusterId() string { + if m != nil { + return m.ClusterId + } + return "" +} + +func (m *SetLocationsRequest) GetLocations() []string { + if m != nil { + return m.Locations + } + return nil +} + +// UpdateMasterRequest updates the master of the cluster. +type UpdateMasterRequest struct { + // The Google Developers Console [project ID or project + // number](https://support.google.com/cloud/answer/6158840). + ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId" json:"project_id,omitempty"` + // The name of the Google Compute Engine + // [zone](/compute/docs/zones#available) in which the cluster + // resides. + Zone string `protobuf:"bytes,2,opt,name=zone" json:"zone,omitempty"` + // The name of the cluster to upgrade. + ClusterId string `protobuf:"bytes,3,opt,name=cluster_id,json=clusterId" json:"cluster_id,omitempty"` + // The Kubernetes version to change the master to. The only valid value is the + // latest supported version. Use "-" to have the server automatically select + // the latest version. + MasterVersion string `protobuf:"bytes,4,opt,name=master_version,json=masterVersion" json:"master_version,omitempty"` +} + +func (m *UpdateMasterRequest) Reset() { *m = UpdateMasterRequest{} } +func (m *UpdateMasterRequest) String() string { return proto.CompactTextString(m) } +func (*UpdateMasterRequest) ProtoMessage() {} +func (*UpdateMasterRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} } + +func (m *UpdateMasterRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *UpdateMasterRequest) GetZone() string { + if m != nil { + return m.Zone + } + return "" +} + +func (m *UpdateMasterRequest) GetClusterId() string { + if m != nil { + return m.ClusterId + } + return "" +} + +func (m *UpdateMasterRequest) GetMasterVersion() string { + if m != nil { + return m.MasterVersion + } + return "" +} + // SetMasterAuthRequest updates the admin password of a cluster. type SetMasterAuthRequest struct { // The Google Developers Console [project ID or project @@ -1309,7 +2058,7 @@ type SetMasterAuthRequest struct { func (m *SetMasterAuthRequest) Reset() { *m = SetMasterAuthRequest{} } func (m *SetMasterAuthRequest) String() string { return proto.CompactTextString(m) } func (*SetMasterAuthRequest) ProtoMessage() {} -func (*SetMasterAuthRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } +func (*SetMasterAuthRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} } func (m *SetMasterAuthRequest) GetProjectId() string { if m != nil { @@ -1362,7 +2111,7 @@ type DeleteClusterRequest struct { func (m *DeleteClusterRequest) Reset() { *m = DeleteClusterRequest{} } func (m *DeleteClusterRequest) String() string { return proto.CompactTextString(m) } func (*DeleteClusterRequest) ProtoMessage() {} -func (*DeleteClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } +func (*DeleteClusterRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} } func (m *DeleteClusterRequest) GetProjectId() string { if m != nil { @@ -1399,7 +2148,7 @@ type ListClustersRequest struct { func (m *ListClustersRequest) Reset() { *m = ListClustersRequest{} } func (m *ListClustersRequest) String() string { return proto.CompactTextString(m) } func (*ListClustersRequest) ProtoMessage() {} -func (*ListClustersRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} } +func (*ListClustersRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} } func (m *ListClustersRequest) GetProjectId() string { if m != nil { @@ -1428,7 +2177,7 @@ type ListClustersResponse struct { func (m *ListClustersResponse) Reset() { *m = ListClustersResponse{} } func (m *ListClustersResponse) String() string { return proto.CompactTextString(m) } func (*ListClustersResponse) ProtoMessage() {} -func (*ListClustersResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } +func (*ListClustersResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} } func (m *ListClustersResponse) GetClusters() []*Cluster { if m != nil { @@ -1460,7 +2209,7 @@ type GetOperationRequest struct { func (m *GetOperationRequest) Reset() { *m = GetOperationRequest{} } func (m *GetOperationRequest) String() string { return proto.CompactTextString(m) } func (*GetOperationRequest) ProtoMessage() {} -func (*GetOperationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } +func (*GetOperationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} } func (m *GetOperationRequest) GetProjectId() string { if m != nil { @@ -1496,7 +2245,7 @@ type ListOperationsRequest struct { func (m *ListOperationsRequest) Reset() { *m = ListOperationsRequest{} } func (m *ListOperationsRequest) String() string { return proto.CompactTextString(m) } func (*ListOperationsRequest) ProtoMessage() {} -func (*ListOperationsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } +func (*ListOperationsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} } func (m *ListOperationsRequest) GetProjectId() string { if m != nil { @@ -1527,7 +2276,7 @@ type CancelOperationRequest struct { func (m *CancelOperationRequest) Reset() { *m = CancelOperationRequest{} } func (m *CancelOperationRequest) String() string { return proto.CompactTextString(m) } func (*CancelOperationRequest) ProtoMessage() {} -func (*CancelOperationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } +func (*CancelOperationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} } func (m *CancelOperationRequest) GetProjectId() string { if m != nil { @@ -1562,7 +2311,7 @@ type ListOperationsResponse struct { func (m *ListOperationsResponse) Reset() { *m = ListOperationsResponse{} } func (m *ListOperationsResponse) String() string { return proto.CompactTextString(m) } func (*ListOperationsResponse) ProtoMessage() {} -func (*ListOperationsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } +func (*ListOperationsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} } func (m *ListOperationsResponse) GetOperations() []*Operation { if m != nil { @@ -1591,7 +2340,7 @@ type GetServerConfigRequest struct { func (m *GetServerConfigRequest) Reset() { *m = GetServerConfigRequest{} } func (m *GetServerConfigRequest) String() string { return proto.CompactTextString(m) } func (*GetServerConfigRequest) ProtoMessage() {} -func (*GetServerConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} } +func (*GetServerConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{32} } func (m *GetServerConfigRequest) GetProjectId() string { if m != nil { @@ -1624,7 +2373,7 @@ type ServerConfig struct { func (m *ServerConfig) Reset() { *m = ServerConfig{} } func (m *ServerConfig) String() string { return proto.CompactTextString(m) } func (*ServerConfig) ProtoMessage() {} -func (*ServerConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} } +func (*ServerConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{33} } func (m *ServerConfig) GetDefaultClusterVersion() string { if m != nil { @@ -1679,7 +2428,7 @@ type CreateNodePoolRequest struct { func (m *CreateNodePoolRequest) Reset() { *m = CreateNodePoolRequest{} } func (m *CreateNodePoolRequest) String() string { return proto.CompactTextString(m) } func (*CreateNodePoolRequest) ProtoMessage() {} -func (*CreateNodePoolRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} } +func (*CreateNodePoolRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{34} } func (m *CreateNodePoolRequest) GetProjectId() string { if m != nil { @@ -1727,7 +2476,7 @@ type DeleteNodePoolRequest struct { func (m *DeleteNodePoolRequest) Reset() { *m = DeleteNodePoolRequest{} } func (m *DeleteNodePoolRequest) String() string { return proto.CompactTextString(m) } func (*DeleteNodePoolRequest) ProtoMessage() {} -func (*DeleteNodePoolRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} } +func (*DeleteNodePoolRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{35} } func (m *DeleteNodePoolRequest) GetProjectId() string { if m != nil { @@ -1773,7 +2522,7 @@ type ListNodePoolsRequest struct { func (m *ListNodePoolsRequest) Reset() { *m = ListNodePoolsRequest{} } func (m *ListNodePoolsRequest) String() string { return proto.CompactTextString(m) } func (*ListNodePoolsRequest) ProtoMessage() {} -func (*ListNodePoolsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} } +func (*ListNodePoolsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{36} } func (m *ListNodePoolsRequest) GetProjectId() string { if m != nil { @@ -1814,7 +2563,7 @@ type GetNodePoolRequest struct { func (m *GetNodePoolRequest) Reset() { *m = GetNodePoolRequest{} } func (m *GetNodePoolRequest) String() string { return proto.CompactTextString(m) } func (*GetNodePoolRequest) ProtoMessage() {} -func (*GetNodePoolRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} } +func (*GetNodePoolRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{37} } func (m *GetNodePoolRequest) GetProjectId() string { if m != nil { @@ -1883,7 +2632,7 @@ type NodePool struct { func (m *NodePool) Reset() { *m = NodePool{} } func (m *NodePool) String() string { return proto.CompactTextString(m) } func (*NodePool) ProtoMessage() {} -func (*NodePool) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} } +func (*NodePool) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{38} } func (m *NodePool) GetName() string { if m != nil { @@ -1974,7 +2723,7 @@ type NodeManagement struct { func (m *NodeManagement) Reset() { *m = NodeManagement{} } func (m *NodeManagement) String() string { return proto.CompactTextString(m) } func (*NodeManagement) ProtoMessage() {} -func (*NodeManagement) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} } +func (*NodeManagement) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{39} } func (m *NodeManagement) GetAutoUpgrade() bool { if m != nil { @@ -2012,7 +2761,7 @@ type AutoUpgradeOptions struct { func (m *AutoUpgradeOptions) Reset() { *m = AutoUpgradeOptions{} } func (m *AutoUpgradeOptions) String() string { return proto.CompactTextString(m) } func (*AutoUpgradeOptions) ProtoMessage() {} -func (*AutoUpgradeOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} } +func (*AutoUpgradeOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{40} } func (m *AutoUpgradeOptions) GetAutoUpgradeStartTime() string { if m != nil { @@ -2049,7 +2798,7 @@ type SetNodePoolManagementRequest struct { func (m *SetNodePoolManagementRequest) Reset() { *m = SetNodePoolManagementRequest{} } func (m *SetNodePoolManagementRequest) String() string { return proto.CompactTextString(m) } func (*SetNodePoolManagementRequest) ProtoMessage() {} -func (*SetNodePoolManagementRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} } +func (*SetNodePoolManagementRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{41} } func (m *SetNodePoolManagementRequest) GetProjectId() string { if m != nil { @@ -2086,6 +2835,64 @@ func (m *SetNodePoolManagementRequest) GetManagement() *NodeManagement { return nil } +// SetNodePoolSizeRequest sets the size a node +// pool. +type SetNodePoolSizeRequest struct { + // The Google Developers Console [project ID or project + // number](https://support.google.com/cloud/answer/6158840). + ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId" json:"project_id,omitempty"` + // The name of the Google Compute Engine + // [zone](/compute/docs/zones#available) in which the cluster + // resides. + Zone string `protobuf:"bytes,2,opt,name=zone" json:"zone,omitempty"` + // The name of the cluster to update. + ClusterId string `protobuf:"bytes,3,opt,name=cluster_id,json=clusterId" json:"cluster_id,omitempty"` + // The name of the node pool to update. + NodePoolId string `protobuf:"bytes,4,opt,name=node_pool_id,json=nodePoolId" json:"node_pool_id,omitempty"` + // The desired node count for the pool. + NodeCount int32 `protobuf:"varint,5,opt,name=node_count,json=nodeCount" json:"node_count,omitempty"` +} + +func (m *SetNodePoolSizeRequest) Reset() { *m = SetNodePoolSizeRequest{} } +func (m *SetNodePoolSizeRequest) String() string { return proto.CompactTextString(m) } +func (*SetNodePoolSizeRequest) ProtoMessage() {} +func (*SetNodePoolSizeRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{42} } + +func (m *SetNodePoolSizeRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *SetNodePoolSizeRequest) GetZone() string { + if m != nil { + return m.Zone + } + return "" +} + +func (m *SetNodePoolSizeRequest) GetClusterId() string { + if m != nil { + return m.ClusterId + } + return "" +} + +func (m *SetNodePoolSizeRequest) GetNodePoolId() string { + if m != nil { + return m.NodePoolId + } + return "" +} + +func (m *SetNodePoolSizeRequest) GetNodeCount() int32 { + if m != nil { + return m.NodeCount + } + return 0 +} + // RollbackNodePoolUpgradeRequest rollbacks the previously Aborted or Failed // NodePool upgrade. This will be an no-op if the last upgrade successfully // completed. @@ -2106,7 +2913,7 @@ type RollbackNodePoolUpgradeRequest struct { func (m *RollbackNodePoolUpgradeRequest) Reset() { *m = RollbackNodePoolUpgradeRequest{} } func (m *RollbackNodePoolUpgradeRequest) String() string { return proto.CompactTextString(m) } func (*RollbackNodePoolUpgradeRequest) ProtoMessage() {} -func (*RollbackNodePoolUpgradeRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} } +func (*RollbackNodePoolUpgradeRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{43} } func (m *RollbackNodePoolUpgradeRequest) GetProjectId() string { if m != nil { @@ -2145,7 +2952,7 @@ type ListNodePoolsResponse struct { func (m *ListNodePoolsResponse) Reset() { *m = ListNodePoolsResponse{} } func (m *ListNodePoolsResponse) String() string { return proto.CompactTextString(m) } func (*ListNodePoolsResponse) ProtoMessage() {} -func (*ListNodePoolsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} } +func (*ListNodePoolsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{44} } func (m *ListNodePoolsResponse) GetNodePools() []*NodePool { if m != nil { @@ -2170,7 +2977,7 @@ type NodePoolAutoscaling struct { func (m *NodePoolAutoscaling) Reset() { *m = NodePoolAutoscaling{} } func (m *NodePoolAutoscaling) String() string { return proto.CompactTextString(m) } func (*NodePoolAutoscaling) ProtoMessage() {} -func (*NodePoolAutoscaling) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{32} } +func (*NodePoolAutoscaling) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{45} } func (m *NodePoolAutoscaling) GetEnabled() bool { if m != nil { @@ -2220,7 +3027,7 @@ type SetLabelsRequest struct { func (m *SetLabelsRequest) Reset() { *m = SetLabelsRequest{} } func (m *SetLabelsRequest) String() string { return proto.CompactTextString(m) } func (*SetLabelsRequest) ProtoMessage() {} -func (*SetLabelsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{33} } +func (*SetLabelsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{46} } func (m *SetLabelsRequest) GetProjectId() string { if m != nil { @@ -2276,7 +3083,7 @@ type SetLegacyAbacRequest struct { func (m *SetLegacyAbacRequest) Reset() { *m = SetLegacyAbacRequest{} } func (m *SetLegacyAbacRequest) String() string { return proto.CompactTextString(m) } func (*SetLegacyAbacRequest) ProtoMessage() {} -func (*SetLegacyAbacRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{34} } +func (*SetLegacyAbacRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{47} } func (m *SetLegacyAbacRequest) GetProjectId() string { if m != nil { @@ -2323,7 +3130,7 @@ type StartIPRotationRequest struct { func (m *StartIPRotationRequest) Reset() { *m = StartIPRotationRequest{} } func (m *StartIPRotationRequest) String() string { return proto.CompactTextString(m) } func (*StartIPRotationRequest) ProtoMessage() {} -func (*StartIPRotationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{35} } +func (*StartIPRotationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{48} } func (m *StartIPRotationRequest) GetProjectId() string { if m != nil { @@ -2362,7 +3169,7 @@ type CompleteIPRotationRequest struct { func (m *CompleteIPRotationRequest) Reset() { *m = CompleteIPRotationRequest{} } func (m *CompleteIPRotationRequest) String() string { return proto.CompactTextString(m) } func (*CompleteIPRotationRequest) ProtoMessage() {} -func (*CompleteIPRotationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{36} } +func (*CompleteIPRotationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{49} } func (m *CompleteIPRotationRequest) GetProjectId() string { if m != nil { @@ -2385,19 +3192,108 @@ func (m *CompleteIPRotationRequest) GetClusterId() string { return "" } +// AcceleratorConfig represents a Hardware Accelerator request. +type AcceleratorConfig struct { + // The number of the accelerator cards exposed to an instance. + AcceleratorCount int64 `protobuf:"varint,1,opt,name=accelerator_count,json=acceleratorCount" json:"accelerator_count,omitempty"` + // The accelerator type resource name. List of supported accelerators + // [here](/compute/docs/gpus/#Introduction) + AcceleratorType string `protobuf:"bytes,2,opt,name=accelerator_type,json=acceleratorType" json:"accelerator_type,omitempty"` +} + +func (m *AcceleratorConfig) Reset() { *m = AcceleratorConfig{} } +func (m *AcceleratorConfig) String() string { return proto.CompactTextString(m) } +func (*AcceleratorConfig) ProtoMessage() {} +func (*AcceleratorConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{50} } + +func (m *AcceleratorConfig) GetAcceleratorCount() int64 { + if m != nil { + return m.AcceleratorCount + } + return 0 +} + +func (m *AcceleratorConfig) GetAcceleratorType() string { + if m != nil { + return m.AcceleratorType + } + return "" +} + +// SetNetworkPolicyRequest enables/disables network policy for a cluster. +type SetNetworkPolicyRequest struct { + // The Google Developers Console [project ID or project + // number](https://developers.google.com/console/help/new/#projectnumber). + ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId" json:"project_id,omitempty"` + // The name of the Google Compute Engine + // [zone](/compute/docs/zones#available) in which the cluster + // resides. + Zone string `protobuf:"bytes,2,opt,name=zone" json:"zone,omitempty"` + // The name of the cluster. + ClusterId string `protobuf:"bytes,3,opt,name=cluster_id,json=clusterId" json:"cluster_id,omitempty"` + // Configuration options for the NetworkPolicy feature. + NetworkPolicy *NetworkPolicy `protobuf:"bytes,4,opt,name=network_policy,json=networkPolicy" json:"network_policy,omitempty"` +} + +func (m *SetNetworkPolicyRequest) Reset() { *m = SetNetworkPolicyRequest{} } +func (m *SetNetworkPolicyRequest) String() string { return proto.CompactTextString(m) } +func (*SetNetworkPolicyRequest) ProtoMessage() {} +func (*SetNetworkPolicyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{51} } + +func (m *SetNetworkPolicyRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *SetNetworkPolicyRequest) GetZone() string { + if m != nil { + return m.Zone + } + return "" +} + +func (m *SetNetworkPolicyRequest) GetClusterId() string { + if m != nil { + return m.ClusterId + } + return "" +} + +func (m *SetNetworkPolicyRequest) GetNetworkPolicy() *NetworkPolicy { + if m != nil { + return m.NetworkPolicy + } + return nil +} + func init() { proto.RegisterType((*NodeConfig)(nil), "google.container.v1.NodeConfig") proto.RegisterType((*MasterAuth)(nil), "google.container.v1.MasterAuth") + proto.RegisterType((*ClientCertificateConfig)(nil), "google.container.v1.ClientCertificateConfig") proto.RegisterType((*AddonsConfig)(nil), "google.container.v1.AddonsConfig") proto.RegisterType((*HttpLoadBalancing)(nil), "google.container.v1.HttpLoadBalancing") proto.RegisterType((*HorizontalPodAutoscaling)(nil), "google.container.v1.HorizontalPodAutoscaling") + proto.RegisterType((*KubernetesDashboard)(nil), "google.container.v1.KubernetesDashboard") + proto.RegisterType((*MasterAuthorizedNetworksConfig)(nil), "google.container.v1.MasterAuthorizedNetworksConfig") + proto.RegisterType((*MasterAuthorizedNetworksConfig_CidrBlock)(nil), "google.container.v1.MasterAuthorizedNetworksConfig.CidrBlock") proto.RegisterType((*LegacyAbac)(nil), "google.container.v1.LegacyAbac") + proto.RegisterType((*NetworkPolicy)(nil), "google.container.v1.NetworkPolicy") + proto.RegisterType((*IPAllocationPolicy)(nil), "google.container.v1.IPAllocationPolicy") proto.RegisterType((*Cluster)(nil), "google.container.v1.Cluster") proto.RegisterType((*ClusterUpdate)(nil), "google.container.v1.ClusterUpdate") proto.RegisterType((*Operation)(nil), "google.container.v1.Operation") proto.RegisterType((*CreateClusterRequest)(nil), "google.container.v1.CreateClusterRequest") proto.RegisterType((*GetClusterRequest)(nil), "google.container.v1.GetClusterRequest") proto.RegisterType((*UpdateClusterRequest)(nil), "google.container.v1.UpdateClusterRequest") + proto.RegisterType((*UpdateNodePoolRequest)(nil), "google.container.v1.UpdateNodePoolRequest") + proto.RegisterType((*SetNodePoolAutoscalingRequest)(nil), "google.container.v1.SetNodePoolAutoscalingRequest") + proto.RegisterType((*SetLoggingServiceRequest)(nil), "google.container.v1.SetLoggingServiceRequest") + proto.RegisterType((*SetMonitoringServiceRequest)(nil), "google.container.v1.SetMonitoringServiceRequest") + proto.RegisterType((*SetAddonsConfigRequest)(nil), "google.container.v1.SetAddonsConfigRequest") + proto.RegisterType((*SetLocationsRequest)(nil), "google.container.v1.SetLocationsRequest") + proto.RegisterType((*UpdateMasterRequest)(nil), "google.container.v1.UpdateMasterRequest") proto.RegisterType((*SetMasterAuthRequest)(nil), "google.container.v1.SetMasterAuthRequest") proto.RegisterType((*DeleteClusterRequest)(nil), "google.container.v1.DeleteClusterRequest") proto.RegisterType((*ListClustersRequest)(nil), "google.container.v1.ListClustersRequest") @@ -2416,6 +3312,7 @@ func init() { proto.RegisterType((*NodeManagement)(nil), "google.container.v1.NodeManagement") proto.RegisterType((*AutoUpgradeOptions)(nil), "google.container.v1.AutoUpgradeOptions") proto.RegisterType((*SetNodePoolManagementRequest)(nil), "google.container.v1.SetNodePoolManagementRequest") + proto.RegisterType((*SetNodePoolSizeRequest)(nil), "google.container.v1.SetNodePoolSizeRequest") proto.RegisterType((*RollbackNodePoolUpgradeRequest)(nil), "google.container.v1.RollbackNodePoolUpgradeRequest") proto.RegisterType((*ListNodePoolsResponse)(nil), "google.container.v1.ListNodePoolsResponse") proto.RegisterType((*NodePoolAutoscaling)(nil), "google.container.v1.NodePoolAutoscaling") @@ -2423,6 +3320,9 @@ func init() { proto.RegisterType((*SetLegacyAbacRequest)(nil), "google.container.v1.SetLegacyAbacRequest") proto.RegisterType((*StartIPRotationRequest)(nil), "google.container.v1.StartIPRotationRequest") proto.RegisterType((*CompleteIPRotationRequest)(nil), "google.container.v1.CompleteIPRotationRequest") + proto.RegisterType((*AcceleratorConfig)(nil), "google.container.v1.AcceleratorConfig") + proto.RegisterType((*SetNetworkPolicyRequest)(nil), "google.container.v1.SetNetworkPolicyRequest") + proto.RegisterEnum("google.container.v1.NetworkPolicy_Provider", NetworkPolicy_Provider_name, NetworkPolicy_Provider_value) proto.RegisterEnum("google.container.v1.Cluster_Status", Cluster_Status_name, Cluster_Status_value) proto.RegisterEnum("google.container.v1.Operation_Status", Operation_Status_name, Operation_Status_value) proto.RegisterEnum("google.container.v1.Operation_Type", Operation_Type_name, Operation_Type_value) @@ -2462,6 +3362,20 @@ type ClusterManagerClient interface { CreateCluster(ctx context.Context, in *CreateClusterRequest, opts ...grpc.CallOption) (*Operation, error) // Updates the settings of a specific cluster. UpdateCluster(ctx context.Context, in *UpdateClusterRequest, opts ...grpc.CallOption) (*Operation, error) + // Updates the version and/or image type of a specific node pool. + UpdateNodePool(ctx context.Context, in *UpdateNodePoolRequest, opts ...grpc.CallOption) (*Operation, error) + // Sets the autoscaling settings of a specific node pool. + SetNodePoolAutoscaling(ctx context.Context, in *SetNodePoolAutoscalingRequest, opts ...grpc.CallOption) (*Operation, error) + // Sets the logging service of a specific cluster. + SetLoggingService(ctx context.Context, in *SetLoggingServiceRequest, opts ...grpc.CallOption) (*Operation, error) + // Sets the monitoring service of a specific cluster. + SetMonitoringService(ctx context.Context, in *SetMonitoringServiceRequest, opts ...grpc.CallOption) (*Operation, error) + // Sets the addons of a specific cluster. + SetAddonsConfig(ctx context.Context, in *SetAddonsConfigRequest, opts ...grpc.CallOption) (*Operation, error) + // Sets the locations of a specific cluster. + SetLocations(ctx context.Context, in *SetLocationsRequest, opts ...grpc.CallOption) (*Operation, error) + // Updates the master of a specific cluster. + UpdateMaster(ctx context.Context, in *UpdateMasterRequest, opts ...grpc.CallOption) (*Operation, error) // Used to set master auth materials. Currently supports :- // Changing the admin password of a specific cluster. // This can be either via password generation or explicitly set the password. @@ -2505,6 +3419,10 @@ type ClusterManagerClient interface { StartIPRotation(ctx context.Context, in *StartIPRotationRequest, opts ...grpc.CallOption) (*Operation, error) // Completes master IP rotation. CompleteIPRotation(ctx context.Context, in *CompleteIPRotationRequest, opts ...grpc.CallOption) (*Operation, error) + // Sets the size of a specific node pool. + SetNodePoolSize(ctx context.Context, in *SetNodePoolSizeRequest, opts ...grpc.CallOption) (*Operation, error) + // Enables/Disables Network Policy for a cluster. + SetNetworkPolicy(ctx context.Context, in *SetNetworkPolicyRequest, opts ...grpc.CallOption) (*Operation, error) } type clusterManagerClient struct { @@ -2551,6 +3469,69 @@ func (c *clusterManagerClient) UpdateCluster(ctx context.Context, in *UpdateClus return out, nil } +func (c *clusterManagerClient) UpdateNodePool(ctx context.Context, in *UpdateNodePoolRequest, opts ...grpc.CallOption) (*Operation, error) { + out := new(Operation) + err := grpc.Invoke(ctx, "/google.container.v1.ClusterManager/UpdateNodePool", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *clusterManagerClient) SetNodePoolAutoscaling(ctx context.Context, in *SetNodePoolAutoscalingRequest, opts ...grpc.CallOption) (*Operation, error) { + out := new(Operation) + err := grpc.Invoke(ctx, "/google.container.v1.ClusterManager/SetNodePoolAutoscaling", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *clusterManagerClient) SetLoggingService(ctx context.Context, in *SetLoggingServiceRequest, opts ...grpc.CallOption) (*Operation, error) { + out := new(Operation) + err := grpc.Invoke(ctx, "/google.container.v1.ClusterManager/SetLoggingService", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *clusterManagerClient) SetMonitoringService(ctx context.Context, in *SetMonitoringServiceRequest, opts ...grpc.CallOption) (*Operation, error) { + out := new(Operation) + err := grpc.Invoke(ctx, "/google.container.v1.ClusterManager/SetMonitoringService", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *clusterManagerClient) SetAddonsConfig(ctx context.Context, in *SetAddonsConfigRequest, opts ...grpc.CallOption) (*Operation, error) { + out := new(Operation) + err := grpc.Invoke(ctx, "/google.container.v1.ClusterManager/SetAddonsConfig", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *clusterManagerClient) SetLocations(ctx context.Context, in *SetLocationsRequest, opts ...grpc.CallOption) (*Operation, error) { + out := new(Operation) + err := grpc.Invoke(ctx, "/google.container.v1.ClusterManager/SetLocations", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *clusterManagerClient) UpdateMaster(ctx context.Context, in *UpdateMasterRequest, opts ...grpc.CallOption) (*Operation, error) { + out := new(Operation) + err := grpc.Invoke(ctx, "/google.container.v1.ClusterManager/UpdateMaster", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *clusterManagerClient) SetMasterAuth(ctx context.Context, in *SetMasterAuthRequest, opts ...grpc.CallOption) (*Operation, error) { out := new(Operation) err := grpc.Invoke(ctx, "/google.container.v1.ClusterManager/SetMasterAuth", in, out, c.cc, opts...) @@ -2695,6 +3676,24 @@ func (c *clusterManagerClient) CompleteIPRotation(ctx context.Context, in *Compl return out, nil } +func (c *clusterManagerClient) SetNodePoolSize(ctx context.Context, in *SetNodePoolSizeRequest, opts ...grpc.CallOption) (*Operation, error) { + out := new(Operation) + err := grpc.Invoke(ctx, "/google.container.v1.ClusterManager/SetNodePoolSize", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *clusterManagerClient) SetNetworkPolicy(ctx context.Context, in *SetNetworkPolicyRequest, opts ...grpc.CallOption) (*Operation, error) { + out := new(Operation) + err := grpc.Invoke(ctx, "/google.container.v1.ClusterManager/SetNetworkPolicy", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // Server API for ClusterManager service type ClusterManagerServer interface { @@ -2719,6 +3718,20 @@ type ClusterManagerServer interface { CreateCluster(context.Context, *CreateClusterRequest) (*Operation, error) // Updates the settings of a specific cluster. UpdateCluster(context.Context, *UpdateClusterRequest) (*Operation, error) + // Updates the version and/or image type of a specific node pool. + UpdateNodePool(context.Context, *UpdateNodePoolRequest) (*Operation, error) + // Sets the autoscaling settings of a specific node pool. + SetNodePoolAutoscaling(context.Context, *SetNodePoolAutoscalingRequest) (*Operation, error) + // Sets the logging service of a specific cluster. + SetLoggingService(context.Context, *SetLoggingServiceRequest) (*Operation, error) + // Sets the monitoring service of a specific cluster. + SetMonitoringService(context.Context, *SetMonitoringServiceRequest) (*Operation, error) + // Sets the addons of a specific cluster. + SetAddonsConfig(context.Context, *SetAddonsConfigRequest) (*Operation, error) + // Sets the locations of a specific cluster. + SetLocations(context.Context, *SetLocationsRequest) (*Operation, error) + // Updates the master of a specific cluster. + UpdateMaster(context.Context, *UpdateMasterRequest) (*Operation, error) // Used to set master auth materials. Currently supports :- // Changing the admin password of a specific cluster. // This can be either via password generation or explicitly set the password. @@ -2762,6 +3775,10 @@ type ClusterManagerServer interface { StartIPRotation(context.Context, *StartIPRotationRequest) (*Operation, error) // Completes master IP rotation. CompleteIPRotation(context.Context, *CompleteIPRotationRequest) (*Operation, error) + // Sets the size of a specific node pool. + SetNodePoolSize(context.Context, *SetNodePoolSizeRequest) (*Operation, error) + // Enables/Disables Network Policy for a cluster. + SetNetworkPolicy(context.Context, *SetNetworkPolicyRequest) (*Operation, error) } func RegisterClusterManagerServer(s *grpc.Server, srv ClusterManagerServer) { @@ -2840,6 +3857,132 @@ func _ClusterManager_UpdateCluster_Handler(srv interface{}, ctx context.Context, return interceptor(ctx, in, info, handler) } +func _ClusterManager_UpdateNodePool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateNodePoolRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ClusterManagerServer).UpdateNodePool(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.container.v1.ClusterManager/UpdateNodePool", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ClusterManagerServer).UpdateNodePool(ctx, req.(*UpdateNodePoolRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ClusterManager_SetNodePoolAutoscaling_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetNodePoolAutoscalingRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ClusterManagerServer).SetNodePoolAutoscaling(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.container.v1.ClusterManager/SetNodePoolAutoscaling", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ClusterManagerServer).SetNodePoolAutoscaling(ctx, req.(*SetNodePoolAutoscalingRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ClusterManager_SetLoggingService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetLoggingServiceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ClusterManagerServer).SetLoggingService(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.container.v1.ClusterManager/SetLoggingService", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ClusterManagerServer).SetLoggingService(ctx, req.(*SetLoggingServiceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ClusterManager_SetMonitoringService_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetMonitoringServiceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ClusterManagerServer).SetMonitoringService(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.container.v1.ClusterManager/SetMonitoringService", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ClusterManagerServer).SetMonitoringService(ctx, req.(*SetMonitoringServiceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ClusterManager_SetAddonsConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetAddonsConfigRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ClusterManagerServer).SetAddonsConfig(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.container.v1.ClusterManager/SetAddonsConfig", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ClusterManagerServer).SetAddonsConfig(ctx, req.(*SetAddonsConfigRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ClusterManager_SetLocations_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetLocationsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ClusterManagerServer).SetLocations(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.container.v1.ClusterManager/SetLocations", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ClusterManagerServer).SetLocations(ctx, req.(*SetLocationsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ClusterManager_UpdateMaster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateMasterRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ClusterManagerServer).UpdateMaster(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.container.v1.ClusterManager/UpdateMaster", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ClusterManagerServer).UpdateMaster(ctx, req.(*UpdateMasterRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _ClusterManager_SetMasterAuth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(SetMasterAuthRequest) if err := dec(in); err != nil { @@ -3128,6 +4271,42 @@ func _ClusterManager_CompleteIPRotation_Handler(srv interface{}, ctx context.Con return interceptor(ctx, in, info, handler) } +func _ClusterManager_SetNodePoolSize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetNodePoolSizeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ClusterManagerServer).SetNodePoolSize(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.container.v1.ClusterManager/SetNodePoolSize", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ClusterManagerServer).SetNodePoolSize(ctx, req.(*SetNodePoolSizeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _ClusterManager_SetNetworkPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SetNetworkPolicyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ClusterManagerServer).SetNetworkPolicy(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.container.v1.ClusterManager/SetNetworkPolicy", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ClusterManagerServer).SetNetworkPolicy(ctx, req.(*SetNetworkPolicyRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _ClusterManager_serviceDesc = grpc.ServiceDesc{ ServiceName: "google.container.v1.ClusterManager", HandlerType: (*ClusterManagerServer)(nil), @@ -3148,6 +4327,34 @@ var _ClusterManager_serviceDesc = grpc.ServiceDesc{ MethodName: "UpdateCluster", Handler: _ClusterManager_UpdateCluster_Handler, }, + { + MethodName: "UpdateNodePool", + Handler: _ClusterManager_UpdateNodePool_Handler, + }, + { + MethodName: "SetNodePoolAutoscaling", + Handler: _ClusterManager_SetNodePoolAutoscaling_Handler, + }, + { + MethodName: "SetLoggingService", + Handler: _ClusterManager_SetLoggingService_Handler, + }, + { + MethodName: "SetMonitoringService", + Handler: _ClusterManager_SetMonitoringService_Handler, + }, + { + MethodName: "SetAddonsConfig", + Handler: _ClusterManager_SetAddonsConfig_Handler, + }, + { + MethodName: "SetLocations", + Handler: _ClusterManager_SetLocations_Handler, + }, + { + MethodName: "UpdateMaster", + Handler: _ClusterManager_UpdateMaster_Handler, + }, { MethodName: "SetMasterAuth", Handler: _ClusterManager_SetMasterAuth_Handler, @@ -3212,6 +4419,14 @@ var _ClusterManager_serviceDesc = grpc.ServiceDesc{ MethodName: "CompleteIPRotation", Handler: _ClusterManager_CompleteIPRotation_Handler, }, + { + MethodName: "SetNodePoolSize", + Handler: _ClusterManager_SetNodePoolSize_Handler, + }, + { + MethodName: "SetNetworkPolicy", + Handler: _ClusterManager_SetNetworkPolicy_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "google/container/v1/cluster_service.proto", @@ -3220,212 +4435,270 @@ var _ClusterManager_serviceDesc = grpc.ServiceDesc{ func init() { proto.RegisterFile("google/container/v1/cluster_service.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ - // 3298 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xdb, 0x6f, 0x1b, 0xd7, - 0xd1, 0xff, 0x56, 0xa2, 0x2e, 0x1c, 0x5e, 0x44, 0x1d, 0x5d, 0xbc, 0x1f, 0x63, 0xc7, 0xf2, 0xe6, - 0x62, 0xc7, 0x6e, 0xc4, 0xf8, 0x92, 0x9b, 0xed, 0x06, 0xa1, 0x29, 0x5a, 0xa2, 0x2d, 0x91, 0xcc, - 0x92, 0xb4, 0x91, 0x00, 0xed, 0x62, 0xb5, 0x7b, 0x44, 0x6d, 0xb4, 0xdc, 0xdd, 0xec, 0x2e, 0x95, - 0xc8, 0x86, 0x1f, 0x1a, 0xb4, 0x40, 0x81, 0x3e, 0xb6, 0x28, 0xfa, 0x50, 0x14, 0x45, 0x9a, 0xf6, - 0x21, 0x05, 0x5a, 0x04, 0x28, 0xda, 0x02, 0x7d, 0x29, 0xd0, 0x97, 0xbe, 0x16, 0x79, 0x28, 0xda, - 0xe7, 0xa2, 0x8f, 0xfd, 0x1b, 0x8a, 0x73, 0xd9, 0xe5, 0xae, 0xb4, 0x14, 0xa5, 0xc8, 0x4a, 0xfa, - 0x64, 0xed, 0x9c, 0x99, 0x73, 0x7e, 0x33, 0x67, 0x66, 0xce, 0xcc, 0x98, 0xf0, 0x52, 0xd7, 0xb6, - 0xbb, 0x26, 0x2e, 0x69, 0xb6, 0xe5, 0xab, 0x86, 0x85, 0xdd, 0xd2, 0xee, 0xd5, 0x92, 0x66, 0xf6, - 0x3d, 0x1f, 0xbb, 0x8a, 0x87, 0xdd, 0x5d, 0x43, 0xc3, 0xcb, 0x8e, 0x6b, 0xfb, 0x36, 0x9a, 0x63, - 0xac, 0xcb, 0x21, 0xeb, 0xf2, 0xee, 0xd5, 0xe2, 0x59, 0x2e, 0xaf, 0x3a, 0x46, 0x49, 0xb5, 0x2c, - 0xdb, 0x57, 0x7d, 0xc3, 0xb6, 0x3c, 0x26, 0x52, 0x7c, 0x86, 0xaf, 0xd2, 0xaf, 0xcd, 0xfe, 0x56, - 0x09, 0xf7, 0x1c, 0x7f, 0x8f, 0x2d, 0x4a, 0x9f, 0xa4, 0x00, 0xea, 0xb6, 0x8e, 0x2b, 0xb6, 0xb5, - 0x65, 0x74, 0xd1, 0x05, 0xc8, 0xf6, 0x54, 0x6d, 0xdb, 0xb0, 0xb0, 0xe2, 0xef, 0x39, 0x58, 0x14, - 0x96, 0x84, 0x4b, 0x69, 0x39, 0xc3, 0x69, 0xed, 0x3d, 0x07, 0xa3, 0x25, 0xc8, 0xea, 0x86, 0xb7, - 0xa3, 0x78, 0xc6, 0x23, 0xac, 0x74, 0x37, 0xc5, 0xb1, 0x25, 0xe1, 0xd2, 0x84, 0x0c, 0x84, 0xd6, - 0x32, 0x1e, 0xe1, 0xd5, 0x4d, 0xb2, 0x89, 0xad, 0xf6, 0xfd, 0x6d, 0xc5, 0xd3, 0x6c, 0x07, 0x7b, - 0xe2, 0xf8, 0xd2, 0x38, 0xd9, 0x84, 0xd2, 0x5a, 0x94, 0x84, 0x2e, 0xc2, 0x0c, 0xd7, 0x4b, 0x51, - 0x35, 0xcd, 0xee, 0x5b, 0xbe, 0x98, 0xa6, 0x47, 0xe5, 0x39, 0xb9, 0xcc, 0xa8, 0xa8, 0x06, 0xd3, - 0x3d, 0xec, 0xab, 0xba, 0xea, 0xab, 0x62, 0x6a, 0x69, 0xfc, 0x52, 0xe6, 0xda, 0xcb, 0xcb, 0x09, - 0x26, 0x58, 0x1e, 0xe8, 0xb0, 0xbc, 0xc1, 0xf9, 0xab, 0x96, 0xef, 0xee, 0xc9, 0xa1, 0x38, 0x3a, - 0x07, 0x60, 0xf4, 0xd4, 0x2e, 0xd7, 0x6c, 0x82, 0x1e, 0x97, 0xa6, 0x14, 0xaa, 0x57, 0x05, 0x26, - 0x4d, 0x75, 0x13, 0x9b, 0x9e, 0x38, 0x49, 0xcf, 0xb9, 0x32, 0xea, 0x9c, 0x75, 0xca, 0xcd, 0x4e, - 0xe1, 0xa2, 0xe8, 0x45, 0x98, 0x31, 0x6d, 0x4d, 0x35, 0x15, 0xcf, 0xd3, 0x15, 0xa6, 0xd7, 0x14, - 0xb5, 0x4f, 0x8e, 0x92, 0x5b, 0x9e, 0x5e, 0xa1, 0x6a, 0x21, 0x48, 0xf9, 0x6a, 0xd7, 0x13, 0xa7, - 0xa9, 0x69, 0xe8, 0xdf, 0x68, 0x09, 0x32, 0x8e, 0x8b, 0xc9, 0xe5, 0x18, 0x9b, 0x26, 0x16, 0x61, - 0x49, 0xb8, 0x34, 0x2d, 0x47, 0x49, 0xc5, 0x5b, 0x90, 0x8b, 0x29, 0x87, 0x0a, 0x30, 0xbe, 0x83, - 0xf7, 0xf8, 0x2d, 0x91, 0x3f, 0xd1, 0x3c, 0x4c, 0xec, 0xaa, 0x66, 0x1f, 0xd3, 0x6b, 0x49, 0xcb, - 0xec, 0xe3, 0xe6, 0xd8, 0x1b, 0x42, 0xf1, 0x4d, 0xc8, 0x44, 0x10, 0x1f, 0x47, 0x54, 0xfa, 0xab, - 0x00, 0xb0, 0xa1, 0x12, 0x6f, 0x2c, 0xf7, 0xfd, 0x6d, 0x54, 0x84, 0xe9, 0xbe, 0x87, 0x5d, 0x4b, - 0xed, 0x05, 0x0e, 0x12, 0x7e, 0x93, 0x35, 0x47, 0xf5, 0xbc, 0x0f, 0x6d, 0x57, 0xe7, 0xfb, 0x84, - 0xdf, 0xe8, 0x06, 0x2c, 0x06, 0x4e, 0xad, 0xa9, 0x8a, 0x86, 0x5d, 0xdf, 0xd8, 0x32, 0x34, 0xd5, - 0xc7, 0xa2, 0x4e, 0x39, 0xe7, 0xf9, 0x6a, 0x45, 0xad, 0x0c, 0xd6, 0xd0, 0xcb, 0x80, 0x34, 0xd3, - 0xc0, 0x96, 0x1f, 0x93, 0xc0, 0x54, 0x62, 0x96, 0xad, 0x44, 0xd9, 0xcf, 0x01, 0x70, 0x76, 0xa2, - 0xde, 0x16, 0xbb, 0x65, 0x46, 0xb9, 0x8f, 0xf7, 0xa4, 0x2f, 0x04, 0xc8, 0x96, 0x75, 0xdd, 0xb6, - 0x3c, 0xee, 0xf1, 0x0f, 0x60, 0x6e, 0xdb, 0xf7, 0x1d, 0xc5, 0xb4, 0x55, 0x5d, 0xd9, 0x54, 0x4d, - 0xd5, 0xd2, 0x0c, 0xab, 0x4b, 0xf5, 0xca, 0x5c, 0x7b, 0x31, 0xd1, 0x07, 0xd6, 0x7c, 0xdf, 0x59, - 0xb7, 0x55, 0xfd, 0x4e, 0xc0, 0x2d, 0xcf, 0x6e, 0xef, 0x27, 0xa1, 0x1d, 0x28, 0x6e, 0xdb, 0xae, - 0xf1, 0x88, 0x08, 0x9a, 0x8a, 0x63, 0xeb, 0x8a, 0xda, 0xf7, 0x6d, 0x4f, 0x53, 0x4d, 0xb2, 0xfd, - 0x18, 0xdd, 0x3e, 0xd9, 0x95, 0xd7, 0x42, 0xb1, 0xa6, 0xad, 0x97, 0x07, 0x42, 0xb2, 0xb8, 0x3d, - 0x64, 0x45, 0x2a, 0xc1, 0xec, 0x01, 0x50, 0xe4, 0x2a, 0x74, 0xc3, 0x53, 0x37, 0x4d, 0xac, 0x53, - 0x75, 0xa6, 0xe5, 0xf0, 0x5b, 0x7a, 0x0d, 0xc4, 0x61, 0xc7, 0x1c, 0x2a, 0xf7, 0x22, 0xc0, 0x3a, - 0xee, 0xaa, 0xda, 0x5e, 0x79, 0x53, 0xd5, 0x90, 0x08, 0x53, 0xd8, 0x8a, 0x32, 0x06, 0x9f, 0xd2, - 0xdf, 0xb2, 0x30, 0x55, 0x61, 0xb7, 0x49, 0x7c, 0x3d, 0xe2, 0x2a, 0xf4, 0x6f, 0xe2, 0xeb, 0x3a, - 0xf6, 0x34, 0xd7, 0x70, 0x48, 0xa6, 0xe2, 0x9e, 0x12, 0x25, 0xa1, 0x6f, 0x00, 0x32, 0x2c, 0xc3, - 0x37, 0x54, 0x53, 0xb1, 0x6c, 0x1d, 0xf3, 0x60, 0x1a, 0xa7, 0xc1, 0x54, 0xe0, 0x2b, 0x2c, 0x18, - 0x49, 0x3c, 0xbd, 0x0d, 0x19, 0xce, 0x45, 0x2e, 0x55, 0x4c, 0x51, 0xf3, 0x9e, 0x1f, 0x11, 0xc1, - 0x32, 0x58, 0x83, 0xcc, 0xf7, 0x36, 0x64, 0x7a, 0xd4, 0xc5, 0xc9, 0x3d, 0x6d, 0xd3, 0xf4, 0x30, - 0x6c, 0x87, 0x41, 0x28, 0xc8, 0xd0, 0x1b, 0x84, 0xc5, 0x45, 0x12, 0xfb, 0xdd, 0xae, 0x61, 0x75, - 0x83, 0x9c, 0x2d, 0x4e, 0xb2, 0x9c, 0xc6, 0xc9, 0x2d, 0x46, 0x25, 0x1e, 0xdd, 0xb3, 0x2d, 0xc3, - 0xb7, 0xdd, 0x28, 0xef, 0x14, 0xf3, 0xe8, 0xc1, 0x4a, 0xc0, 0x2e, 0xc2, 0x94, 0x85, 0xfd, 0x0f, - 0x6d, 0x77, 0x47, 0x9c, 0xa6, 0x3c, 0xc1, 0x27, 0xba, 0x0c, 0xb3, 0x41, 0x40, 0x19, 0xce, 0xee, - 0x0d, 0x45, 0x33, 0x74, 0x97, 0xe7, 0xd1, 0x19, 0xbe, 0x50, 0x73, 0x76, 0x6f, 0x54, 0x0c, 0xdd, - 0x45, 0x77, 0x21, 0xa7, 0x52, 0xbf, 0x0f, 0x6c, 0x04, 0x54, 0xc3, 0x0b, 0x89, 0x1a, 0x46, 0x23, - 0x44, 0xce, 0xaa, 0xd1, 0x78, 0x79, 0x16, 0xc0, 0xeb, 0x6f, 0x06, 0x80, 0x32, 0xf4, 0xb0, 0x08, - 0x05, 0xdd, 0x06, 0x6a, 0x55, 0xc5, 0xb1, 0x6d, 0xd3, 0x13, 0xb3, 0x34, 0x95, 0x9e, 0x1b, 0x7a, - 0x11, 0x4d, 0xdb, 0x36, 0xe5, 0xb4, 0xc5, 0xff, 0xf2, 0xd0, 0x59, 0x48, 0x93, 0x44, 0x49, 0x9f, - 0x2f, 0x31, 0x47, 0x93, 0xe3, 0x80, 0x80, 0x5e, 0x83, 0x33, 0xcc, 0xc1, 0x94, 0x9d, 0xfe, 0x26, - 0x76, 0x2d, 0xec, 0x63, 0x4f, 0x51, 0x4d, 0x67, 0x5b, 0x15, 0xf3, 0xd4, 0xff, 0x16, 0xd8, 0xf2, - 0xfd, 0x70, 0xb5, 0x4c, 0x16, 0xd1, 0xbb, 0x30, 0xe3, 0x62, 0xcf, 0xee, 0xbb, 0x1a, 0x56, 0x78, - 0x8e, 0x9f, 0xa1, 0xc0, 0x5e, 0x49, 0x04, 0xc6, 0x1d, 0x77, 0x59, 0xe6, 0x32, 0xd1, 0x44, 0x9f, - 0x77, 0x63, 0x44, 0x74, 0x05, 0x66, 0xe9, 0x8e, 0xca, 0x96, 0x61, 0x75, 0xb1, 0xeb, 0xb8, 0x86, - 0xe5, 0x8b, 0x05, 0x6a, 0x95, 0x02, 0x5d, 0xb8, 0x3b, 0xa0, 0x13, 0x1f, 0x33, 0x69, 0xf4, 0x28, - 0xea, 0xa6, 0xaa, 0x89, 0xe8, 0x10, 0x1f, 0x1b, 0x44, 0x99, 0x0c, 0xe6, 0x20, 0xe2, 0x9e, 0x81, - 0xb4, 0x87, 0xcd, 0x2d, 0xc5, 0x34, 0xac, 0x1d, 0x9e, 0x35, 0xa7, 0x09, 0x61, 0xdd, 0xb0, 0x76, - 0x48, 0xa0, 0x3d, 0xb2, 0xad, 0x20, 0x37, 0xd2, 0xbf, 0x49, 0x30, 0x63, 0x4b, 0x77, 0x6c, 0x02, - 0x8b, 0x25, 0xc3, 0xf0, 0x9b, 0x98, 0x33, 0x08, 0xb1, 0xc0, 0x8d, 0x76, 0xb1, 0xeb, 0x91, 0x80, - 0xec, 0x52, 0xd6, 0x05, 0xbe, 0xcc, 0x0d, 0xf2, 0x80, 0x2d, 0xd2, 0x3c, 0xde, 0x77, 0x5d, 0x92, - 0x63, 0x79, 0xc8, 0x04, 0x62, 0xdb, 0x3c, 0x8f, 0xb3, 0x55, 0x16, 0x27, 0x81, 0xd4, 0x2b, 0x10, - 0xd0, 0x59, 0x40, 0x07, 0x32, 0x06, 0x95, 0x41, 0x7c, 0x8d, 0x38, 0x45, 0x20, 0x71, 0x1e, 0x32, - 0x9a, 0x8b, 0x55, 0x1f, 0x2b, 0xbe, 0xd1, 0xc3, 0xe2, 0xfb, 0xcc, 0xd7, 0x18, 0xa9, 0x6d, 0xf4, - 0x30, 0xba, 0x05, 0x93, 0x9e, 0xaf, 0xfa, 0x7d, 0x4f, 0xdc, 0x59, 0x12, 0x2e, 0xe5, 0xaf, 0x3d, - 0x77, 0xe8, 0x75, 0xb6, 0x28, 0xab, 0xcc, 0x45, 0xd0, 0x0b, 0x90, 0x67, 0x7f, 0x29, 0x3d, 0xec, - 0x79, 0x6a, 0x17, 0x8b, 0x26, 0x3d, 0x20, 0xc7, 0xa8, 0x1b, 0x8c, 0x88, 0x5e, 0x86, 0x39, 0x0a, - 0x37, 0x0c, 0x30, 0x5a, 0xf8, 0x88, 0x3d, 0x96, 0x88, 0xc8, 0x52, 0x10, 0x62, 0xa4, 0xfa, 0x21, - 0x69, 0x8b, 0x07, 0xb4, 0x17, 0x89, 0x49, 0x8b, 0x39, 0x44, 0xb0, 0x12, 0x06, 0xe5, 0x32, 0xcc, - 0x19, 0x96, 0xe7, 0xab, 0x96, 0x86, 0x95, 0xae, 0x6b, 0xf7, 0x1d, 0xa5, 0xef, 0x9a, 0x9e, 0x68, - 0x53, 0xc7, 0x9f, 0x0d, 0x96, 0x56, 0xc9, 0x4a, 0xc7, 0x35, 0x3d, 0xb2, 0x7b, 0xcc, 0x86, 0x2c, - 0x29, 0x3a, 0x0c, 0x4b, 0xc4, 0x82, 0x2c, 0x29, 0x9e, 0x87, 0x0c, 0xfe, 0xc8, 0x31, 0x5c, 0x6e, - 0xbf, 0x0f, 0x98, 0xfd, 0x18, 0x89, 0xd8, 0xaf, 0x58, 0x86, 0xb9, 0x04, 0x1f, 0x3f, 0x56, 0x69, - 0x60, 0xc0, 0x24, 0xb3, 0x2b, 0x5a, 0x04, 0xd4, 0x6a, 0x97, 0xdb, 0x9d, 0x96, 0xd2, 0xa9, 0xb7, - 0x9a, 0xd5, 0x4a, 0xed, 0x6e, 0xad, 0xba, 0x52, 0xf8, 0x3f, 0x54, 0x80, 0x6c, 0x53, 0x6e, 0x3c, - 0xa8, 0xb5, 0x6a, 0x8d, 0x7a, 0xad, 0xbe, 0x5a, 0x10, 0x50, 0x06, 0xa6, 0xe4, 0x4e, 0x9d, 0x7e, - 0x8c, 0xa1, 0x19, 0xc8, 0xc8, 0xd5, 0x4a, 0xa3, 0x5e, 0xa9, 0xad, 0x13, 0xc2, 0x38, 0xca, 0xc2, - 0x74, 0xab, 0xdd, 0x68, 0x36, 0xc9, 0x57, 0x0a, 0xa5, 0x61, 0xa2, 0x2a, 0xcb, 0x0d, 0xb9, 0x30, - 0x21, 0x7d, 0x2f, 0x05, 0x39, 0x7e, 0x97, 0x1d, 0x47, 0x27, 0x6f, 0xfd, 0x2b, 0x30, 0xaf, 0x63, - 0xcf, 0x70, 0xb1, 0x1e, 0x77, 0xa9, 0x14, 0x73, 0x29, 0xbe, 0x16, 0x75, 0xa9, 0xdb, 0x50, 0x0c, - 0x24, 0x12, 0x52, 0x30, 0xab, 0x09, 0x45, 0xce, 0xb1, 0x71, 0x20, 0x13, 0x77, 0x60, 0x21, 0x90, - 0x8e, 0xe7, 0xd2, 0xc9, 0xa3, 0xe6, 0xd2, 0x39, 0x2e, 0x1f, 0x2b, 0x41, 0x4a, 0xfb, 0xd4, 0x20, - 0xa9, 0x53, 0x31, 0xf4, 0xe0, 0x45, 0x88, 0xa8, 0x41, 0x92, 0x64, 0x4d, 0x27, 0x6e, 0x10, 0x08, - 0x44, 0x2a, 0x5a, 0xf6, 0x38, 0x14, 0xf8, 0x4a, 0x2d, 0x2c, 0x6c, 0x77, 0xe0, 0xdc, 0xc1, 0xed, - 0xa3, 0xc5, 0x48, 0x9a, 0xa2, 0xbf, 0x74, 0x68, 0x92, 0x8e, 0xd6, 0x21, 0xc5, 0x7d, 0x88, 0xa2, - 0xc5, 0xc3, 0x15, 0x08, 0xf0, 0x2a, 0x83, 0x44, 0x0e, 0xd4, 0x9f, 0x03, 0x64, 0xeb, 0x61, 0x3e, - 0xbf, 0x01, 0x8b, 0xe1, 0x6d, 0xc4, 0x13, 0x09, 0x2f, 0x08, 0x83, 0x9b, 0x88, 0x26, 0x12, 0xe9, - 0x2f, 0x13, 0x90, 0x6e, 0x38, 0xd8, 0xa5, 0x9b, 0x24, 0x56, 0x17, 0x41, 0x22, 0x1c, 0x8b, 0x24, - 0xc2, 0x7b, 0x90, 0xb7, 0x03, 0x21, 0x66, 0xaf, 0xf1, 0x43, 0x72, 0x46, 0xb8, 0xff, 0x32, 0x31, - 0xa1, 0x9c, 0x0b, 0x45, 0xa9, 0x45, 0xbf, 0x19, 0xe6, 0x9d, 0x14, 0xdd, 0xe3, 0x85, 0x11, 0x7b, - 0xec, 0xcb, 0x3c, 0x8b, 0x30, 0xa9, 0x63, 0x5f, 0x35, 0x4c, 0x7e, 0x65, 0xfc, 0x2b, 0x21, 0x23, - 0x4d, 0x24, 0x65, 0xa4, 0xd8, 0x1b, 0x30, 0xb9, 0xef, 0x0d, 0x38, 0x0f, 0x19, 0x5f, 0x75, 0xbb, - 0xd8, 0x67, 0xcb, 0xcc, 0x85, 0x80, 0x91, 0x08, 0x83, 0x24, 0x8f, 0x0c, 0xd8, 0x0c, 0x4c, 0x35, - 0xab, 0xf5, 0x95, 0x84, 0x58, 0x9d, 0x86, 0xd4, 0x4a, 0xa3, 0x5e, 0x65, 0x41, 0x5a, 0xbe, 0xd3, - 0x90, 0xdb, 0x34, 0x48, 0xa5, 0xcf, 0xc7, 0x20, 0x45, 0x0d, 0x33, 0x0f, 0x85, 0xf6, 0xbb, 0xcd, - 0xea, 0xbe, 0x0d, 0x11, 0xe4, 0x2b, 0x72, 0xb5, 0xdc, 0xae, 0x2a, 0x95, 0xf5, 0x4e, 0xab, 0x5d, - 0x95, 0x0b, 0x02, 0xa1, 0xad, 0x54, 0xd7, 0xab, 0x11, 0xda, 0x18, 0xa1, 0x75, 0x9a, 0xab, 0x72, - 0x79, 0xa5, 0xaa, 0x6c, 0x94, 0x29, 0x6d, 0x1c, 0xcd, 0x42, 0x2e, 0xa0, 0xd5, 0x1b, 0x2b, 0xd5, - 0x56, 0x21, 0x45, 0xd8, 0xe4, 0x6a, 0xb3, 0x5c, 0x93, 0x43, 0xd1, 0x09, 0x26, 0xba, 0x12, 0x3d, - 0x62, 0x92, 0x80, 0xe1, 0xc7, 0x12, 0x49, 0xa5, 0xd9, 0x68, 0xac, 0x17, 0xa6, 0x08, 0x95, 0x1f, - 0x3c, 0xa0, 0x4e, 0xa3, 0xb3, 0x20, 0xb6, 0xaa, 0xed, 0x01, 0x49, 0xd9, 0x28, 0xd7, 0xcb, 0xab, - 0xd5, 0x8d, 0x6a, 0xbd, 0x5d, 0x48, 0xa3, 0x05, 0x98, 0x2d, 0x77, 0xda, 0x0d, 0x85, 0x1f, 0xcb, - 0x80, 0x00, 0x31, 0x20, 0x25, 0xc7, 0x01, 0x66, 0x50, 0x1e, 0x80, 0x6c, 0xb6, 0x5e, 0xbe, 0x53, - 0x5d, 0x6f, 0x15, 0xb2, 0x68, 0x0e, 0x66, 0xc8, 0x37, 0xd3, 0x49, 0x29, 0x77, 0xda, 0x6b, 0x85, - 0x9c, 0xf4, 0x1d, 0x01, 0xe6, 0x2b, 0xf4, 0x29, 0xe3, 0x39, 0x4d, 0xc6, 0x1f, 0xf4, 0xb1, 0xe7, - 0x93, 0x06, 0xc6, 0x71, 0xed, 0xf7, 0xb1, 0xe6, 0x93, 0x1c, 0xc0, 0xdc, 0x3a, 0xcd, 0x29, 0x35, - 0x3d, 0xd1, 0xb7, 0x5f, 0x83, 0x29, 0xfe, 0x80, 0x53, 0xa7, 0xce, 0x5c, 0x3b, 0x7b, 0xd8, 0x43, - 0x28, 0x07, 0xcc, 0x12, 0x86, 0xd9, 0x55, 0xec, 0x9f, 0xfc, 0x7c, 0xda, 0x73, 0xf1, 0x3a, 0x54, - 0xa7, 0x10, 0x68, 0xcf, 0xc5, 0x0a, 0x50, 0x5d, 0xfa, 0x54, 0x80, 0x79, 0x96, 0xb1, 0x4f, 0xfb, - 0x28, 0x74, 0x13, 0x26, 0xfb, 0xf4, 0x24, 0xde, 0x02, 0x48, 0x87, 0x19, 0x82, 0x61, 0x92, 0xb9, - 0x84, 0xf4, 0xeb, 0x31, 0x98, 0x6f, 0x61, 0x3f, 0x52, 0xdd, 0x9f, 0x1a, 0xcc, 0x35, 0x98, 0x54, - 0x35, 0x3f, 0x78, 0xaa, 0xf2, 0x43, 0xea, 0xd0, 0x24, 0x30, 0xcb, 0x65, 0x2a, 0x27, 0x73, 0x79, - 0xf4, 0x7a, 0xa8, 0xf0, 0x11, 0x3b, 0x96, 0x40, 0xdb, 0xb7, 0x60, 0x92, 0x6d, 0x45, 0x42, 0xbc, - 0x53, 0xbf, 0x5f, 0x6f, 0x3c, 0xac, 0xb3, 0xd7, 0x9a, 0xf8, 0x6a, 0xb3, 0xdc, 0x6a, 0x3d, 0x6c, - 0xc8, 0x2b, 0x05, 0x81, 0x38, 0xff, 0x6a, 0xb5, 0x5e, 0x95, 0x49, 0x20, 0x85, 0xe4, 0x31, 0x69, - 0x1b, 0xe6, 0x57, 0xb0, 0x89, 0x4f, 0xff, 0x4e, 0xa5, 0x35, 0x98, 0x5b, 0x37, 0xbc, 0xc0, 0x4d, - 0xbd, 0x2f, 0x7f, 0x90, 0xd4, 0x87, 0xf9, 0xf8, 0x4e, 0x9e, 0x63, 0x5b, 0x1e, 0x46, 0x6f, 0xc0, - 0x34, 0x3f, 0xce, 0x13, 0x05, 0xda, 0x18, 0x1c, 0x1e, 0x40, 0x21, 0x37, 0x7a, 0x0e, 0x72, 0x3d, - 0xc3, 0xf3, 0x48, 0x11, 0x41, 0x4e, 0xf0, 0xc4, 0x31, 0xfa, 0xd4, 0x65, 0x39, 0xf1, 0x3d, 0x42, - 0x93, 0x76, 0x60, 0x6e, 0x15, 0xfb, 0xe1, 0x73, 0x70, 0x02, 0x4b, 0x5d, 0x80, 0xec, 0xe0, 0x11, - 0x0b, 0x6d, 0x95, 0x09, 0x69, 0x35, 0x5d, 0xba, 0x07, 0x0b, 0x44, 0xc7, 0xf0, 0xb4, 0x93, 0xd8, - 0xcb, 0x82, 0xc5, 0x0a, 0x29, 0x40, 0xcd, 0xaf, 0x08, 0xfb, 0x13, 0x58, 0xdc, 0x8f, 0x9d, 0xdf, - 0xd0, 0x5b, 0x00, 0x21, 0x63, 0x70, 0x47, 0xcf, 0x1e, 0xfe, 0xea, 0xca, 0x11, 0x89, 0xa3, 0xdd, - 0xd3, 0x7d, 0x58, 0x5c, 0xc5, 0x3e, 0x29, 0xf6, 0xb0, 0xcb, 0xeb, 0xb5, 0x2f, 0x6f, 0xbb, 0xef, - 0x8e, 0x41, 0x36, 0xba, 0x15, 0xe9, 0xb6, 0x74, 0xbc, 0xa5, 0xf6, 0x4d, 0xff, 0x40, 0xb7, 0xc5, - 0x36, 0x5c, 0xe0, 0xcb, 0xfb, 0xba, 0xad, 0x65, 0x98, 0xdb, 0x55, 0x4d, 0x23, 0x5e, 0xe2, 0x06, - 0x43, 0xd5, 0x59, 0xba, 0x14, 0xa9, 0x70, 0x3d, 0x56, 0x1c, 0xb2, 0x73, 0x22, 0xc5, 0x61, 0x2a, - 0x28, 0x0e, 0xe9, 0xca, 0xa0, 0x38, 0xbc, 0x0c, 0x6c, 0x8b, 0x08, 0xaf, 0x27, 0x4e, 0xd0, 0xbd, - 0x67, 0xe8, 0x42, 0xc8, 0xea, 0xa1, 0x6b, 0xb0, 0xc0, 0x78, 0xe3, 0xc5, 0x1a, 0x1b, 0x98, 0xa6, - 0x65, 0x06, 0x33, 0x56, 0xab, 0x79, 0xd2, 0x2f, 0x05, 0x58, 0x60, 0xcf, 0x5c, 0xd8, 0xee, 0x9f, - 0x62, 0xf2, 0x4f, 0x87, 0x05, 0x2e, 0xcf, 0xff, 0x23, 0x26, 0x0f, 0xd3, 0xc1, 0xe4, 0x41, 0xfa, - 0x81, 0x00, 0x0b, 0x2c, 0x9f, 0x9d, 0x3e, 0xce, 0x25, 0xc8, 0xc6, 0xea, 0x7c, 0x76, 0x37, 0x60, - 0x85, 0x05, 0x3e, 0x49, 0xae, 0x24, 0x10, 0x02, 0x28, 0xde, 0xe9, 0x25, 0xd7, 0xef, 0x0b, 0x80, - 0x56, 0xb1, 0xff, 0xbf, 0xa0, 0xf4, 0xbf, 0x53, 0x30, 0x1d, 0xe0, 0x48, 0x2c, 0xeb, 0x5f, 0x87, - 0x49, 0xde, 0x6f, 0x8d, 0x1d, 0x6d, 0xbe, 0xc7, 0xd9, 0x8f, 0x39, 0x4b, 0x3c, 0x74, 0xc6, 0x22, - 0xc2, 0x54, 0x10, 0xb5, 0x6c, 0xcc, 0x12, 0x7c, 0x0e, 0xeb, 0xe5, 0xb7, 0x86, 0xf5, 0xf2, 0xb7, - 0xc3, 0x26, 0xa2, 0x4b, 0x6b, 0x80, 0xe7, 0x0f, 0x75, 0xd5, 0xd1, 0xd3, 0x8b, 0xed, 0xa4, 0x5e, - 0xe1, 0x1e, 0x64, 0xa2, 0x9d, 0x5e, 0xea, 0x98, 0x9d, 0x5e, 0x54, 0x18, 0x55, 0x00, 0x7a, 0xaa, - 0xa5, 0x76, 0x71, 0x0f, 0x5b, 0x3e, 0x2f, 0x37, 0x9e, 0x1b, 0xba, 0xd5, 0x46, 0xc8, 0x2a, 0x47, - 0xc4, 0x48, 0xd9, 0x7b, 0xc2, 0x81, 0xc1, 0x22, 0x20, 0xfe, 0xa1, 0x3c, 0xac, 0xb5, 0xd7, 0x14, - 0x36, 0x1e, 0x18, 0xdf, 0x3f, 0x48, 0x48, 0xc5, 0x06, 0x09, 0x13, 0x83, 0x41, 0xc2, 0xa4, 0xf4, - 0x2b, 0x01, 0xf2, 0x71, 0x88, 0xe4, 0x71, 0x22, 0xaa, 0x2a, 0x7d, 0xa7, 0xeb, 0xaa, 0x3a, 0xe6, - 0xe3, 0x6c, 0xaa, 0x7e, 0x87, 0x91, 0x48, 0x67, 0x45, 0x59, 0x5c, 0xec, 0xa8, 0x86, 0x4b, 0x5d, - 0x70, 0x5a, 0x06, 0x42, 0x92, 0x29, 0x05, 0x35, 0x61, 0x86, 0x8b, 0x2b, 0xb6, 0x13, 0x34, 0xbe, - 0xc4, 0x48, 0x17, 0x93, 0xe7, 0x02, 0x83, 0xbd, 0x1b, 0x8c, 0x5d, 0xce, 0xf7, 0x63, 0xdf, 0x52, - 0x0f, 0xd0, 0x41, 0x2e, 0xf4, 0x2a, 0x9c, 0x89, 0x62, 0x55, 0x3c, 0x5f, 0x75, 0x7d, 0x36, 0xe2, - 0x61, 0xd1, 0x32, 0x1f, 0x81, 0xdd, 0x22, 0x8b, 0x74, 0x58, 0x36, 0x72, 0xe4, 0x2e, 0xfd, 0x5d, - 0x80, 0xb3, 0xad, 0x41, 0x2e, 0x88, 0xdc, 0xe0, 0xd7, 0x97, 0x15, 0x9e, 0x8e, 0xd7, 0xfd, 0x48, - 0x80, 0x67, 0x65, 0xdb, 0x34, 0x37, 0x55, 0x6d, 0x27, 0x50, 0x8f, 0x1b, 0xe8, 0xeb, 0xcc, 0x78, - 0x1d, 0x56, 0xab, 0x45, 0xd2, 0x3c, 0x2f, 0x77, 0xe2, 0x43, 0x74, 0xe1, 0x78, 0x43, 0x74, 0xe9, - 0x31, 0xcc, 0x25, 0x8d, 0x66, 0x86, 0xfe, 0x6f, 0x0d, 0x7a, 0x1e, 0xf2, 0x3d, 0xc3, 0x8a, 0xe6, - 0x46, 0xf6, 0x9f, 0xba, 0xd9, 0x9e, 0x61, 0x0d, 0xf2, 0x22, 0xe1, 0x52, 0x3f, 0x3a, 0x98, 0x41, - 0xb3, 0x3d, 0xf5, 0xa3, 0x90, 0x4b, 0xfa, 0xe3, 0x18, 0x14, 0x5a, 0xd8, 0x67, 0xf3, 0xc4, 0xd3, - 0x33, 0xee, 0xe6, 0xc1, 0x91, 0x3e, 0xfb, 0xef, 0xe1, 0x37, 0x87, 0xb5, 0x52, 0x31, 0x44, 0x5f, - 0x7e, 0xb6, 0x3f, 0x91, 0x3c, 0xdb, 0x7f, 0x1a, 0xb3, 0xd4, 0x8f, 0x05, 0xda, 0x80, 0x46, 0x46, - 0xff, 0xa7, 0x66, 0xbe, 0x88, 0x2f, 0xa4, 0xe2, 0xff, 0x73, 0xf7, 0x3e, 0x2c, 0xd2, 0x9c, 0x51, - 0x6b, 0xca, 0xfc, 0x77, 0x04, 0xa7, 0x57, 0x7c, 0xf4, 0xe0, 0xff, 0x2b, 0x76, 0xcf, 0x21, 0x55, - 0xd7, 0x57, 0x70, 0xdc, 0xb5, 0xff, 0x3c, 0x03, 0x79, 0x5e, 0x5c, 0xb3, 0x3c, 0xe1, 0xa2, 0x9f, - 0x0a, 0x90, 0x8d, 0xb6, 0x84, 0x28, 0xf9, 0x6d, 0x4c, 0xe8, 0x3f, 0x8b, 0x2f, 0x1d, 0x81, 0x93, - 0x85, 0xb3, 0xf4, 0xfa, 0xc7, 0x5f, 0xfc, 0xeb, 0x87, 0x63, 0x57, 0x51, 0xa9, 0xb4, 0x7b, 0xb5, - 0xc4, 0x55, 0xf0, 0x4a, 0x8f, 0x07, 0xea, 0x3d, 0x29, 0xd1, 0xae, 0xa4, 0xf4, 0x98, 0xfc, 0xf3, - 0xa4, 0x14, 0xb6, 0x97, 0x3f, 0x11, 0x00, 0x06, 0x13, 0x1a, 0x94, 0xfc, 0xdf, 0xd1, 0x07, 0x46, - 0x38, 0xc5, 0x43, 0xbb, 0x57, 0x69, 0x85, 0xa2, 0x79, 0x0b, 0xdd, 0x3e, 0x26, 0x9a, 0xd2, 0xe3, - 0x81, 0x71, 0x9f, 0xa0, 0x1f, 0x0b, 0x90, 0x8b, 0xcd, 0xaf, 0x50, 0xb2, 0x41, 0x92, 0x66, 0x5c, - 0xc5, 0x11, 0xad, 0x9b, 0x74, 0x93, 0x42, 0xbc, 0x21, 0x1d, 0xd7, 0x60, 0x37, 0x85, 0xcb, 0xe8, - 0x17, 0x02, 0xe4, 0x62, 0xd3, 0xa6, 0x21, 0xc0, 0x92, 0x26, 0x52, 0x23, 0x81, 0xad, 0x52, 0x60, - 0xe5, 0xe2, 0x89, 0x6c, 0x47, 0x50, 0x7e, 0x2e, 0x40, 0x2e, 0x36, 0xdf, 0x19, 0x82, 0x32, 0x69, - 0x06, 0x34, 0x12, 0x65, 0x87, 0xa2, 0x6c, 0x48, 0xf7, 0x4e, 0x84, 0xd2, 0x8b, 0x1e, 0x4d, 0x30, - 0xff, 0x5c, 0x80, 0x5c, 0x6c, 0xe6, 0x33, 0x04, 0x73, 0xd2, 0x5c, 0x68, 0x24, 0x66, 0xee, 0x95, - 0x97, 0x4f, 0xe6, 0x95, 0x9f, 0x0a, 0x90, 0x8f, 0x8f, 0x10, 0xd0, 0xe5, 0xa1, 0x71, 0x7a, 0x60, - 0x46, 0x52, 0xbc, 0x72, 0x24, 0x5e, 0x1e, 0xd5, 0x6f, 0x52, 0xc4, 0xd7, 0xd1, 0xd5, 0x23, 0x22, - 0x8e, 0x8c, 0x23, 0x3e, 0x11, 0x20, 0x1b, 0x1d, 0x09, 0x0d, 0x49, 0x3b, 0x09, 0x53, 0xa3, 0x91, - 0x76, 0x5c, 0xa3, 0xa8, 0xee, 0xa0, 0xb7, 0x8f, 0x8d, 0xaa, 0xf4, 0x38, 0x3a, 0x9f, 0x79, 0x82, - 0x3e, 0x13, 0x60, 0x66, 0xdf, 0xf8, 0x07, 0x25, 0x1b, 0x28, 0x79, 0x48, 0x54, 0x5c, 0x0c, 0x98, - 0x83, 0x5f, 0x9e, 0x2d, 0x57, 0x7b, 0x8e, 0xbf, 0x27, 0xc9, 0x14, 0xe2, 0xba, 0xb4, 0x7a, 0x52, - 0x88, 0x37, 0x35, 0x7a, 0x30, 0xf1, 0xcd, 0x9f, 0x09, 0x30, 0xb3, 0x6f, 0x78, 0x33, 0x04, 0x6c, - 0xf2, 0x88, 0xa7, 0x78, 0x61, 0x48, 0xf8, 0x0d, 0x38, 0xa5, 0x5b, 0x14, 0xf7, 0xab, 0xe8, 0xfa, - 0x11, 0x71, 0x7b, 0x54, 0x98, 0xf7, 0xa0, 0xbf, 0x17, 0x20, 0x17, 0x2b, 0xf6, 0xd0, 0xf0, 0x07, - 0x64, 0x7f, 0xdf, 0x5f, 0xbc, 0x7c, 0x14, 0x56, 0xee, 0x96, 0x75, 0x8a, 0x72, 0x0d, 0xdd, 0x3d, - 0x49, 0x20, 0x95, 0x06, 0x3f, 0xc9, 0xf8, 0x9d, 0x00, 0x99, 0xc8, 0x84, 0x00, 0x5d, 0x1c, 0x66, - 0xd5, 0x7d, 0x33, 0x84, 0xe2, 0xe1, 0x05, 0xab, 0xf4, 0x2d, 0x8a, 0xf3, 0x21, 0xea, 0x3c, 0x1d, - 0x9c, 0xa5, 0xc7, 0xd1, 0x62, 0xfb, 0x09, 0xfa, 0xad, 0x00, 0xf9, 0xf8, 0xe0, 0x69, 0x48, 0x26, - 0x48, 0x9c, 0x4e, 0x8d, 0x0c, 0xb3, 0x77, 0x28, 0xfa, 0xfb, 0xd2, 0x53, 0xb2, 0x32, 0x71, 0xe1, - 0x3f, 0x09, 0x90, 0x8f, 0x8f, 0xa0, 0x86, 0x20, 0x4e, 0x9c, 0x53, 0x8d, 0x44, 0xcc, 0xed, 0x7d, - 0xf9, 0x94, 0xec, 0xfd, 0x0f, 0x01, 0xce, 0x0c, 0x69, 0xb1, 0xd0, 0xf5, 0x44, 0x68, 0x87, 0x37, - 0x64, 0x23, 0xf5, 0x31, 0xa8, 0x3e, 0x9a, 0xf4, 0xed, 0x53, 0xd1, 0xe7, 0xa6, 0xcb, 0xd1, 0x91, - 0x9b, 0xf9, 0xa7, 0x00, 0x0b, 0x89, 0x8d, 0x31, 0xba, 0x3a, 0xec, 0xd1, 0x1e, 0xda, 0x44, 0x8f, - 0xd4, 0xcb, 0xa2, 0x7a, 0x6d, 0x4b, 0xda, 0xa9, 0xe8, 0x55, 0xa2, 0xaf, 0x7a, 0x80, 0x89, 0x28, - 0xf7, 0x99, 0x00, 0xe9, 0xb0, 0x3d, 0x42, 0x2f, 0x1c, 0xa9, 0x7d, 0x1a, 0xa9, 0xc4, 0x03, 0xaa, - 0x44, 0x53, 0xba, 0x7f, 0x22, 0x25, 0xe2, 0xfd, 0x18, 0x01, 0xfb, 0x1b, 0x56, 0x36, 0x45, 0x7e, - 0x83, 0x38, 0xb4, 0x6c, 0x3a, 0xd0, 0x46, 0x8d, 0x04, 0x7d, 0xdc, 0x77, 0x29, 0x19, 0xf4, 0xe0, - 0xd7, 0x5a, 0x04, 0xf0, 0x1f, 0x04, 0x98, 0xd9, 0xd7, 0x4f, 0x0d, 0x79, 0x97, 0x92, 0xbb, 0xae, - 0x91, 0xa0, 0x1f, 0x52, 0xd0, 0xef, 0x48, 0xeb, 0x27, 0xab, 0xf5, 0xe8, 0xe1, 0x4e, 0x70, 0x38, - 0x41, 0xfe, 0x67, 0x01, 0xd0, 0xc1, 0xee, 0x0c, 0x2d, 0x27, 0x27, 0xd1, 0x61, 0x6d, 0xdc, 0x48, - 0xfc, 0xef, 0x51, 0xfc, 0x6d, 0xa9, 0x71, 0x22, 0xfc, 0x5a, 0x70, 0x7e, 0x54, 0x85, 0x3b, 0x16, - 0x9c, 0xd1, 0xec, 0x5e, 0x12, 0x80, 0x3b, 0x73, 0xbc, 0x3c, 0xe5, 0x3f, 0xed, 0x69, 0x92, 0x0a, - 0xa5, 0x29, 0xbc, 0x77, 0x9b, 0xf3, 0x76, 0x6d, 0x53, 0xb5, 0xba, 0xcb, 0xb6, 0xdb, 0x2d, 0x75, - 0xb1, 0x45, 0xeb, 0x97, 0x12, 0x5b, 0x52, 0x1d, 0xc3, 0x8b, 0xfd, 0x50, 0xff, 0x56, 0xf8, 0xb1, - 0x39, 0x49, 0x19, 0xaf, 0xff, 0x37, 0x00, 0x00, 0xff, 0xff, 0xcf, 0xbe, 0xbf, 0xb9, 0xd0, 0x2f, - 0x00, 0x00, + // 4238 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5c, 0x5b, 0x8c, 0xdc, 0x58, + 0x5a, 0xc6, 0xdd, 0xd5, 0x97, 0xfa, 0xeb, 0xd2, 0xd5, 0xa7, 0x2f, 0xf1, 0xf6, 0xe4, 0xea, 0x99, + 0xcc, 0xe4, 0x32, 0xd3, 0x35, 0xc9, 0x64, 0xe7, 0x92, 0xc9, 0x8e, 0xa6, 0x52, 0x5d, 0xe9, 0x54, + 0xd2, 0xdd, 0x55, 0xeb, 0xea, 0x9e, 0x30, 0x03, 0xbb, 0x96, 0xdb, 0x3e, 0xa9, 0xf6, 0xb4, 0xcb, + 0xf6, 0xda, 0xae, 0xde, 0xe9, 0x44, 0x41, 0x62, 0x05, 0x12, 0x12, 0x02, 0x21, 0xc1, 0x22, 0x84, + 0xd0, 0x0a, 0xc1, 0x82, 0xd0, 0x8e, 0xb8, 0x2d, 0x68, 0x41, 0xc0, 0x03, 0x2f, 0x48, 0xbc, 0xf0, + 0xc4, 0x03, 0x82, 0x17, 0x84, 0x84, 0x90, 0x78, 0xe1, 0x95, 0x57, 0x74, 0x2e, 0x76, 0xd9, 0x55, + 0x76, 0x55, 0x77, 0x6a, 0x2a, 0xe1, 0x29, 0xe5, 0xff, 0xfc, 0xe7, 0x9c, 0xef, 0xff, 0x7d, 0xce, + 0x7f, 0x75, 0x07, 0xae, 0xb6, 0x6d, 0xbb, 0x6d, 0xe2, 0xb2, 0x66, 0x5b, 0xbe, 0x6a, 0x58, 0xd8, + 0x2d, 0x1f, 0xdd, 0x28, 0x6b, 0x66, 0xd7, 0xf3, 0xb1, 0xab, 0x78, 0xd8, 0x3d, 0x32, 0x34, 0xbc, + 0xee, 0xb8, 0xb6, 0x6f, 0xa3, 0x25, 0xc6, 0xba, 0x1e, 0xb2, 0xae, 0x1f, 0xdd, 0x58, 0x3b, 0xcb, + 0xe7, 0xab, 0x8e, 0x51, 0x56, 0x2d, 0xcb, 0xf6, 0x55, 0xdf, 0xb0, 0x2d, 0x8f, 0x4d, 0x59, 0x7b, + 0x85, 0x8f, 0xd2, 0xa7, 0xfd, 0xee, 0xe3, 0x32, 0xee, 0x38, 0xfe, 0x31, 0x1b, 0x94, 0xfe, 0x27, + 0x03, 0xb0, 0x63, 0xeb, 0xb8, 0x6a, 0x5b, 0x8f, 0x8d, 0x36, 0xba, 0x04, 0xf9, 0x8e, 0xaa, 0x1d, + 0x18, 0x16, 0x56, 0xfc, 0x63, 0x07, 0x8b, 0xc2, 0x45, 0xe1, 0x4a, 0x56, 0xce, 0x71, 0xda, 0xee, + 0xb1, 0x83, 0xd1, 0x45, 0xc8, 0xeb, 0x86, 0x77, 0xa8, 0x78, 0xc6, 0x13, 0xac, 0xb4, 0xf7, 0xc5, + 0xa9, 0x8b, 0xc2, 0x95, 0x19, 0x19, 0x08, 0xad, 0x65, 0x3c, 0xc1, 0x9b, 0xfb, 0x64, 0x11, 0x5b, + 0xed, 0xfa, 0x07, 0x8a, 0xa7, 0xd9, 0x0e, 0xf6, 0xc4, 0xe9, 0x8b, 0xd3, 0x64, 0x11, 0x4a, 0x6b, + 0x51, 0x12, 0x7a, 0x03, 0x16, 0xb8, 0x5c, 0x8a, 0xaa, 0x69, 0x76, 0xd7, 0xf2, 0xc5, 0x2c, 0xdd, + 0xaa, 0xc8, 0xc9, 0x15, 0x46, 0x45, 0x75, 0x98, 0xef, 0x60, 0x5f, 0xd5, 0x55, 0x5f, 0x15, 0x33, + 0x17, 0xa7, 0xaf, 0xe4, 0x6e, 0xbe, 0xb5, 0x9e, 0xa0, 0x82, 0xf5, 0x9e, 0x0c, 0xeb, 0xdb, 0x9c, + 0xbf, 0x66, 0xf9, 0xee, 0xb1, 0x1c, 0x4e, 0x47, 0xe7, 0x00, 0x8c, 0x8e, 0xda, 0xe6, 0x92, 0xcd, + 0xd0, 0xed, 0xb2, 0x94, 0x42, 0xe5, 0xaa, 0xc2, 0xac, 0xa9, 0xee, 0x63, 0xd3, 0x13, 0x67, 0xe9, + 0x3e, 0xd7, 0x47, 0xed, 0xb3, 0x45, 0xb9, 0xd9, 0x2e, 0x7c, 0x2a, 0x7a, 0x1d, 0x16, 0x4c, 0x5b, + 0x53, 0x4d, 0xc5, 0xf3, 0x74, 0x85, 0xc9, 0x35, 0x47, 0xf5, 0x53, 0xa0, 0xe4, 0x96, 0xa7, 0x57, + 0xa9, 0x58, 0x08, 0x32, 0xbe, 0xda, 0xf6, 0xc4, 0x79, 0xaa, 0x1a, 0xfa, 0x1b, 0x5d, 0x84, 0x9c, + 0xe3, 0x62, 0xf2, 0x72, 0x8c, 0x7d, 0x13, 0x8b, 0x70, 0x51, 0xb8, 0x32, 0x2f, 0x47, 0x49, 0xe8, + 0x01, 0xe4, 0x55, 0x4d, 0xc3, 0x26, 0x76, 0x55, 0xdf, 0x76, 0x3d, 0x31, 0x47, 0x81, 0xbe, 0x9e, + 0x08, 0xb4, 0xd2, 0x63, 0x64, 0x78, 0xe5, 0xd8, 0xdc, 0xb5, 0x0f, 0xa1, 0x10, 0x53, 0x14, 0x2a, + 0xc1, 0xf4, 0x21, 0x3e, 0xe6, 0x6f, 0x9c, 0xfc, 0x44, 0xcb, 0x30, 0x73, 0xa4, 0x9a, 0x5d, 0x4c, + 0x5f, 0x71, 0x56, 0x66, 0x0f, 0xb7, 0xa7, 0xde, 0x17, 0xd6, 0x3e, 0x80, 0x5c, 0x44, 0xfa, 0xd3, + 0x4c, 0x95, 0x7e, 0x3c, 0x05, 0xb0, 0xad, 0x92, 0x93, 0x5d, 0xe9, 0xfa, 0x07, 0x68, 0x0d, 0xe6, + 0xbb, 0x1e, 0x76, 0x2d, 0xb5, 0x13, 0x1c, 0xb6, 0xf0, 0x99, 0x8c, 0x39, 0xaa, 0xe7, 0x7d, 0xd7, + 0x76, 0x75, 0xbe, 0x4e, 0xf8, 0x8c, 0x0e, 0xe0, 0x6b, 0x9a, 0x69, 0x60, 0xcb, 0x57, 0x34, 0xec, + 0xfa, 0xc6, 0x63, 0x43, 0x53, 0x7d, 0xac, 0x68, 0x54, 0x52, 0x71, 0xfa, 0xa2, 0x70, 0x25, 0x77, + 0xf3, 0xcd, 0x44, 0xbd, 0x54, 0xe9, 0xac, 0x6a, 0x6f, 0x12, 0xd7, 0xce, 0x19, 0x2d, 0x79, 0x00, + 0xdd, 0x82, 0xd5, 0xe0, 0x2a, 0x6a, 0x6a, 0x74, 0x37, 0x51, 0xa7, 0x98, 0x96, 0xf9, 0x68, 0x55, + 0x8d, 0xcc, 0x45, 0x6f, 0x01, 0x1a, 0xc4, 0x27, 0x62, 0x3a, 0x63, 0x71, 0x60, 0x2b, 0x72, 0x36, + 0x39, 0x3b, 0x51, 0xe4, 0x63, 0x76, 0x36, 0x19, 0xe5, 0x21, 0x3e, 0x96, 0x5a, 0x70, 0x26, 0x05, + 0x37, 0x7a, 0x1f, 0x44, 0xc3, 0xf3, 0xba, 0x58, 0x49, 0xd8, 0x4e, 0xa0, 0x47, 0x68, 0x95, 0x8e, + 0x0f, 0xcc, 0x97, 0xfe, 0x6c, 0x0a, 0xf2, 0x15, 0x5d, 0xb7, 0x2d, 0x8f, 0x2f, 0xf5, 0x09, 0x2c, + 0x1d, 0xf8, 0xbe, 0xa3, 0x98, 0xb6, 0xaa, 0x2b, 0xfb, 0xaa, 0xa9, 0x5a, 0x9a, 0x61, 0xb5, 0xe9, + 0x2a, 0x69, 0xa7, 0xec, 0xbe, 0xef, 0x3b, 0x5b, 0xb6, 0xaa, 0xdf, 0x0d, 0xb8, 0xe5, 0xc5, 0x83, + 0x7e, 0x12, 0x3a, 0x84, 0xb5, 0x03, 0xdb, 0x35, 0x9e, 0x90, 0x89, 0xa6, 0xe2, 0xd8, 0xba, 0xa2, + 0x76, 0x7d, 0xdb, 0xd3, 0x54, 0x93, 0x2c, 0x3f, 0x45, 0x97, 0x4f, 0xbe, 0xd5, 0xf7, 0xc3, 0x69, + 0x4d, 0x5b, 0xaf, 0xf4, 0x26, 0xc9, 0xe2, 0x41, 0xca, 0x08, 0xfa, 0x19, 0x58, 0x3e, 0xec, 0xee, + 0x63, 0xd7, 0xc2, 0x3e, 0xf6, 0x14, 0x5d, 0xf5, 0x0e, 0xf6, 0x6d, 0xd5, 0xd5, 0xf9, 0x99, 0xb8, + 0x92, 0xb8, 0xcd, 0xc3, 0x70, 0xc2, 0x46, 0xc0, 0x2f, 0x2f, 0x1d, 0x0e, 0x12, 0xa5, 0x32, 0x2c, + 0x0e, 0x48, 0x4c, 0x8e, 0xa9, 0x6e, 0x78, 0xea, 0xbe, 0x89, 0x75, 0xae, 0xf1, 0xf0, 0x59, 0x7a, + 0x17, 0xc4, 0x34, 0x19, 0x86, 0xce, 0xbb, 0x01, 0x4b, 0x09, 0xa0, 0x86, 0x4e, 0xf9, 0x6f, 0x01, + 0xce, 0xf7, 0x2e, 0x16, 0xd9, 0x14, 0xeb, 0x3b, 0xd8, 0xff, 0xae, 0xed, 0x1e, 0x06, 0x2f, 0x58, + 0x84, 0x39, 0x6c, 0x45, 0x67, 0x07, 0x8f, 0xe8, 0xdb, 0x90, 0xd3, 0x0c, 0xdd, 0x55, 0xf6, 0x4d, + 0x5b, 0x3b, 0xf4, 0xc4, 0x29, 0x6a, 0x58, 0xbe, 0x91, 0xa8, 0xac, 0xe1, 0x7b, 0xac, 0x57, 0x0d, + 0xdd, 0xbd, 0x4b, 0x56, 0x91, 0x41, 0x0b, 0x7e, 0x7a, 0x6b, 0xdb, 0x90, 0x0d, 0x07, 0x88, 0x7f, + 0xd0, 0x0d, 0xcf, 0x31, 0xd5, 0x63, 0x25, 0x72, 0xef, 0x73, 0x9c, 0xb6, 0x43, 0xae, 0x3e, 0xb9, + 0x0f, 0x21, 0x1e, 0x7e, 0xf9, 0xb3, 0xe1, 0x7a, 0xd2, 0xeb, 0x00, 0x5b, 0xb8, 0xad, 0x6a, 0xc7, + 0x95, 0x7d, 0x55, 0x4b, 0x17, 0x4b, 0xfa, 0xa1, 0x00, 0x05, 0x8e, 0xaf, 0x69, 0x9b, 0x86, 0x76, + 0x8c, 0x36, 0x61, 0xde, 0x71, 0xed, 0x23, 0x43, 0xc7, 0x2e, 0x65, 0x2e, 0xa6, 0xd9, 0xf9, 0xe8, + 0xac, 0xf5, 0x26, 0x9f, 0x22, 0x87, 0x93, 0xa3, 0x9b, 0x4e, 0xc5, 0x37, 0x7d, 0x1b, 0xe6, 0x9b, + 0x3d, 0xae, 0xe5, 0xa6, 0xdc, 0xf8, 0xa4, 0xbe, 0x51, 0x93, 0x95, 0xbd, 0x9d, 0x56, 0xb3, 0x56, + 0xad, 0xdf, 0xab, 0xd7, 0x36, 0x4a, 0x3f, 0x85, 0x00, 0x66, 0xab, 0x95, 0xad, 0x7a, 0xb5, 0x51, + 0x12, 0xa4, 0x5f, 0x9b, 0x02, 0x54, 0x6f, 0x56, 0x4c, 0xe2, 0x23, 0x88, 0xe7, 0xe6, 0x58, 0x5f, + 0x83, 0x62, 0xd7, 0xc3, 0x8a, 0xe1, 0x28, 0xaa, 0x69, 0xa8, 0x1e, 0xf6, 0xb8, 0x78, 0xf9, 0xae, + 0x87, 0xeb, 0x4e, 0x85, 0xd1, 0xd0, 0x75, 0x58, 0xd4, 0x5c, 0x4c, 0xac, 0x9f, 0xd7, 0xdd, 0xb7, + 0x18, 0x6c, 0x0e, 0xa9, 0xc4, 0x06, 0x5a, 0x21, 0x9d, 0xfa, 0xdd, 0xf0, 0x89, 0x69, 0x7f, 0x9a, + 0xfb, 0xdd, 0x90, 0x4c, 0x5f, 0xc0, 0x35, 0x58, 0x0c, 0xac, 0x9e, 0xe1, 0x1c, 0xdd, 0x52, 0x88, + 0xee, 0xc5, 0x0c, 0x65, 0x5d, 0xe0, 0x03, 0x75, 0xe7, 0xe8, 0x16, 0x79, 0xa9, 0x04, 0xa7, 0x65, + 0xeb, 0x38, 0xc2, 0xc8, 0x9c, 0x6b, 0x9e, 0x50, 0x43, 0xae, 0x37, 0x01, 0x71, 0xdf, 0xee, 0x45, + 0x38, 0x67, 0x29, 0x67, 0x29, 0x18, 0x09, 0xb8, 0xa5, 0xff, 0x2d, 0xc2, 0x5c, 0x95, 0xed, 0x43, + 0x9c, 0x65, 0xe4, 0x9c, 0xd0, 0xdf, 0xc4, 0x59, 0xea, 0xd8, 0xd3, 0x5c, 0xc3, 0x21, 0x0a, 0xe3, + 0x27, 0x24, 0x4a, 0x22, 0xfb, 0x19, 0x96, 0xe1, 0x1b, 0xaa, 0xa9, 0x50, 0x74, 0xcc, 0x1b, 0x4f, + 0x53, 0x6f, 0x5c, 0xe2, 0x23, 0xcc, 0x9b, 0x13, 0x87, 0xfc, 0x31, 0xe4, 0x38, 0x17, 0xf5, 0x20, + 0x19, 0x6a, 0x2d, 0x2e, 0x8c, 0x08, 0x01, 0x64, 0xb0, 0x7a, 0xa1, 0xd3, 0xc7, 0x90, 0xeb, 0xd0, + 0xab, 0x41, 0xac, 0xdb, 0x01, 0x55, 0x41, 0xda, 0x0a, 0xbd, 0x2b, 0x24, 0x43, 0xa7, 0xe7, 0x0b, + 0xdf, 0x20, 0xc1, 0x43, 0xbb, 0x6d, 0x58, 0xed, 0x20, 0xe8, 0xe3, 0xea, 0x29, 0x72, 0x72, 0x8b, + 0x51, 0x89, 0x73, 0xe9, 0xd8, 0x96, 0xe1, 0xdb, 0x6e, 0x94, 0x77, 0x8e, 0x39, 0x97, 0xde, 0x48, + 0xc0, 0x2e, 0xc2, 0x5c, 0x70, 0x2e, 0xe6, 0x29, 0x4f, 0xf0, 0x98, 0xfc, 0x96, 0xb3, 0xc9, 0x6f, + 0xf9, 0x1e, 0x14, 0x54, 0xea, 0x2d, 0x02, 0x1d, 0x01, 0x95, 0xf0, 0x52, 0x72, 0xf4, 0x11, 0xf1, + 0x2b, 0x72, 0x5e, 0x8d, 0x7a, 0x99, 0xf3, 0x00, 0x91, 0x83, 0x9a, 0xa3, 0x9b, 0x45, 0x28, 0xe8, + 0x0e, 0x50, 0xad, 0x2a, 0x8e, 0x6d, 0x9b, 0x9e, 0x98, 0xa7, 0x96, 0xe8, 0x5c, 0xea, 0x8b, 0x68, + 0xda, 0xb6, 0x29, 0x67, 0x2d, 0xfe, 0xcb, 0x43, 0x67, 0x21, 0x1b, 0xdc, 0x22, 0x4f, 0x2c, 0xd0, + 0xe8, 0xaa, 0x47, 0x40, 0xef, 0xc2, 0x19, 0x76, 0x4b, 0x95, 0x88, 0x8f, 0x50, 0x4d, 0xe7, 0x40, + 0x15, 0x8b, 0xf4, 0xc6, 0xac, 0xb0, 0xe1, 0x9e, 0xed, 0xad, 0x90, 0x41, 0xf4, 0x29, 0x2c, 0xb8, + 0xd8, 0xb3, 0xbb, 0xae, 0x86, 0x15, 0x1e, 0x24, 0x2e, 0x50, 0x60, 0x6f, 0xa7, 0xc4, 0x18, 0x54, + 0x75, 0xeb, 0x32, 0x9f, 0x13, 0x8d, 0x14, 0x8b, 0x6e, 0x8c, 0x48, 0xae, 0x2f, 0x5d, 0x51, 0x79, + 0x6c, 0x58, 0x6d, 0xec, 0x3a, 0xae, 0x61, 0xf9, 0x62, 0x89, 0xdd, 0x0a, 0x3a, 0x70, 0xaf, 0x47, + 0x27, 0x67, 0xcc, 0xa4, 0x76, 0x4f, 0x51, 0xf7, 0x55, 0x4d, 0x44, 0x43, 0xce, 0x58, 0xcf, 0x3e, + 0xca, 0x60, 0xf6, 0x6c, 0x65, 0x1d, 0x8a, 0xc1, 0xed, 0x77, 0xa8, 0x95, 0x11, 0x97, 0xe8, 0x22, + 0xd2, 0x68, 0x2b, 0x28, 0x17, 0xac, 0x98, 0x29, 0xfd, 0x14, 0x96, 0xa9, 0x69, 0x0a, 0xd4, 0x1b, + 0x2c, 0xb8, 0x4c, 0x17, 0x7c, 0x23, 0x71, 0xc1, 0x41, 0x2b, 0x27, 0x23, 0xc3, 0x19, 0xb0, 0x7c, + 0x3f, 0x07, 0x97, 0x22, 0x77, 0x89, 0xf9, 0x19, 0x85, 0xef, 0x1e, 0x9e, 0xbf, 0x55, 0xba, 0xcf, + 0x3b, 0xcf, 0xe1, 0xa4, 0xe4, 0xf3, 0x9d, 0xe1, 0x8e, 0xf2, 0x15, 0xc8, 0x7a, 0xd8, 0x7c, 0xac, + 0x98, 0x86, 0x75, 0xc8, 0xc3, 0xbc, 0x79, 0x42, 0xd8, 0x32, 0xac, 0x43, 0x62, 0x8e, 0x9e, 0xd8, + 0x56, 0x10, 0xcc, 0xd1, 0xdf, 0xc4, 0x31, 0x63, 0x4b, 0x77, 0x6c, 0xf2, 0xf2, 0x58, 0xf4, 0x16, + 0x3e, 0x93, 0x43, 0x17, 0x18, 0xa2, 0xe0, 0xb2, 0x1d, 0x61, 0xd7, 0x23, 0x66, 0xab, 0x4d, 0x59, + 0x57, 0xf8, 0x30, 0x3f, 0x36, 0x9f, 0xb0, 0x41, 0x1a, 0x78, 0x76, 0x5d, 0x97, 0x04, 0x75, 0x5c, + 0x19, 0xc1, 0xb4, 0x03, 0x1e, 0x78, 0xb2, 0x51, 0x26, 0x6b, 0x30, 0xeb, 0x6d, 0x08, 0xe8, 0xcc, + 0xec, 0x05, 0x73, 0x0c, 0x3a, 0x07, 0xf1, 0x31, 0x72, 0x75, 0x82, 0x19, 0x17, 0x20, 0xc7, 0x1d, + 0x88, 0x6f, 0x74, 0xb0, 0xf8, 0x39, 0xbb, 0x91, 0x8c, 0xb4, 0x6b, 0x74, 0x30, 0xfa, 0x10, 0x66, + 0x3d, 0x5f, 0xf5, 0xbb, 0x9e, 0x78, 0x48, 0x3d, 0xe6, 0xab, 0x43, 0x0f, 0x7d, 0x8b, 0xb2, 0xca, + 0x7c, 0x0a, 0xba, 0x0c, 0x45, 0xf6, 0x4b, 0xe9, 0x60, 0xcf, 0x53, 0xdb, 0x58, 0x34, 0xe9, 0x06, + 0x05, 0x46, 0xdd, 0x66, 0x44, 0xf4, 0x16, 0x2c, 0xc5, 0x7d, 0x08, 0xcd, 0x2f, 0xc5, 0x0e, 0x33, + 0xd7, 0x51, 0x47, 0x42, 0x92, 0xcc, 0x14, 0x67, 0x62, 0x25, 0x3b, 0x13, 0xb4, 0x0e, 0x4b, 0x86, + 0xe5, 0xf9, 0xaa, 0xa5, 0x61, 0xa5, 0xed, 0xda, 0x5d, 0x47, 0xe9, 0xba, 0xa6, 0x27, 0xda, 0xd4, + 0x3c, 0x2c, 0x06, 0x43, 0x9b, 0x64, 0x64, 0xcf, 0x35, 0x3d, 0xb2, 0x7a, 0x4c, 0x87, 0xcc, 0x75, + 0x38, 0x0c, 0x4b, 0x44, 0x83, 0xcc, 0x75, 0x5c, 0x80, 0x1c, 0xfe, 0xc2, 0x31, 0x5c, 0xae, 0xbf, + 0xef, 0x30, 0xfd, 0x31, 0x12, 0xd1, 0xdf, 0x5a, 0x05, 0x96, 0x12, 0x2c, 0xc1, 0xa9, 0xb2, 0x26, + 0x03, 0x66, 0x99, 0x5e, 0xd1, 0x2a, 0xa0, 0xd6, 0x6e, 0x65, 0x77, 0xaf, 0xd5, 0x17, 0x4f, 0x94, + 0x20, 0x4f, 0x23, 0x8d, 0x56, 0xbd, 0xb1, 0x53, 0xdf, 0xd9, 0x2c, 0x09, 0x28, 0x07, 0x73, 0xf2, + 0xde, 0x0e, 0x7d, 0x98, 0x42, 0x0b, 0x90, 0x93, 0x6b, 0xd5, 0xc6, 0x4e, 0xb5, 0xbe, 0x45, 0x08, + 0xd3, 0x28, 0x0f, 0xf3, 0xad, 0xdd, 0x46, 0xb3, 0x49, 0x9e, 0x32, 0x28, 0x0b, 0x33, 0x35, 0x59, + 0x6e, 0xc8, 0xa5, 0x19, 0xe9, 0xfb, 0x33, 0x50, 0xe0, 0xef, 0x72, 0xcf, 0xd1, 0x49, 0x72, 0xf2, + 0x36, 0x2c, 0xeb, 0xd8, 0x33, 0x5c, 0x72, 0x07, 0xa3, 0x47, 0x8a, 0x85, 0x03, 0x88, 0x8f, 0x45, + 0x8f, 0xd4, 0x1d, 0x58, 0x0b, 0x66, 0x24, 0x38, 0x2a, 0x16, 0x1d, 0x88, 0x9c, 0x63, 0x7b, 0xc0, + 0x5f, 0xed, 0xc1, 0x4a, 0x30, 0x3b, 0xee, 0x71, 0x66, 0x4f, 0xea, 0x71, 0x96, 0xf8, 0xfc, 0x58, + 0x7a, 0x53, 0xee, 0x13, 0x83, 0x38, 0x18, 0xc5, 0xd0, 0x03, 0xbf, 0x19, 0x11, 0x83, 0xb8, 0x92, + 0xba, 0x4e, 0x8e, 0x41, 0x30, 0x21, 0x52, 0x38, 0x60, 0x2e, 0xb4, 0xc4, 0x47, 0xea, 0x61, 0xfd, + 0xe0, 0x10, 0xce, 0x0d, 0x2e, 0x1f, 0x4d, 0x74, 0xb2, 0x43, 0x32, 0x90, 0x60, 0xd7, 0x68, 0x8e, + 0xb3, 0xd6, 0x87, 0x28, 0x9a, 0x3b, 0x5c, 0x87, 0x00, 0xaf, 0xd2, 0x73, 0x77, 0x40, 0xcf, 0x73, + 0x80, 0x6c, 0x2b, 0xf4, 0x7a, 0xbf, 0x22, 0xc0, 0xd5, 0xf0, 0x75, 0x8c, 0x34, 0xab, 0xf9, 0xe7, + 0x37, 0xab, 0x97, 0x83, 0x57, 0x3a, 0xdc, 0xba, 0xde, 0x82, 0xd5, 0x3e, 0x38, 0xc1, 0x89, 0xe2, + 0x19, 0x75, 0x6c, 0x19, 0x7e, 0xa6, 0xa4, 0x3f, 0x9e, 0x85, 0x6c, 0xc3, 0xc1, 0x2e, 0x15, 0x2a, + 0x31, 0x26, 0x0c, 0x0c, 0xf3, 0x54, 0xc4, 0x30, 0x3f, 0x80, 0xa2, 0x1d, 0x4c, 0x62, 0xef, 0x6f, + 0x7a, 0x88, 0x0d, 0x0b, 0xd7, 0x5f, 0x27, 0xaf, 0x54, 0x2e, 0x84, 0x53, 0xe9, 0x1b, 0xfe, 0x46, + 0x68, 0x07, 0x33, 0x74, 0x8d, 0xcb, 0x23, 0xd6, 0xe8, 0xb3, 0x84, 0xab, 0x30, 0xab, 0x63, 0x5f, + 0x35, 0x4c, 0x7e, 0x84, 0xf8, 0x53, 0x82, 0x85, 0x9c, 0x49, 0xb2, 0x90, 0x31, 0x9f, 0x34, 0xdb, + 0xe7, 0x93, 0x2e, 0x40, 0xce, 0x57, 0xdd, 0x36, 0xf6, 0xd9, 0x30, 0x3b, 0xd2, 0xc0, 0x48, 0x94, + 0xe1, 0x1c, 0x80, 0xe7, 0xab, 0xae, 0xcf, 0x6c, 0x14, 0xb0, 0x84, 0x8a, 0x52, 0xa8, 0x89, 0xff, + 0x1a, 0xf5, 0x5f, 0x6c, 0x90, 0x85, 0x64, 0x73, 0xd8, 0xd2, 0xc9, 0x90, 0x24, 0x8f, 0x34, 0x3d, + 0x39, 0x98, 0x6b, 0xd6, 0x76, 0x36, 0x12, 0xac, 0xce, 0x3c, 0x64, 0x36, 0x1a, 0x3b, 0x35, 0x66, + 0x6e, 0x2a, 0x77, 0x1b, 0xf2, 0x2e, 0x35, 0x37, 0xd2, 0x7f, 0x4c, 0x41, 0x86, 0xaa, 0x74, 0x19, + 0x4a, 0xbb, 0x9f, 0x36, 0x6b, 0x7d, 0x0b, 0x22, 0x28, 0x56, 0xe5, 0x5a, 0x65, 0xb7, 0xa6, 0x54, + 0xb7, 0xf6, 0x5a, 0xbb, 0x35, 0xb9, 0x24, 0x10, 0xda, 0x46, 0x6d, 0xab, 0x16, 0xa1, 0x4d, 0x11, + 0xda, 0x5e, 0x73, 0x53, 0xae, 0x6c, 0xd4, 0x94, 0xed, 0x0a, 0xa5, 0x4d, 0xa3, 0x45, 0x28, 0x04, + 0xb4, 0x9d, 0xc6, 0x46, 0xad, 0x55, 0xca, 0x10, 0x36, 0xb9, 0xd6, 0xac, 0xd4, 0xe5, 0x70, 0xea, + 0x0c, 0x9b, 0xba, 0x11, 0xdd, 0x62, 0x96, 0x80, 0xe1, 0xdb, 0x92, 0x99, 0x4a, 0xb3, 0xd1, 0xd8, + 0x2a, 0xcd, 0x11, 0x2a, 0xdf, 0xb8, 0x47, 0x9d, 0x47, 0x67, 0x41, 0x6c, 0xd5, 0x76, 0x7b, 0x24, + 0x65, 0xbb, 0xb2, 0x53, 0xd9, 0xac, 0x6d, 0xd7, 0x76, 0x76, 0x4b, 0x59, 0xb4, 0x02, 0x8b, 0x95, + 0xbd, 0xdd, 0x86, 0xc2, 0xb7, 0x65, 0x40, 0x80, 0x28, 0x90, 0x92, 0xe3, 0x00, 0x73, 0xa8, 0x08, + 0x40, 0x16, 0xdb, 0xaa, 0xdc, 0xad, 0x6d, 0xb5, 0x4a, 0x79, 0xb4, 0x04, 0x0b, 0xe4, 0x99, 0xc9, + 0xa4, 0x54, 0xf6, 0x76, 0xef, 0x97, 0x0a, 0x54, 0xfb, 0xb1, 0x1d, 0x5b, 0xf5, 0xcf, 0x6a, 0xa5, + 0x62, 0x48, 0xaf, 0xed, 0x3e, 0x6a, 0xc8, 0x0f, 0x95, 0x66, 0x63, 0xab, 0x5e, 0xfd, 0xb4, 0xb4, + 0x20, 0xfd, 0xbc, 0x00, 0xcb, 0x55, 0xea, 0xc4, 0xb9, 0x35, 0x97, 0xf1, 0x77, 0xba, 0xd8, 0xf3, + 0xc9, 0x51, 0x70, 0x5c, 0xfb, 0x73, 0xac, 0xf9, 0xc4, 0xfa, 0xb1, 0x0b, 0x94, 0xe5, 0x94, 0xba, + 0x9e, 0x78, 0x8b, 0xde, 0x85, 0x39, 0x1e, 0xba, 0xf0, 0x3a, 0xca, 0xd9, 0x61, 0x21, 0x80, 0x1c, + 0x30, 0x4b, 0x18, 0x16, 0x37, 0xb1, 0x3f, 0xfe, 0xfe, 0xb4, 0x3c, 0xc6, 0xf3, 0x14, 0x9d, 0x67, + 0xac, 0xd9, 0x20, 0x41, 0xa1, 0x69, 0xfe, 0x32, 0xf3, 0x55, 0x93, 0xde, 0x0a, 0xdd, 0x86, 0xd9, + 0x2e, 0xdd, 0x89, 0xa7, 0x88, 0xd2, 0x30, 0x45, 0x30, 0x4c, 0x32, 0x9f, 0x21, 0xfd, 0x93, 0x00, + 0x2b, 0x8c, 0x14, 0x66, 0x2e, 0x13, 0xc3, 0x79, 0x11, 0xf2, 0x31, 0x27, 0xc7, 0x7c, 0x35, 0x58, + 0x3d, 0xef, 0x76, 0x89, 0x73, 0x04, 0xb6, 0x97, 0x19, 0x1d, 0x9a, 0x05, 0x07, 0x6e, 0x3c, 0x5e, + 0x31, 0x9f, 0xed, 0xab, 0x98, 0x4b, 0xff, 0x2e, 0xc0, 0xb9, 0x16, 0xf6, 0x93, 0x7c, 0xd7, 0x4b, + 0x94, 0xeb, 0x01, 0xe4, 0xa2, 0x5e, 0x77, 0xe6, 0x94, 0x5e, 0x37, 0x3a, 0x59, 0xfa, 0xbe, 0x00, + 0x62, 0x0b, 0xfb, 0x5b, 0xb1, 0xf4, 0x7b, 0x72, 0xc2, 0x25, 0x14, 0x00, 0x32, 0x49, 0x05, 0x00, + 0xe9, 0x07, 0x02, 0xbc, 0xd2, 0xc2, 0xfe, 0x40, 0xe8, 0x34, 0x39, 0x68, 0xc9, 0x25, 0x87, 0x4c, + 0x4a, 0xc9, 0x41, 0xfa, 0xb1, 0x00, 0xab, 0x2d, 0xec, 0xc7, 0x82, 0xb2, 0x89, 0x61, 0x1b, 0xa8, + 0x4c, 0x64, 0x9e, 0xab, 0x32, 0x21, 0xfd, 0xa2, 0x00, 0x4b, 0xf4, 0x6d, 0xf3, 0xc0, 0x69, 0x72, + 0x88, 0x63, 0x55, 0x8a, 0x4c, 0x5f, 0x95, 0x42, 0xfa, 0x55, 0x01, 0x96, 0x98, 0x9d, 0x60, 0x11, + 0xd0, 0xe4, 0x70, 0x5c, 0x86, 0x62, 0x5f, 0x04, 0xc6, 0xde, 0x68, 0xa1, 0x13, 0x0b, 0xbd, 0xbe, + 0x9c, 0x82, 0x65, 0x72, 0xdc, 0x7a, 0x65, 0xab, 0x89, 0x21, 0xba, 0x0f, 0xb3, 0xaa, 0xe6, 0x07, + 0x48, 0x8a, 0x29, 0x05, 0x96, 0x24, 0x30, 0xeb, 0x15, 0x3a, 0x4f, 0xe6, 0xf3, 0xd1, 0x7b, 0xa1, + 0xa5, 0x3e, 0x61, 0x29, 0x2e, 0x30, 0xd3, 0x1f, 0xc1, 0x2c, 0x5b, 0x8a, 0xc4, 0x32, 0x7b, 0x3b, + 0x0f, 0x77, 0x1a, 0x8f, 0x76, 0x58, 0x82, 0x45, 0xfc, 0x6c, 0xb3, 0xd2, 0x6a, 0x3d, 0x6a, 0xc8, + 0x1b, 0x25, 0x81, 0x78, 0xf9, 0xcd, 0xda, 0x4e, 0x4d, 0x26, 0x11, 0x43, 0x48, 0x9e, 0x92, 0x0e, + 0x60, 0x79, 0x03, 0x9b, 0x78, 0xf2, 0xce, 0x48, 0xba, 0x0f, 0x4b, 0x5b, 0x86, 0x17, 0xf8, 0xd7, + 0x31, 0xce, 0xab, 0xd4, 0x85, 0xe5, 0xf8, 0x4a, 0x9e, 0x63, 0x5b, 0x1e, 0x46, 0xef, 0xc3, 0x3c, + 0xdf, 0xce, 0x13, 0x05, 0x5a, 0xf1, 0x1a, 0xee, 0xf9, 0x43, 0x6e, 0xf4, 0x2a, 0x14, 0x3a, 0x86, + 0xe7, 0x11, 0x6b, 0x41, 0x76, 0x60, 0x3d, 0x85, 0xac, 0x9c, 0xe7, 0xc4, 0xcf, 0x08, 0x4d, 0x3a, + 0x84, 0xa5, 0x4d, 0xec, 0x87, 0x11, 0xf3, 0x18, 0x9a, 0xba, 0x04, 0xf9, 0x5e, 0x9c, 0x1f, 0xea, + 0x2a, 0x17, 0xd2, 0xea, 0xba, 0xf4, 0x00, 0x56, 0x88, 0x8c, 0xe1, 0x6e, 0xe3, 0xe8, 0xcb, 0x82, + 0xd5, 0xaa, 0x6a, 0x69, 0xd8, 0x7c, 0x41, 0xd8, 0x9f, 0xc1, 0x6a, 0x3f, 0x76, 0xfe, 0x86, 0x3e, + 0x02, 0x08, 0x19, 0x83, 0x77, 0x74, 0x7e, 0x78, 0x62, 0x22, 0x47, 0x66, 0x9c, 0xec, 0x3d, 0x3d, + 0x84, 0xd5, 0x4d, 0xec, 0x13, 0xe3, 0x8e, 0xdd, 0x71, 0xad, 0xb9, 0xf4, 0x0b, 0x53, 0x90, 0x8f, + 0x2e, 0x85, 0xde, 0x85, 0x33, 0x3a, 0x7e, 0xac, 0x76, 0x4d, 0x7f, 0xa0, 0x40, 0xc6, 0x16, 0x5c, + 0xe1, 0xc3, 0x7d, 0x05, 0xb2, 0x75, 0x58, 0x3a, 0x52, 0x4d, 0x23, 0x5e, 0x95, 0x08, 0x3e, 0x37, + 0x58, 0xa4, 0x43, 0x91, 0xa2, 0x84, 0xc7, 0xf2, 0x79, 0xb6, 0x4f, 0x24, 0xac, 0xc9, 0x04, 0xf9, + 0x3c, 0x1d, 0xe9, 0xe5, 0xf3, 0xd7, 0x80, 0x2d, 0x11, 0xe1, 0xf5, 0xc4, 0x19, 0xba, 0xf6, 0x02, + 0x1d, 0x08, 0x59, 0x3d, 0x74, 0x13, 0x56, 0x18, 0x6f, 0xdc, 0x9a, 0xb2, 0x4f, 0x09, 0xb2, 0x32, + 0x83, 0x19, 0x4b, 0x67, 0x3d, 0xe9, 0x0f, 0x04, 0x58, 0x61, 0xf1, 0xf9, 0xe4, 0xa3, 0xc1, 0xdb, + 0x90, 0x0d, 0xa3, 0x26, 0xee, 0x1d, 0x47, 0x94, 0xd4, 0xe7, 0x83, 0x88, 0x4a, 0xfa, 0x65, 0x01, + 0x56, 0x98, 0x3d, 0xfb, 0x7f, 0x10, 0xb5, 0x12, 0xe3, 0x4a, 0x2e, 0x42, 0x00, 0x65, 0x72, 0x3e, + 0x5a, 0xfa, 0x25, 0x01, 0xd0, 0x66, 0x2f, 0xba, 0x7d, 0x99, 0x42, 0xff, 0x57, 0x06, 0xe6, 0x03, + 0x1c, 0x89, 0x95, 0x8f, 0xf7, 0x60, 0x96, 0x87, 0x3e, 0x53, 0x27, 0x6b, 0x5c, 0x71, 0xf6, 0x53, + 0x36, 0xc9, 0x86, 0x96, 0xc5, 0x45, 0x98, 0x0b, 0x6e, 0x2d, 0xab, 0x8c, 0x07, 0x8f, 0x69, 0xe5, + 0xd7, 0xc7, 0x69, 0xe5, 0xd7, 0x3b, 0x61, 0x9d, 0xa5, 0x4d, 0x63, 0x80, 0xd7, 0x86, 0x1e, 0xd5, + 0xd1, 0x05, 0xe7, 0x83, 0xa4, 0x72, 0x4a, 0x5f, 0x9a, 0x90, 0x19, 0x23, 0x4d, 0x40, 0x55, 0x80, + 0x8e, 0x6a, 0xa9, 0x6d, 0xdc, 0xc1, 0x96, 0xcf, 0xc3, 0x8d, 0x57, 0x53, 0x97, 0xda, 0x0e, 0x59, + 0xe5, 0xc8, 0x34, 0x92, 0xaf, 0x8f, 0x59, 0xe3, 0x5d, 0x05, 0xc4, 0x1f, 0x94, 0x47, 0xf5, 0xdd, + 0xfb, 0x0a, 0xab, 0xe8, 0x4e, 0xf7, 0xd7, 0x7e, 0x33, 0xb1, 0xda, 0xef, 0x4c, 0xaf, 0xf6, 0x3b, + 0x2b, 0xfd, 0xa1, 0x00, 0xc5, 0x38, 0x44, 0xe2, 0x9c, 0x88, 0xa8, 0x4a, 0xd7, 0x69, 0xbb, 0xaa, + 0x1e, 0x7c, 0x53, 0x42, 0xc5, 0xdf, 0x63, 0x24, 0x74, 0x81, 0xa9, 0x52, 0x71, 0xb1, 0xa3, 0x1a, + 0x2e, 0xef, 0x3d, 0x03, 0x21, 0xc9, 0x94, 0x82, 0x9a, 0xb0, 0xc0, 0xa7, 0x2b, 0xb6, 0x13, 0xd4, + 0x2a, 0xd3, 0x9b, 0x44, 0x95, 0xde, 0xda, 0x0d, 0xc6, 0x2e, 0x17, 0xbb, 0xb1, 0x67, 0xa9, 0x03, + 0x68, 0x90, 0x0b, 0x7d, 0x1d, 0xce, 0x44, 0xb1, 0x2a, 0x91, 0x8a, 0x17, 0xbb, 0x2d, 0xcb, 0x11, + 0xd8, 0xad, 0xb0, 0xf8, 0x35, 0xb2, 0x97, 0x2c, 0xfd, 0x8b, 0x00, 0x67, 0x23, 0x99, 0x6e, 0xe4, + 0x0d, 0xbe, 0xc4, 0x44, 0xf7, 0x2b, 0x39, 0x75, 0x5f, 0xb2, 0x44, 0x2d, 0x90, 0xac, 0x65, 0x3c, + 0xc1, 0x2f, 0x53, 0xa6, 0x73, 0xbc, 0xf9, 0xcb, 0xec, 0xd0, 0x0c, 0xb5, 0x43, 0x59, 0x2b, 0x30, + 0x40, 0xd2, 0x6f, 0x08, 0x70, 0x5e, 0xb6, 0x4d, 0x73, 0x5f, 0xd5, 0x0e, 0x03, 0xc8, 0xfc, 0x75, + 0xbe, 0x4c, 0xfb, 0xbc, 0xc7, 0x22, 0xcb, 0x88, 0x53, 0xe2, 0xc1, 0x59, 0xbc, 0x97, 0x2d, 0x9c, + 0xae, 0x97, 0x2d, 0x3d, 0x85, 0xa5, 0xa4, 0xda, 0x7f, 0xfa, 0x57, 0x3c, 0xaf, 0x41, 0xb1, 0x63, + 0x58, 0x51, 0x4b, 0xce, 0x3e, 0xce, 0xcc, 0x77, 0x0c, 0xab, 0x67, 0xc5, 0x09, 0x97, 0xfa, 0xc5, + 0xa0, 0xbd, 0xcf, 0x77, 0xd4, 0x2f, 0x42, 0x2e, 0xe9, 0xaf, 0xa7, 0xa0, 0x44, 0x92, 0x61, 0xda, + 0xb0, 0x9a, 0x9c, 0x72, 0xf7, 0x07, 0x3b, 0xeb, 0xec, 0x33, 0xcf, 0x0f, 0xd2, 0x12, 0xbf, 0x18, + 0xa2, 0xe7, 0x6f, 0xb1, 0xcf, 0x24, 0xb7, 0xd8, 0xbf, 0x8a, 0x66, 0xdd, 0xf7, 0x04, 0x9a, 0x2e, + 0x47, 0x3a, 0xf0, 0x13, 0x53, 0x5f, 0xe4, 0x2c, 0x64, 0xe2, 0x5f, 0x21, 0x7d, 0x0e, 0xab, 0xd4, + 0xc2, 0xd5, 0x9b, 0x32, 0xff, 0x1e, 0x78, 0x72, 0xa1, 0x52, 0x07, 0xbe, 0x56, 0xb5, 0x3b, 0x0e, + 0x89, 0x11, 0x5f, 0xc4, 0x76, 0x87, 0xb0, 0x38, 0xf0, 0x75, 0x2b, 0x79, 0xc9, 0x91, 0xef, 0x5b, + 0xf9, 0xc1, 0x26, 0xbb, 0x4d, 0xcb, 0x25, 0x35, 0xca, 0x4d, 0xae, 0xc0, 0x55, 0x88, 0xd2, 0x58, + 0x1e, 0xc0, 0x00, 0x2c, 0x44, 0xe8, 0xb4, 0xc8, 0xf9, 0x13, 0x01, 0xce, 0x10, 0x03, 0x19, 0xfb, + 0x12, 0x62, 0x62, 0xef, 0x73, 0xf0, 0xf3, 0x8c, 0xcc, 0x73, 0x7e, 0x9e, 0x71, 0xf3, 0xb7, 0xaf, + 0x42, 0x91, 0x27, 0x4c, 0xcc, 0xf6, 0xbb, 0xe8, 0x77, 0x04, 0xc8, 0x47, 0xd3, 0x7c, 0x94, 0x1c, + 0xef, 0x24, 0xd4, 0x14, 0xd6, 0xae, 0x9e, 0x80, 0x93, 0x19, 0x3d, 0xe9, 0xbd, 0xef, 0xfd, 0xf3, + 0x7f, 0xfe, 0xfa, 0xd4, 0x0d, 0x54, 0x2e, 0x1f, 0xdd, 0x28, 0x73, 0x6d, 0x78, 0xe5, 0xa7, 0x3d, + 0x4d, 0x3d, 0x2b, 0xd3, 0x4c, 0xb3, 0xfc, 0x94, 0xfc, 0xf3, 0xac, 0x1c, 0x96, 0x0c, 0x7e, 0x4b, + 0x00, 0xe8, 0xb5, 0x0b, 0x50, 0xf2, 0x17, 0xa7, 0x03, 0xfd, 0x84, 0xb5, 0xa1, 0x15, 0x09, 0x69, + 0x83, 0xa2, 0xf9, 0x08, 0xdd, 0x39, 0x25, 0x9a, 0xf2, 0xd3, 0xde, 0x7b, 0x7a, 0x86, 0x7e, 0x53, + 0x80, 0x42, 0xac, 0x99, 0x82, 0x92, 0x15, 0x92, 0xd4, 0x70, 0x59, 0x1b, 0x91, 0x8e, 0x4b, 0xb7, + 0x29, 0xc4, 0x5b, 0xd2, 0x69, 0x15, 0x76, 0x5b, 0xb8, 0x86, 0x7e, 0x5f, 0x80, 0x42, 0xac, 0xf5, + 0x91, 0x02, 0x2c, 0xa9, 0x3d, 0x32, 0x12, 0xd8, 0x26, 0x05, 0x56, 0x59, 0x1b, 0x4b, 0x77, 0x04, + 0xe5, 0x3f, 0x08, 0x50, 0x8c, 0x77, 0x3e, 0xd0, 0xb5, 0x21, 0x30, 0xfb, 0x72, 0xae, 0x91, 0x38, + 0xdb, 0x14, 0xa7, 0x2a, 0xfd, 0xec, 0x38, 0x38, 0xcb, 0xa1, 0xe3, 0x2d, 0x3f, 0x8d, 0xfa, 0xfb, + 0x67, 0x65, 0x56, 0x17, 0x24, 0x72, 0xfc, 0x5b, 0x3c, 0x5a, 0x8a, 0x7a, 0xe5, 0x9b, 0x69, 0xfe, + 0x2a, 0xbd, 0x3d, 0x32, 0x52, 0x2e, 0x93, 0xca, 0xf5, 0x58, 0x52, 0x27, 0x23, 0x57, 0x24, 0x85, + 0x21, 0xc2, 0xfd, 0x85, 0x00, 0x8b, 0x03, 0xcd, 0x0e, 0xf4, 0x56, 0xaa, 0x1f, 0x4e, 0x6a, 0x8a, + 0x8c, 0x14, 0xa9, 0x41, 0x45, 0xaa, 0x4b, 0x1b, 0x63, 0x89, 0xc4, 0xdb, 0x21, 0x04, 0xf5, 0xdf, + 0x31, 0x67, 0x3b, 0xf8, 0x15, 0x49, 0x7a, 0xe5, 0x38, 0xa5, 0x6b, 0x32, 0x12, 0xbb, 0x4c, 0xb1, + 0x6f, 0x49, 0x9b, 0x63, 0x61, 0xef, 0x35, 0x4b, 0x08, 0xfc, 0x3f, 0x11, 0x60, 0xa1, 0xaf, 0x51, + 0x82, 0xae, 0xa7, 0x21, 0x4f, 0x68, 0xa7, 0x8c, 0x04, 0xbd, 0x43, 0x41, 0xdf, 0x97, 0xaa, 0x63, + 0x81, 0x66, 0x7d, 0x12, 0x02, 0xf8, 0x4b, 0x01, 0xf2, 0xd1, 0x26, 0x49, 0x8a, 0x0f, 0x49, 0xe8, + 0xa3, 0x8c, 0x84, 0xfa, 0x4d, 0x0a, 0xf5, 0xa1, 0x74, 0x6f, 0xcc, 0xb3, 0xc1, 0xb7, 0x25, 0x68, + 0xff, 0x48, 0x80, 0x7c, 0xb4, 0x95, 0x92, 0x82, 0x36, 0xa1, 0xdb, 0xf2, 0x82, 0x14, 0xcb, 0x0a, + 0x86, 0x04, 0xea, 0x9f, 0x0b, 0x50, 0x88, 0xf5, 0x35, 0x52, 0x2c, 0x79, 0x52, 0xef, 0x63, 0x24, + 0xd8, 0x3d, 0x0a, 0xb6, 0x21, 0x3d, 0x18, 0xcb, 0x92, 0x7b, 0xd1, 0xad, 0x09, 0xe6, 0xdf, 0x15, + 0xa0, 0x10, 0xeb, 0x75, 0xa4, 0x60, 0x4e, 0xea, 0x87, 0x8c, 0xc4, 0xcc, 0x3d, 0xf7, 0xb5, 0xf1, + 0x3c, 0xf7, 0x0f, 0x05, 0x28, 0xc6, 0x4b, 0xe7, 0x29, 0xae, 0x27, 0xb1, 0x37, 0xb0, 0x76, 0xfd, + 0x44, 0xbc, 0x3c, 0xf2, 0xf9, 0x80, 0x22, 0x7e, 0x07, 0xdd, 0x38, 0x21, 0xe2, 0x48, 0x19, 0xfe, + 0xf7, 0x04, 0xc8, 0x47, 0x5b, 0x21, 0x29, 0x07, 0x35, 0xa1, 0x5b, 0x32, 0x52, 0x8f, 0xf7, 0x29, + 0xaa, 0xbb, 0xe8, 0xe3, 0x53, 0xa3, 0x2a, 0x3f, 0x8d, 0xf6, 0x25, 0x9e, 0xa1, 0x1f, 0x09, 0xb0, + 0xd0, 0xd7, 0xf6, 0x48, 0x31, 0x56, 0xc9, 0xcd, 0x91, 0xb5, 0xd5, 0x80, 0x39, 0xf8, 0x5b, 0xc4, + 0xf5, 0x5a, 0xc7, 0xf1, 0x8f, 0x4f, 0x6d, 0x59, 0x53, 0x21, 0xde, 0xd6, 0xe8, 0xc6, 0xe4, 0x6c, + 0xfe, 0x40, 0x80, 0x85, 0xbe, 0xa6, 0x45, 0x0a, 0xd8, 0xe4, 0xd6, 0xc6, 0xda, 0xa5, 0x94, 0xeb, + 0xd7, 0xe3, 0x94, 0x3e, 0xa4, 0xb8, 0xbf, 0x8e, 0xde, 0x39, 0x21, 0x6e, 0x8f, 0x4e, 0xe6, 0xb5, + 0xd7, 0x9f, 0x08, 0x50, 0x88, 0x95, 0x0d, 0x50, 0x7a, 0x90, 0xdd, 0x5f, 0xef, 0x5e, 0xbb, 0x76, + 0x12, 0x56, 0x7e, 0x2c, 0xb9, 0xa5, 0x42, 0xf7, 0xbe, 0x9a, 0x30, 0x02, 0xfd, 0xa5, 0x00, 0xb9, + 0x48, 0x65, 0x1c, 0xbd, 0x91, 0xa6, 0xd5, 0xfe, 0x38, 0x6e, 0x78, 0xe9, 0x43, 0xfa, 0x16, 0xc5, + 0xf9, 0x08, 0xed, 0x4d, 0x24, 0xdc, 0x41, 0x7f, 0x2a, 0x40, 0x31, 0xde, 0x70, 0x49, 0xb1, 0x04, + 0x89, 0x5d, 0x99, 0x17, 0xe4, 0xbd, 0x42, 0xf4, 0xe4, 0x08, 0xff, 0xad, 0x00, 0xc5, 0x78, 0xeb, + 0x25, 0x05, 0x71, 0x62, 0x7f, 0x66, 0x24, 0x62, 0xae, 0xef, 0x6b, 0x13, 0xd2, 0xf7, 0xbf, 0x0a, + 0x70, 0x26, 0xa5, 0x58, 0x87, 0x92, 0x3f, 0x2f, 0x1d, 0x5e, 0xda, 0x1b, 0x29, 0x8f, 0x41, 0xe5, + 0xd1, 0xa4, 0x6f, 0x4f, 0x44, 0x9e, 0xdb, 0x2e, 0x47, 0xc7, 0x13, 0x81, 0x95, 0xc4, 0x82, 0x30, + 0xba, 0x31, 0x2a, 0x0f, 0x18, 0x28, 0x1e, 0x8f, 0x94, 0xcb, 0xa2, 0x72, 0x1d, 0x48, 0xda, 0x64, + 0xd2, 0x00, 0xea, 0xd5, 0x03, 0x4c, 0x44, 0xb8, 0x1f, 0x09, 0x90, 0x0d, 0x0b, 0x6d, 0xe8, 0xf2, + 0x89, 0x0a, 0x71, 0x23, 0x85, 0xf8, 0x84, 0x0a, 0xd1, 0x94, 0x1e, 0x8e, 0x25, 0x44, 0xbc, 0xb2, + 0xc7, 0x03, 0xe8, 0x42, 0xac, 0xd8, 0x96, 0x1e, 0x36, 0x0d, 0x14, 0xe4, 0x5e, 0x50, 0xc4, 0xdf, + 0xfb, 0xf3, 0x1b, 0x02, 0xf8, 0xaf, 0x48, 0xc4, 0x1f, 0xaf, 0xcc, 0xa5, 0x45, 0xfc, 0x89, 0xf5, + 0xbb, 0x91, 0xa0, 0x1f, 0x51, 0xd0, 0xdf, 0x94, 0xb6, 0xc6, 0x8b, 0xf5, 0xe8, 0xe6, 0x4e, 0xb0, + 0x39, 0x41, 0xfe, 0xf7, 0x02, 0xa0, 0xc1, 0x3a, 0x1f, 0x5a, 0x4f, 0x36, 0xa2, 0x69, 0x05, 0xc1, + 0x91, 0xf8, 0x3f, 0xa3, 0xf8, 0x77, 0xa5, 0xc6, 0x58, 0xf8, 0xb5, 0x60, 0xff, 0x98, 0x08, 0xff, + 0xc8, 0xd2, 0xad, 0x68, 0xbb, 0x23, 0x3d, 0xdd, 0x4a, 0x68, 0x8a, 0x8c, 0x04, 0x7f, 0x40, 0xc1, + 0xef, 0x4b, 0xdf, 0x9a, 0xd8, 0x5d, 0x25, 0x68, 0x88, 0x28, 0x7f, 0x23, 0xd0, 0x02, 0x7d, 0xfc, + 0xcf, 0x5b, 0xdf, 0x4c, 0x95, 0x25, 0xa1, 0x7e, 0x39, 0x52, 0x98, 0x9f, 0xa6, 0xc2, 0xc8, 0xd2, + 0xf6, 0xb8, 0x59, 0x43, 0x6c, 0xf7, 0xdb, 0xc2, 0xb5, 0xbb, 0x16, 0x9c, 0xd1, 0xec, 0x4e, 0xd2, + 0xf6, 0x77, 0x97, 0x78, 0x9a, 0xc0, 0x93, 0xf3, 0x26, 0x89, 0x14, 0x9b, 0xc2, 0x67, 0x77, 0x38, + 0x6f, 0xdb, 0x36, 0x55, 0xab, 0xbd, 0x6e, 0xbb, 0xed, 0x72, 0x1b, 0x5b, 0x34, 0x8e, 0x2c, 0xb3, + 0x21, 0xd5, 0x31, 0xbc, 0xd8, 0x7f, 0xa1, 0xf1, 0x61, 0xf8, 0xb0, 0x3f, 0x4b, 0x19, 0xdf, 0xf9, + 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0e, 0xd3, 0x30, 0x4e, 0x6a, 0x43, 0x00, 0x00, } diff --git a/vendor/google.golang.org/genproto/googleapis/datastore/admin/v1beta1/datastore_admin.pb.go b/vendor/google.golang.org/genproto/googleapis/datastore/admin/v1beta1/datastore_admin.pb.go new file mode 100644 index 00000000..bf78d241 --- /dev/null +++ b/vendor/google.golang.org/genproto/googleapis/datastore/admin/v1beta1/datastore_admin.pb.go @@ -0,0 +1,731 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: google/datastore/admin/v1beta1/datastore_admin.proto + +/* +Package admin is a generated protocol buffer package. + +It is generated from these files: + google/datastore/admin/v1beta1/datastore_admin.proto + +It has these top-level messages: + CommonMetadata + Progress + ExportEntitiesRequest + ImportEntitiesRequest + ExportEntitiesResponse + ExportEntitiesMetadata + ImportEntitiesMetadata + EntityFilter +*/ +package admin + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" +import _ "google.golang.org/genproto/googleapis/api/annotations" +import google_longrunning "google.golang.org/genproto/googleapis/longrunning" +import google_protobuf3 "github.com/golang/protobuf/ptypes/timestamp" + +import ( + context "golang.org/x/net/context" + grpc "google.golang.org/grpc" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +// Operation types. +type OperationType int32 + +const ( + // Unspecified. + OperationType_OPERATION_TYPE_UNSPECIFIED OperationType = 0 + // ExportEntities. + OperationType_EXPORT_ENTITIES OperationType = 1 + // ImportEntities. + OperationType_IMPORT_ENTITIES OperationType = 2 +) + +var OperationType_name = map[int32]string{ + 0: "OPERATION_TYPE_UNSPECIFIED", + 1: "EXPORT_ENTITIES", + 2: "IMPORT_ENTITIES", +} +var OperationType_value = map[string]int32{ + "OPERATION_TYPE_UNSPECIFIED": 0, + "EXPORT_ENTITIES": 1, + "IMPORT_ENTITIES": 2, +} + +func (x OperationType) String() string { + return proto.EnumName(OperationType_name, int32(x)) +} +func (OperationType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } + +// The various possible states for an ongoing Operation. +type CommonMetadata_State int32 + +const ( + // Unspecified. + CommonMetadata_STATE_UNSPECIFIED CommonMetadata_State = 0 + // Request is being prepared for processing. + CommonMetadata_INITIALIZING CommonMetadata_State = 1 + // Request is actively being processed. + CommonMetadata_PROCESSING CommonMetadata_State = 2 + // Request is in the process of being cancelled after user called + // longrunning.Operations.CancelOperation on the operation. + CommonMetadata_CANCELLING CommonMetadata_State = 3 + // Request has been processed and is in its finalization stage. + CommonMetadata_FINALIZING CommonMetadata_State = 4 + // Request has completed successfully. + CommonMetadata_SUCCESSFUL CommonMetadata_State = 5 + // Request has finished being processed, but encountered an error. + CommonMetadata_FAILED CommonMetadata_State = 6 + // Request has finished being cancelled after user called + // longrunning.Operations.CancelOperation. + CommonMetadata_CANCELLED CommonMetadata_State = 7 +) + +var CommonMetadata_State_name = map[int32]string{ + 0: "STATE_UNSPECIFIED", + 1: "INITIALIZING", + 2: "PROCESSING", + 3: "CANCELLING", + 4: "FINALIZING", + 5: "SUCCESSFUL", + 6: "FAILED", + 7: "CANCELLED", +} +var CommonMetadata_State_value = map[string]int32{ + "STATE_UNSPECIFIED": 0, + "INITIALIZING": 1, + "PROCESSING": 2, + "CANCELLING": 3, + "FINALIZING": 4, + "SUCCESSFUL": 5, + "FAILED": 6, + "CANCELLED": 7, +} + +func (x CommonMetadata_State) String() string { + return proto.EnumName(CommonMetadata_State_name, int32(x)) +} +func (CommonMetadata_State) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 0} } + +// Metadata common to all Datastore Admin operations. +type CommonMetadata struct { + // The time that work began on the operation. + StartTime *google_protobuf3.Timestamp `protobuf:"bytes,1,opt,name=start_time,json=startTime" json:"start_time,omitempty"` + // The time the operation ended, either successfully or otherwise. + EndTime *google_protobuf3.Timestamp `protobuf:"bytes,2,opt,name=end_time,json=endTime" json:"end_time,omitempty"` + // The type of the operation. Can be used as a filter in + // ListOperationsRequest. + OperationType OperationType `protobuf:"varint,3,opt,name=operation_type,json=operationType,enum=google.datastore.admin.v1beta1.OperationType" json:"operation_type,omitempty"` + // The client-assigned labels which were provided when the operation was + // created. May also include additional labels. + Labels map[string]string `protobuf:"bytes,4,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // The current state of the Operation. + State CommonMetadata_State `protobuf:"varint,5,opt,name=state,enum=google.datastore.admin.v1beta1.CommonMetadata_State" json:"state,omitempty"` +} + +func (m *CommonMetadata) Reset() { *m = CommonMetadata{} } +func (m *CommonMetadata) String() string { return proto.CompactTextString(m) } +func (*CommonMetadata) ProtoMessage() {} +func (*CommonMetadata) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } + +func (m *CommonMetadata) GetStartTime() *google_protobuf3.Timestamp { + if m != nil { + return m.StartTime + } + return nil +} + +func (m *CommonMetadata) GetEndTime() *google_protobuf3.Timestamp { + if m != nil { + return m.EndTime + } + return nil +} + +func (m *CommonMetadata) GetOperationType() OperationType { + if m != nil { + return m.OperationType + } + return OperationType_OPERATION_TYPE_UNSPECIFIED +} + +func (m *CommonMetadata) GetLabels() map[string]string { + if m != nil { + return m.Labels + } + return nil +} + +func (m *CommonMetadata) GetState() CommonMetadata_State { + if m != nil { + return m.State + } + return CommonMetadata_STATE_UNSPECIFIED +} + +// Measures the progress of a particular metric. +type Progress struct { + // Note that this may be greater than work_estimated. + WorkCompleted int64 `protobuf:"varint,1,opt,name=work_completed,json=workCompleted" json:"work_completed,omitempty"` + // An estimate of how much work needs to be performed. May be zero if the + // work estimate is unavailable. + WorkEstimated int64 `protobuf:"varint,2,opt,name=work_estimated,json=workEstimated" json:"work_estimated,omitempty"` +} + +func (m *Progress) Reset() { *m = Progress{} } +func (m *Progress) String() string { return proto.CompactTextString(m) } +func (*Progress) ProtoMessage() {} +func (*Progress) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } + +func (m *Progress) GetWorkCompleted() int64 { + if m != nil { + return m.WorkCompleted + } + return 0 +} + +func (m *Progress) GetWorkEstimated() int64 { + if m != nil { + return m.WorkEstimated + } + return 0 +} + +// The request for +// [google.datastore.admin.v1beta1.DatastoreAdmin.ExportEntities][google.datastore.admin.v1beta1.DatastoreAdmin.ExportEntities]. +type ExportEntitiesRequest struct { + // Project ID against which to make the request. + ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId" json:"project_id,omitempty"` + // Client-assigned labels. + Labels map[string]string `protobuf:"bytes,2,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // Description of what data from the project is included in the export. + EntityFilter *EntityFilter `protobuf:"bytes,3,opt,name=entity_filter,json=entityFilter" json:"entity_filter,omitempty"` + // Location for the export metadata and data files. + // + // The full resource URL of the external storage location. Currently, only + // Google Cloud Storage is supported. So output_url_prefix should be of the + // form: `gs://BUCKET_NAME[/NAMESPACE_PATH]`, where `BUCKET_NAME` is the + // name of the Cloud Storage bucket and `NAMESPACE_PATH` is an optional Cloud + // Storage namespace path (this is not a Cloud Datastore namespace). For more + // information about Cloud Storage namespace paths, see + // [Object name + // considerations](https://cloud.google.com/storage/docs/naming#object-considerations). + // + // The resulting files will be nested deeper than the specified URL prefix. + // The final output URL will be provided in the + // [google.datastore.admin.v1beta1.ExportEntitiesResponse.output_url][google.datastore.admin.v1beta1.ExportEntitiesResponse.output_url] + // field. That value should be used for subsequent ImportEntities operations. + // + // By nesting the data files deeper, the same Cloud Storage bucket can be used + // in multiple ExportEntities operations without conflict. + OutputUrlPrefix string `protobuf:"bytes,4,opt,name=output_url_prefix,json=outputUrlPrefix" json:"output_url_prefix,omitempty"` +} + +func (m *ExportEntitiesRequest) Reset() { *m = ExportEntitiesRequest{} } +func (m *ExportEntitiesRequest) String() string { return proto.CompactTextString(m) } +func (*ExportEntitiesRequest) ProtoMessage() {} +func (*ExportEntitiesRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } + +func (m *ExportEntitiesRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *ExportEntitiesRequest) GetLabels() map[string]string { + if m != nil { + return m.Labels + } + return nil +} + +func (m *ExportEntitiesRequest) GetEntityFilter() *EntityFilter { + if m != nil { + return m.EntityFilter + } + return nil +} + +func (m *ExportEntitiesRequest) GetOutputUrlPrefix() string { + if m != nil { + return m.OutputUrlPrefix + } + return "" +} + +// The request for +// [google.datastore.admin.v1beta1.DatastoreAdmin.ImportEntities][google.datastore.admin.v1beta1.DatastoreAdmin.ImportEntities]. +type ImportEntitiesRequest struct { + // Project ID against which to make the request. + ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId" json:"project_id,omitempty"` + // Client-assigned labels. + Labels map[string]string `protobuf:"bytes,2,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // The full resource URL of the external storage location. Currently, only + // Google Cloud Storage is supported. So input_url should be of the form: + // `gs://BUCKET_NAME[/NAMESPACE_PATH]/OVERALL_EXPORT_METADATA_FILE`, where + // `BUCKET_NAME` is the name of the Cloud Storage bucket, `NAMESPACE_PATH` is + // an optional Cloud Storage namespace path (this is not a Cloud Datastore + // namespace), and `OVERALL_EXPORT_METADATA_FILE` is the metadata file written + // by the ExportEntities operation. For more information about Cloud Storage + // namespace paths, see + // [Object name + // considerations](https://cloud.google.com/storage/docs/naming#object-considerations). + // + // For more information, see + // [google.datastore.admin.v1beta1.ExportEntitiesResponse.output_url][google.datastore.admin.v1beta1.ExportEntitiesResponse.output_url]. + InputUrl string `protobuf:"bytes,3,opt,name=input_url,json=inputUrl" json:"input_url,omitempty"` + // Optionally specify which kinds/namespaces are to be imported. If provided, + // the list must be a subset of the EntityFilter used in creating the export, + // otherwise a FAILED_PRECONDITION error will be returned. If no filter is + // specified then all entities from the export are imported. + EntityFilter *EntityFilter `protobuf:"bytes,4,opt,name=entity_filter,json=entityFilter" json:"entity_filter,omitempty"` +} + +func (m *ImportEntitiesRequest) Reset() { *m = ImportEntitiesRequest{} } +func (m *ImportEntitiesRequest) String() string { return proto.CompactTextString(m) } +func (*ImportEntitiesRequest) ProtoMessage() {} +func (*ImportEntitiesRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } + +func (m *ImportEntitiesRequest) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *ImportEntitiesRequest) GetLabels() map[string]string { + if m != nil { + return m.Labels + } + return nil +} + +func (m *ImportEntitiesRequest) GetInputUrl() string { + if m != nil { + return m.InputUrl + } + return "" +} + +func (m *ImportEntitiesRequest) GetEntityFilter() *EntityFilter { + if m != nil { + return m.EntityFilter + } + return nil +} + +// The response for +// [google.datastore.admin.v1beta1.DatastoreAdmin.ExportEntities][google.datastore.admin.v1beta1.DatastoreAdmin.ExportEntities]. +type ExportEntitiesResponse struct { + // Location of the output metadata file. This can be used to begin an import + // into Cloud Datastore (this project or another project). See + // [google.datastore.admin.v1beta1.ImportEntitiesRequest.input_url][google.datastore.admin.v1beta1.ImportEntitiesRequest.input_url]. + // Only present if the operation completed successfully. + OutputUrl string `protobuf:"bytes,1,opt,name=output_url,json=outputUrl" json:"output_url,omitempty"` +} + +func (m *ExportEntitiesResponse) Reset() { *m = ExportEntitiesResponse{} } +func (m *ExportEntitiesResponse) String() string { return proto.CompactTextString(m) } +func (*ExportEntitiesResponse) ProtoMessage() {} +func (*ExportEntitiesResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } + +func (m *ExportEntitiesResponse) GetOutputUrl() string { + if m != nil { + return m.OutputUrl + } + return "" +} + +// Metadata for ExportEntities operations. +type ExportEntitiesMetadata struct { + // Metadata common to all Datastore Admin operations. + Common *CommonMetadata `protobuf:"bytes,1,opt,name=common" json:"common,omitempty"` + // An estimate of the number of entities processed. + ProgressEntities *Progress `protobuf:"bytes,2,opt,name=progress_entities,json=progressEntities" json:"progress_entities,omitempty"` + // An estimate of the number of bytes processed. + ProgressBytes *Progress `protobuf:"bytes,3,opt,name=progress_bytes,json=progressBytes" json:"progress_bytes,omitempty"` + // Description of which entities are being exported. + EntityFilter *EntityFilter `protobuf:"bytes,4,opt,name=entity_filter,json=entityFilter" json:"entity_filter,omitempty"` + // Location for the export metadata and data files. This will be the same + // value as the + // [google.datastore.admin.v1beta1.ExportEntitiesRequest.output_url_prefix][google.datastore.admin.v1beta1.ExportEntitiesRequest.output_url_prefix] + // field. The final output location is provided in + // [google.datastore.admin.v1beta1.ExportEntitiesResponse.output_url][google.datastore.admin.v1beta1.ExportEntitiesResponse.output_url]. + OutputUrlPrefix string `protobuf:"bytes,5,opt,name=output_url_prefix,json=outputUrlPrefix" json:"output_url_prefix,omitempty"` +} + +func (m *ExportEntitiesMetadata) Reset() { *m = ExportEntitiesMetadata{} } +func (m *ExportEntitiesMetadata) String() string { return proto.CompactTextString(m) } +func (*ExportEntitiesMetadata) ProtoMessage() {} +func (*ExportEntitiesMetadata) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } + +func (m *ExportEntitiesMetadata) GetCommon() *CommonMetadata { + if m != nil { + return m.Common + } + return nil +} + +func (m *ExportEntitiesMetadata) GetProgressEntities() *Progress { + if m != nil { + return m.ProgressEntities + } + return nil +} + +func (m *ExportEntitiesMetadata) GetProgressBytes() *Progress { + if m != nil { + return m.ProgressBytes + } + return nil +} + +func (m *ExportEntitiesMetadata) GetEntityFilter() *EntityFilter { + if m != nil { + return m.EntityFilter + } + return nil +} + +func (m *ExportEntitiesMetadata) GetOutputUrlPrefix() string { + if m != nil { + return m.OutputUrlPrefix + } + return "" +} + +// Metadata for ImportEntities operations. +type ImportEntitiesMetadata struct { + // Metadata common to all Datastore Admin operations. + Common *CommonMetadata `protobuf:"bytes,1,opt,name=common" json:"common,omitempty"` + // An estimate of the number of entities processed. + ProgressEntities *Progress `protobuf:"bytes,2,opt,name=progress_entities,json=progressEntities" json:"progress_entities,omitempty"` + // An estimate of the number of bytes processed. + ProgressBytes *Progress `protobuf:"bytes,3,opt,name=progress_bytes,json=progressBytes" json:"progress_bytes,omitempty"` + // Description of which entities are being imported. + EntityFilter *EntityFilter `protobuf:"bytes,4,opt,name=entity_filter,json=entityFilter" json:"entity_filter,omitempty"` + // The location of the import metadata file. This will be the same value as + // the [google.datastore.admin.v1beta1.ExportEntitiesResponse.output_url][google.datastore.admin.v1beta1.ExportEntitiesResponse.output_url] + // field. + InputUrl string `protobuf:"bytes,5,opt,name=input_url,json=inputUrl" json:"input_url,omitempty"` +} + +func (m *ImportEntitiesMetadata) Reset() { *m = ImportEntitiesMetadata{} } +func (m *ImportEntitiesMetadata) String() string { return proto.CompactTextString(m) } +func (*ImportEntitiesMetadata) ProtoMessage() {} +func (*ImportEntitiesMetadata) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } + +func (m *ImportEntitiesMetadata) GetCommon() *CommonMetadata { + if m != nil { + return m.Common + } + return nil +} + +func (m *ImportEntitiesMetadata) GetProgressEntities() *Progress { + if m != nil { + return m.ProgressEntities + } + return nil +} + +func (m *ImportEntitiesMetadata) GetProgressBytes() *Progress { + if m != nil { + return m.ProgressBytes + } + return nil +} + +func (m *ImportEntitiesMetadata) GetEntityFilter() *EntityFilter { + if m != nil { + return m.EntityFilter + } + return nil +} + +func (m *ImportEntitiesMetadata) GetInputUrl() string { + if m != nil { + return m.InputUrl + } + return "" +} + +// Identifies a subset of entities in a project. This is specified as +// combinations of kind + namespace (either or both of which may be all, as +// described in the following examples). +// Example usage: +// +// Entire project: +// kinds=[], namespace_ids=[] +// +// Kinds Foo and Bar in all namespaces: +// kinds=['Foo', 'Bar'], namespace_ids=[] +// +// Kinds Foo and Bar only in the default namespace: +// kinds=['Foo', 'Bar'], namespace_ids=[''] +// +// Kinds Foo and Bar in both the default and Baz namespaces: +// kinds=['Foo', 'Bar'], namespace_ids=['', 'Baz'] +// +// The entire Baz namespace: +// kinds=[], namespace_ids=['Baz'] +type EntityFilter struct { + // If empty, then this represents all kinds. + Kinds []string `protobuf:"bytes,1,rep,name=kinds" json:"kinds,omitempty"` + // An empty list represents all namespaces. This is the preferred + // usage for projects that don't use namespaces. + // + // An empty string element represents the default namespace. This should be + // used if the project has data in non-default namespaces, but doesn't want to + // include them. + // Each namespace in this list must be unique. + NamespaceIds []string `protobuf:"bytes,2,rep,name=namespace_ids,json=namespaceIds" json:"namespace_ids,omitempty"` +} + +func (m *EntityFilter) Reset() { *m = EntityFilter{} } +func (m *EntityFilter) String() string { return proto.CompactTextString(m) } +func (*EntityFilter) ProtoMessage() {} +func (*EntityFilter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } + +func (m *EntityFilter) GetKinds() []string { + if m != nil { + return m.Kinds + } + return nil +} + +func (m *EntityFilter) GetNamespaceIds() []string { + if m != nil { + return m.NamespaceIds + } + return nil +} + +func init() { + proto.RegisterType((*CommonMetadata)(nil), "google.datastore.admin.v1beta1.CommonMetadata") + proto.RegisterType((*Progress)(nil), "google.datastore.admin.v1beta1.Progress") + proto.RegisterType((*ExportEntitiesRequest)(nil), "google.datastore.admin.v1beta1.ExportEntitiesRequest") + proto.RegisterType((*ImportEntitiesRequest)(nil), "google.datastore.admin.v1beta1.ImportEntitiesRequest") + proto.RegisterType((*ExportEntitiesResponse)(nil), "google.datastore.admin.v1beta1.ExportEntitiesResponse") + proto.RegisterType((*ExportEntitiesMetadata)(nil), "google.datastore.admin.v1beta1.ExportEntitiesMetadata") + proto.RegisterType((*ImportEntitiesMetadata)(nil), "google.datastore.admin.v1beta1.ImportEntitiesMetadata") + proto.RegisterType((*EntityFilter)(nil), "google.datastore.admin.v1beta1.EntityFilter") + proto.RegisterEnum("google.datastore.admin.v1beta1.OperationType", OperationType_name, OperationType_value) + proto.RegisterEnum("google.datastore.admin.v1beta1.CommonMetadata_State", CommonMetadata_State_name, CommonMetadata_State_value) +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// Client API for DatastoreAdmin service + +type DatastoreAdminClient interface { + // Exports a copy of all or a subset of entities from Google Cloud Datastore + // to another storage system, such as Google Cloud Storage. Recent updates to + // entities may not be reflected in the export. The export occurs in the + // background and its progress can be monitored and managed via the + // Operation resource that is created. The output of an export may only be + // used once the associated operation is done. If an export operation is + // cancelled before completion it may leave partial data behind in Google + // Cloud Storage. + ExportEntities(ctx context.Context, in *ExportEntitiesRequest, opts ...grpc.CallOption) (*google_longrunning.Operation, error) + // Imports entities into Google Cloud Datastore. Existing entities with the + // same key are overwritten. The import occurs in the background and its + // progress can be monitored and managed via the Operation resource that is + // created. If an ImportEntities operation is cancelled, it is possible + // that a subset of the data has already been imported to Cloud Datastore. + ImportEntities(ctx context.Context, in *ImportEntitiesRequest, opts ...grpc.CallOption) (*google_longrunning.Operation, error) +} + +type datastoreAdminClient struct { + cc *grpc.ClientConn +} + +func NewDatastoreAdminClient(cc *grpc.ClientConn) DatastoreAdminClient { + return &datastoreAdminClient{cc} +} + +func (c *datastoreAdminClient) ExportEntities(ctx context.Context, in *ExportEntitiesRequest, opts ...grpc.CallOption) (*google_longrunning.Operation, error) { + out := new(google_longrunning.Operation) + err := grpc.Invoke(ctx, "/google.datastore.admin.v1beta1.DatastoreAdmin/ExportEntities", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *datastoreAdminClient) ImportEntities(ctx context.Context, in *ImportEntitiesRequest, opts ...grpc.CallOption) (*google_longrunning.Operation, error) { + out := new(google_longrunning.Operation) + err := grpc.Invoke(ctx, "/google.datastore.admin.v1beta1.DatastoreAdmin/ImportEntities", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// Server API for DatastoreAdmin service + +type DatastoreAdminServer interface { + // Exports a copy of all or a subset of entities from Google Cloud Datastore + // to another storage system, such as Google Cloud Storage. Recent updates to + // entities may not be reflected in the export. The export occurs in the + // background and its progress can be monitored and managed via the + // Operation resource that is created. The output of an export may only be + // used once the associated operation is done. If an export operation is + // cancelled before completion it may leave partial data behind in Google + // Cloud Storage. + ExportEntities(context.Context, *ExportEntitiesRequest) (*google_longrunning.Operation, error) + // Imports entities into Google Cloud Datastore. Existing entities with the + // same key are overwritten. The import occurs in the background and its + // progress can be monitored and managed via the Operation resource that is + // created. If an ImportEntities operation is cancelled, it is possible + // that a subset of the data has already been imported to Cloud Datastore. + ImportEntities(context.Context, *ImportEntitiesRequest) (*google_longrunning.Operation, error) +} + +func RegisterDatastoreAdminServer(s *grpc.Server, srv DatastoreAdminServer) { + s.RegisterService(&_DatastoreAdmin_serviceDesc, srv) +} + +func _DatastoreAdmin_ExportEntities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ExportEntitiesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DatastoreAdminServer).ExportEntities(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.datastore.admin.v1beta1.DatastoreAdmin/ExportEntities", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DatastoreAdminServer).ExportEntities(ctx, req.(*ExportEntitiesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _DatastoreAdmin_ImportEntities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ImportEntitiesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DatastoreAdminServer).ImportEntities(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.datastore.admin.v1beta1.DatastoreAdmin/ImportEntities", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DatastoreAdminServer).ImportEntities(ctx, req.(*ImportEntitiesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _DatastoreAdmin_serviceDesc = grpc.ServiceDesc{ + ServiceName: "google.datastore.admin.v1beta1.DatastoreAdmin", + HandlerType: (*DatastoreAdminServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "ExportEntities", + Handler: _DatastoreAdmin_ExportEntities_Handler, + }, + { + MethodName: "ImportEntities", + Handler: _DatastoreAdmin_ImportEntities_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "google/datastore/admin/v1beta1/datastore_admin.proto", +} + +func init() { + proto.RegisterFile("google/datastore/admin/v1beta1/datastore_admin.proto", fileDescriptor0) +} + +var fileDescriptor0 = []byte{ + // 996 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x56, 0x41, 0x8f, 0xdb, 0x44, + 0x14, 0xc6, 0xce, 0x26, 0x6d, 0xde, 0x6e, 0xd2, 0xec, 0x94, 0xad, 0xa2, 0x40, 0xcb, 0xca, 0xa5, + 0xd2, 0x6a, 0x05, 0x0e, 0x1b, 0x5a, 0x41, 0x97, 0x53, 0x36, 0xeb, 0x54, 0x46, 0x69, 0x12, 0x1c, + 0x07, 0x75, 0x7b, 0xb1, 0x9c, 0x78, 0x36, 0x32, 0x6b, 0x7b, 0x8c, 0x3d, 0x29, 0x8d, 0x10, 0x17, + 0x2e, 0x1c, 0x38, 0x72, 0xe1, 0x1f, 0x20, 0xf1, 0x1b, 0xb8, 0x70, 0xe1, 0xc2, 0x91, 0xbf, 0xc0, + 0x8f, 0xe0, 0x88, 0x66, 0x3c, 0x76, 0xe2, 0x25, 0x10, 0xca, 0x16, 0x4e, 0xdc, 0xfc, 0xde, 0xbc, + 0xef, 0x9b, 0x37, 0xdf, 0x9b, 0xf7, 0x3c, 0x70, 0x7f, 0x46, 0xc8, 0xcc, 0xc3, 0x4d, 0xc7, 0xa6, + 0x76, 0x4c, 0x49, 0x84, 0x9b, 0xb6, 0xe3, 0xbb, 0x41, 0xf3, 0xd9, 0xd1, 0x04, 0x53, 0xfb, 0x68, + 0xe9, 0xb7, 0xb8, 0x5f, 0x0d, 0x23, 0x42, 0x09, 0xba, 0x93, 0xa0, 0xd4, 0x6c, 0x55, 0x4d, 0x56, + 0x05, 0xaa, 0xf1, 0xba, 0x60, 0xb5, 0x43, 0xb7, 0x69, 0x07, 0x01, 0xa1, 0x36, 0x75, 0x49, 0x10, + 0x27, 0xe8, 0xc6, 0x5d, 0xb1, 0xea, 0x91, 0x60, 0x16, 0xcd, 0x83, 0xc0, 0x0d, 0x66, 0x4d, 0x12, + 0xe2, 0x28, 0x17, 0xf4, 0x86, 0x08, 0xe2, 0xd6, 0x64, 0x7e, 0xde, 0xa4, 0xae, 0x8f, 0x63, 0x6a, + 0xfb, 0x61, 0x12, 0xa0, 0xfc, 0xb8, 0x05, 0xd5, 0x0e, 0xf1, 0x7d, 0x12, 0x3c, 0xc6, 0xd4, 0x66, + 0x99, 0xa0, 0x87, 0x00, 0x31, 0xb5, 0x23, 0x6a, 0xb1, 0xd8, 0xba, 0xb4, 0x2f, 0x1d, 0x6c, 0xb7, + 0x1a, 0xaa, 0xc8, 0x35, 0x25, 0x52, 0xcd, 0x94, 0xc8, 0x28, 0xf3, 0x68, 0x66, 0xa3, 0x07, 0x70, + 0x1d, 0x07, 0x4e, 0x02, 0x94, 0x37, 0x02, 0xaf, 0xe1, 0xc0, 0xe1, 0x30, 0x13, 0xaa, 0x59, 0xe6, + 0x16, 0x5d, 0x84, 0xb8, 0x5e, 0xd8, 0x97, 0x0e, 0xaa, 0xad, 0xb7, 0xd5, 0xbf, 0x56, 0x48, 0x1d, + 0xa4, 0x28, 0x73, 0x11, 0x62, 0xa3, 0x42, 0x56, 0x4d, 0x64, 0x40, 0xc9, 0xb3, 0x27, 0xd8, 0x8b, + 0xeb, 0x5b, 0xfb, 0x85, 0x83, 0xed, 0xd6, 0xf1, 0x26, 0xb6, 0xbc, 0x0e, 0x6a, 0x8f, 0x83, 0xb5, + 0x80, 0x46, 0x0b, 0x43, 0x30, 0xa1, 0x0f, 0xa1, 0x18, 0x53, 0x9b, 0xe2, 0x7a, 0x91, 0x27, 0x78, + 0xff, 0x05, 0x29, 0x47, 0x0c, 0x6b, 0x24, 0x14, 0x8d, 0x87, 0xb0, 0xbd, 0xb2, 0x05, 0xaa, 0x41, + 0xe1, 0x02, 0x2f, 0xb8, 0xde, 0x65, 0x83, 0x7d, 0xa2, 0x57, 0xa1, 0xf8, 0xcc, 0xf6, 0xe6, 0x89, + 0x94, 0x65, 0x23, 0x31, 0x8e, 0xe5, 0xf7, 0x25, 0xe5, 0x6b, 0x09, 0x8a, 0x9c, 0x0b, 0xed, 0xc1, + 0xee, 0xc8, 0x6c, 0x9b, 0x9a, 0x35, 0xee, 0x8f, 0x86, 0x5a, 0x47, 0xef, 0xea, 0xda, 0x69, 0xed, + 0x15, 0x54, 0x83, 0x1d, 0xbd, 0xaf, 0x9b, 0x7a, 0xbb, 0xa7, 0x3f, 0xd5, 0xfb, 0x8f, 0x6a, 0x12, + 0xaa, 0x02, 0x0c, 0x8d, 0x41, 0x47, 0x1b, 0x8d, 0x98, 0x2d, 0x33, 0xbb, 0xd3, 0xee, 0x77, 0xb4, + 0x5e, 0x8f, 0xd9, 0x05, 0x66, 0x77, 0xf5, 0x7e, 0x1a, 0xbf, 0xc5, 0xec, 0xd1, 0xb8, 0xc3, 0xe2, + 0xbb, 0xe3, 0x5e, 0xad, 0x88, 0x00, 0x4a, 0xdd, 0xb6, 0xde, 0xd3, 0x4e, 0x6b, 0x25, 0x54, 0x81, + 0xb2, 0xc0, 0x6a, 0xa7, 0xb5, 0x6b, 0xca, 0x13, 0xb8, 0x3e, 0x8c, 0xc8, 0x2c, 0xc2, 0x71, 0x8c, + 0xee, 0x41, 0xf5, 0x33, 0x12, 0x5d, 0x58, 0x53, 0xe2, 0x87, 0x1e, 0xa6, 0xd8, 0xe1, 0x07, 0x2a, + 0x18, 0x15, 0xe6, 0xed, 0xa4, 0xce, 0x2c, 0x0c, 0xc7, 0xd4, 0xf5, 0x6d, 0x16, 0x26, 0x2f, 0xc3, + 0xb4, 0xd4, 0xa9, 0xfc, 0x2c, 0xc3, 0x9e, 0xf6, 0x3c, 0x24, 0x11, 0xd5, 0x02, 0xea, 0x52, 0x17, + 0xc7, 0x06, 0xfe, 0x74, 0x8e, 0x63, 0x8a, 0x6e, 0x03, 0x84, 0x11, 0xf9, 0x04, 0x4f, 0xa9, 0xe5, + 0x3a, 0x42, 0xb4, 0xb2, 0xf0, 0xe8, 0x0e, 0x3a, 0xcb, 0x6a, 0x2f, 0xf3, 0xda, 0xb7, 0x37, 0x15, + 0x6a, 0xed, 0x2e, 0x6b, 0xaf, 0xc0, 0x47, 0x50, 0xc1, 0x2c, 0x6c, 0x61, 0x9d, 0xbb, 0x1e, 0xc5, + 0x11, 0xbf, 0xab, 0xdb, 0xad, 0xb7, 0x36, 0xee, 0xc0, 0x41, 0x5d, 0x8e, 0x31, 0x76, 0xf0, 0x8a, + 0x85, 0x0e, 0x61, 0x97, 0xcc, 0x69, 0x38, 0xa7, 0xd6, 0x3c, 0xf2, 0xac, 0x30, 0xc2, 0xe7, 0xee, + 0xf3, 0xfa, 0x16, 0x3f, 0xd3, 0x8d, 0x64, 0x61, 0x1c, 0x79, 0x43, 0xee, 0xbe, 0xca, 0xad, 0xf9, + 0x41, 0x86, 0x3d, 0xdd, 0xff, 0x2f, 0xd4, 0x5c, 0xbb, 0xcb, 0x5a, 0x35, 0x5f, 0x83, 0xb2, 0x1b, + 0x88, 0x93, 0x73, 0x25, 0xcb, 0xc6, 0x75, 0xee, 0x18, 0x47, 0xde, 0x1f, 0xa5, 0xde, 0xba, 0xaa, + 0xd4, 0x57, 0x91, 0xef, 0x3d, 0xb8, 0x75, 0xf9, 0x96, 0xc4, 0x21, 0x09, 0x62, 0xcc, 0xe4, 0x5b, + 0xd6, 0x2f, 0x95, 0x2f, 0x2b, 0x9c, 0xf2, 0x55, 0xe1, 0x32, 0x32, 0x9b, 0xb5, 0x5d, 0x28, 0x4d, + 0xf9, 0x88, 0x10, 0x73, 0x56, 0x7d, 0xb1, 0x81, 0x62, 0x08, 0x34, 0x1a, 0xc3, 0x6e, 0x28, 0x5a, + 0xd0, 0xc2, 0x62, 0x13, 0x31, 0x81, 0x0f, 0x36, 0x51, 0xa6, 0xbd, 0x6b, 0xd4, 0x52, 0x8a, 0x34, + 0x4d, 0x34, 0x80, 0x6a, 0x46, 0x3b, 0x59, 0x50, 0x1c, 0x8b, 0xcb, 0xfe, 0xf7, 0x39, 0x2b, 0x29, + 0xfe, 0x84, 0xc1, 0xff, 0x85, 0x8a, 0xae, 0x6f, 0x9e, 0xe2, 0xda, 0xe6, 0x51, 0x7e, 0x93, 0xe1, + 0x56, 0xfe, 0x6e, 0xfe, 0x5f, 0x89, 0x97, 0x57, 0x89, 0x5c, 0x2f, 0x17, 0xf3, 0xbd, 0xac, 0xe8, + 0xb0, 0xb3, 0x0a, 0x65, 0x7d, 0x76, 0xe1, 0x06, 0x4e, 0x5c, 0x97, 0xf6, 0x0b, 0xac, 0xcf, 0xb8, + 0x81, 0xee, 0x42, 0x25, 0xb0, 0x7d, 0x1c, 0x87, 0xf6, 0x14, 0x5b, 0xae, 0x93, 0x0c, 0x9c, 0xb2, + 0xb1, 0x93, 0x39, 0x75, 0x27, 0x3e, 0x3c, 0x83, 0x4a, 0xee, 0xc7, 0x8f, 0xee, 0x40, 0x63, 0x30, + 0xd4, 0x8c, 0xb6, 0xa9, 0x0f, 0xfa, 0x96, 0x79, 0x36, 0xbc, 0xfc, 0x37, 0xbc, 0x09, 0x37, 0xb4, + 0x27, 0xc3, 0x81, 0x61, 0x5a, 0x5a, 0xdf, 0xd4, 0x4d, 0x5d, 0x1b, 0xd5, 0x24, 0xe6, 0xd4, 0x1f, + 0xe7, 0x9d, 0x72, 0xeb, 0x27, 0x19, 0xaa, 0xa7, 0xe9, 0xc9, 0xdb, 0xec, 0xe0, 0xe8, 0x5b, 0x09, + 0xaa, 0xf9, 0xee, 0x45, 0x0f, 0xfe, 0xd1, 0xdf, 0xa4, 0x71, 0x3b, 0x85, 0xad, 0x3c, 0xd9, 0x96, + 0x4f, 0x18, 0xe5, 0x9d, 0x2f, 0x7f, 0xf9, 0xf5, 0x1b, 0xf9, 0x50, 0xb9, 0x97, 0x3d, 0x1b, 0xc5, + 0x04, 0x8e, 0x9b, 0x9f, 0x2f, 0xa7, 0xf3, 0x17, 0xc7, 0x98, 0x93, 0x1f, 0x4b, 0x87, 0x3c, 0xb5, + 0xfc, 0x75, 0xde, 0x9c, 0xda, 0xda, 0xd1, 0xfc, 0xb2, 0x52, 0x73, 0x7d, 0x91, 0xda, 0xc9, 0x77, + 0x12, 0x28, 0x53, 0xe2, 0x6f, 0xc8, 0xe6, 0xe4, 0x66, 0x5e, 0xec, 0x21, 0x7b, 0x24, 0x0e, 0xa5, + 0xa7, 0x1d, 0x01, 0x9b, 0x11, 0xcf, 0x0e, 0x66, 0x2a, 0x89, 0x66, 0xcd, 0x19, 0x0e, 0xf8, 0x13, + 0xb2, 0x99, 0x2c, 0xd9, 0xa1, 0x1b, 0xff, 0xd9, 0x73, 0xfb, 0x03, 0x6e, 0x7d, 0x2f, 0xbf, 0xf9, + 0x28, 0x61, 0xe9, 0x78, 0x64, 0xee, 0xa8, 0xd9, 0x4e, 0x2a, 0xdf, 0x4a, 0xfd, 0xf8, 0xe8, 0x84, + 0x05, 0x4f, 0x4a, 0x9c, 0xf6, 0xdd, 0xdf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x77, 0x71, 0x2d, 0x88, + 0xc4, 0x0b, 0x00, 0x00, +} diff --git a/vendor/google.golang.org/genproto/googleapis/datastore/v1/datastore.pb.go b/vendor/google.golang.org/genproto/googleapis/datastore/v1/datastore.pb.go index 4b82961d..1bf5667a 100644 --- a/vendor/google.golang.org/genproto/googleapis/datastore/v1/datastore.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/datastore/v1/datastore.pb.go @@ -25,6 +25,7 @@ It has these top-level messages: Mutation MutationResult ReadOptions + TransactionOptions PartitionId Key ArrayValue @@ -388,6 +389,8 @@ func (m *RunQueryResponse) GetQuery() *Query { type BeginTransactionRequest struct { // The ID of the project against which to make the request. ProjectId string `protobuf:"bytes,8,opt,name=project_id,json=projectId" json:"project_id,omitempty"` + // Options for a new transaction. + TransactionOptions *TransactionOptions `protobuf:"bytes,10,opt,name=transaction_options,json=transactionOptions" json:"transaction_options,omitempty"` } func (m *BeginTransactionRequest) Reset() { *m = BeginTransactionRequest{} } @@ -402,6 +405,13 @@ func (m *BeginTransactionRequest) GetProjectId() string { return "" } +func (m *BeginTransactionRequest) GetTransactionOptions() *TransactionOptions { + if m != nil { + return m.TransactionOptions + } + return nil +} + // The response for [Datastore.BeginTransaction][google.datastore.v1.Datastore.BeginTransaction]. type BeginTransactionResponse struct { // The transaction identifier (always present). @@ -1067,6 +1077,160 @@ func _ReadOptions_OneofSizer(msg proto.Message) (n int) { return n } +// Options for beginning a new transaction. +type TransactionOptions struct { + // The `mode` of the transaction, indicating whether write operations are + // supported. + // + // Types that are valid to be assigned to Mode: + // *TransactionOptions_ReadWrite_ + // *TransactionOptions_ReadOnly_ + Mode isTransactionOptions_Mode `protobuf_oneof:"mode"` +} + +func (m *TransactionOptions) Reset() { *m = TransactionOptions{} } +func (m *TransactionOptions) String() string { return proto.CompactTextString(m) } +func (*TransactionOptions) ProtoMessage() {} +func (*TransactionOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } + +type isTransactionOptions_Mode interface { + isTransactionOptions_Mode() +} + +type TransactionOptions_ReadWrite_ struct { + ReadWrite *TransactionOptions_ReadWrite `protobuf:"bytes,1,opt,name=read_write,json=readWrite,oneof"` +} +type TransactionOptions_ReadOnly_ struct { + ReadOnly *TransactionOptions_ReadOnly `protobuf:"bytes,2,opt,name=read_only,json=readOnly,oneof"` +} + +func (*TransactionOptions_ReadWrite_) isTransactionOptions_Mode() {} +func (*TransactionOptions_ReadOnly_) isTransactionOptions_Mode() {} + +func (m *TransactionOptions) GetMode() isTransactionOptions_Mode { + if m != nil { + return m.Mode + } + return nil +} + +func (m *TransactionOptions) GetReadWrite() *TransactionOptions_ReadWrite { + if x, ok := m.GetMode().(*TransactionOptions_ReadWrite_); ok { + return x.ReadWrite + } + return nil +} + +func (m *TransactionOptions) GetReadOnly() *TransactionOptions_ReadOnly { + if x, ok := m.GetMode().(*TransactionOptions_ReadOnly_); ok { + return x.ReadOnly + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*TransactionOptions) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _TransactionOptions_OneofMarshaler, _TransactionOptions_OneofUnmarshaler, _TransactionOptions_OneofSizer, []interface{}{ + (*TransactionOptions_ReadWrite_)(nil), + (*TransactionOptions_ReadOnly_)(nil), + } +} + +func _TransactionOptions_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*TransactionOptions) + // mode + switch x := m.Mode.(type) { + case *TransactionOptions_ReadWrite_: + b.EncodeVarint(1<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.ReadWrite); err != nil { + return err + } + case *TransactionOptions_ReadOnly_: + b.EncodeVarint(2<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.ReadOnly); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("TransactionOptions.Mode has unexpected type %T", x) + } + return nil +} + +func _TransactionOptions_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*TransactionOptions) + switch tag { + case 1: // mode.read_write + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(TransactionOptions_ReadWrite) + err := b.DecodeMessage(msg) + m.Mode = &TransactionOptions_ReadWrite_{msg} + return true, err + case 2: // mode.read_only + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(TransactionOptions_ReadOnly) + err := b.DecodeMessage(msg) + m.Mode = &TransactionOptions_ReadOnly_{msg} + return true, err + default: + return false, nil + } +} + +func _TransactionOptions_OneofSizer(msg proto.Message) (n int) { + m := msg.(*TransactionOptions) + // mode + switch x := m.Mode.(type) { + case *TransactionOptions_ReadWrite_: + s := proto.Size(x.ReadWrite) + n += proto.SizeVarint(1<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case *TransactionOptions_ReadOnly_: + s := proto.Size(x.ReadOnly) + n += proto.SizeVarint(2<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +// Options specific to read / write transactions. +type TransactionOptions_ReadWrite struct { + // The transaction identifier of the transaction being retried. + PreviousTransaction []byte `protobuf:"bytes,1,opt,name=previous_transaction,json=previousTransaction,proto3" json:"previous_transaction,omitempty"` +} + +func (m *TransactionOptions_ReadWrite) Reset() { *m = TransactionOptions_ReadWrite{} } +func (m *TransactionOptions_ReadWrite) String() string { return proto.CompactTextString(m) } +func (*TransactionOptions_ReadWrite) ProtoMessage() {} +func (*TransactionOptions_ReadWrite) Descriptor() ([]byte, []int) { + return fileDescriptor0, []int{15, 0} +} + +func (m *TransactionOptions_ReadWrite) GetPreviousTransaction() []byte { + if m != nil { + return m.PreviousTransaction + } + return nil +} + +// Options specific to read-only transactions. +type TransactionOptions_ReadOnly struct { +} + +func (m *TransactionOptions_ReadOnly) Reset() { *m = TransactionOptions_ReadOnly{} } +func (m *TransactionOptions_ReadOnly) String() string { return proto.CompactTextString(m) } +func (*TransactionOptions_ReadOnly) ProtoMessage() {} +func (*TransactionOptions_ReadOnly) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15, 1} } + func init() { proto.RegisterType((*LookupRequest)(nil), "google.datastore.v1.LookupRequest") proto.RegisterType((*LookupResponse)(nil), "google.datastore.v1.LookupResponse") @@ -1083,6 +1247,9 @@ func init() { proto.RegisterType((*Mutation)(nil), "google.datastore.v1.Mutation") proto.RegisterType((*MutationResult)(nil), "google.datastore.v1.MutationResult") proto.RegisterType((*ReadOptions)(nil), "google.datastore.v1.ReadOptions") + proto.RegisterType((*TransactionOptions)(nil), "google.datastore.v1.TransactionOptions") + proto.RegisterType((*TransactionOptions_ReadWrite)(nil), "google.datastore.v1.TransactionOptions.ReadWrite") + proto.RegisterType((*TransactionOptions_ReadOnly)(nil), "google.datastore.v1.TransactionOptions.ReadOnly") proto.RegisterEnum("google.datastore.v1.CommitRequest_Mode", CommitRequest_Mode_name, CommitRequest_Mode_value) proto.RegisterEnum("google.datastore.v1.ReadOptions_ReadConsistency", ReadOptions_ReadConsistency_name, ReadOptions_ReadConsistency_value) } @@ -1343,81 +1510,87 @@ var _Datastore_serviceDesc = grpc.ServiceDesc{ func init() { proto.RegisterFile("google/datastore/v1/datastore.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ - // 1205 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x41, 0x6f, 0xe3, 0x44, - 0x14, 0xae, 0x93, 0x36, 0x9b, 0xbc, 0xa4, 0x69, 0x3a, 0xbb, 0xb0, 0x26, 0xbb, 0x15, 0xc1, 0xa5, - 0xda, 0xa8, 0xbb, 0x9b, 0xb4, 0x81, 0x15, 0xa8, 0xed, 0xa5, 0x49, 0xb3, 0x6d, 0xc4, 0x36, 0x29, - 0xd3, 0xb4, 0x12, 0x48, 0xc8, 0x72, 0xed, 0x69, 0x30, 0x75, 0x3c, 0xae, 0x3d, 0xa9, 0x88, 0x10, - 0x2b, 0x01, 0x5a, 0x7e, 0x00, 0xfc, 0x02, 0x2e, 0x1c, 0x10, 0x47, 0x4e, 0x88, 0x7f, 0xc1, 0x91, - 0x2b, 0xff, 0x80, 0x3f, 0x80, 0x3c, 0x1e, 0x37, 0x75, 0xd6, 0x69, 0x82, 0xc4, 0x2d, 0xf3, 0xf2, - 0x7d, 0x6f, 0xbe, 0xf7, 0xde, 0xcc, 0x7b, 0x63, 0x58, 0xed, 0x51, 0xda, 0xb3, 0x48, 0xd5, 0xd0, - 0x98, 0xe6, 0x31, 0xea, 0x92, 0xea, 0xd5, 0xe6, 0x68, 0x51, 0x71, 0x5c, 0xca, 0x28, 0xba, 0x1b, - 0x80, 0x2a, 0x23, 0xfb, 0xd5, 0x66, 0xf1, 0xa1, 0x60, 0x6a, 0x8e, 0x59, 0xd5, 0x6c, 0x9b, 0x32, - 0x8d, 0x99, 0xd4, 0xf6, 0x02, 0x4a, 0xb1, 0x14, 0xe7, 0x97, 0xd8, 0xcc, 0x64, 0x43, 0x81, 0x78, - 0x3b, 0x0e, 0x71, 0x39, 0x20, 0xae, 0x00, 0x28, 0x3f, 0x49, 0xb0, 0xf8, 0x82, 0xd2, 0x8b, 0x81, - 0x83, 0xc9, 0xe5, 0x80, 0x78, 0x0c, 0xad, 0x00, 0x38, 0x2e, 0xfd, 0x82, 0xe8, 0x4c, 0x35, 0x0d, - 0x39, 0x5d, 0x92, 0xca, 0x19, 0x9c, 0x11, 0x96, 0x96, 0x81, 0x1a, 0x90, 0x73, 0x89, 0x66, 0xa8, - 0xd4, 0xe1, 0x4a, 0x64, 0xa9, 0x24, 0x95, 0xb3, 0xb5, 0x52, 0x25, 0x46, 0x7d, 0x05, 0x13, 0xcd, - 0xe8, 0x04, 0x38, 0x9c, 0x75, 0x47, 0x0b, 0xf4, 0x04, 0xe6, 0x2f, 0xc8, 0xd0, 0x93, 0x93, 0xa5, - 0x64, 0x39, 0x5b, 0x93, 0x63, 0xc9, 0x1f, 0x91, 0x21, 0xe6, 0x28, 0xe5, 0x0f, 0x09, 0xf2, 0xa1, - 0x46, 0xcf, 0xa1, 0xb6, 0x47, 0xd0, 0x07, 0xb0, 0x70, 0x4e, 0x07, 0xb6, 0x21, 0x4b, 0xdc, 0xc3, - 0x3b, 0xb1, 0x1e, 0x9a, 0x3c, 0x13, 0x98, 0x78, 0x03, 0x8b, 0xe1, 0x00, 0x8f, 0xb6, 0xe1, 0x4e, - 0xdf, 0xf4, 0x3c, 0xd3, 0xee, 0xc9, 0x89, 0x59, 0xa9, 0x21, 0x03, 0xbd, 0x0f, 0x69, 0x83, 0x9c, - 0x13, 0xd7, 0x25, 0xc6, 0x54, 0xe9, 0xd7, 0x48, 0xe5, 0xf7, 0x04, 0x2c, 0xe1, 0x81, 0xfd, 0xb1, - 0x9f, 0xf5, 0xd9, 0x93, 0xec, 0x68, 0x2e, 0x33, 0xfd, 0x6c, 0xf9, 0x80, 0xc4, 0x2d, 0x49, 0x3e, - 0x0a, 0x81, 0x2d, 0x03, 0x67, 0x9d, 0xd1, 0xe2, 0xff, 0xa9, 0x54, 0x0d, 0x16, 0xf8, 0x71, 0x91, - 0x93, 0x9c, 0x5d, 0x8c, 0x65, 0xf3, 0xd0, 0x0e, 0xe6, 0x70, 0x00, 0x45, 0x3b, 0x90, 0xe9, 0x5d, - 0x5a, 0x6a, 0xc0, 0xbb, 0xc3, 0x79, 0x2b, 0xb1, 0xbc, 0xfd, 0x4b, 0x2b, 0xa4, 0xa6, 0x7b, 0xe2, - 0x77, 0x3d, 0x07, 0xc0, 0x99, 0x2a, 0x1b, 0x3a, 0x44, 0xf9, 0x46, 0x82, 0xc2, 0x28, 0x79, 0xa2, - 0xfa, 0xdb, 0xb0, 0x70, 0xa6, 0x31, 0xfd, 0x73, 0x11, 0xd2, 0xda, 0x64, 0x51, 0x41, 0x05, 0xeb, - 0x3e, 0x18, 0x07, 0x1c, 0xb4, 0x11, 0x46, 0x94, 0x98, 0x16, 0x91, 0x88, 0x47, 0xf9, 0x10, 0xee, - 0xd7, 0x49, 0xcf, 0xb4, 0xbb, 0xae, 0x66, 0x7b, 0x9a, 0xee, 0x27, 0x66, 0xb6, 0x3a, 0x2a, 0x3b, - 0x20, 0xbf, 0xce, 0x14, 0x41, 0x94, 0x20, 0xcb, 0x46, 0x66, 0x1e, 0x4a, 0x0e, 0xdf, 0x34, 0x29, - 0x18, 0x96, 0x30, 0xb5, 0xac, 0x33, 0x4d, 0xbf, 0x98, 0xf1, 0xdc, 0x4c, 0xf7, 0x89, 0xa0, 0x30, - 0xf2, 0x19, 0x28, 0x51, 0x7e, 0x4d, 0xc0, 0x62, 0x83, 0xf6, 0xfb, 0x26, 0x9b, 0x71, 0x9b, 0x6d, - 0x98, 0xef, 0x53, 0x83, 0xc8, 0x0b, 0x25, 0xa9, 0x9c, 0xaf, 0x3d, 0x8a, 0xcd, 0x60, 0xc4, 0x61, - 0xe5, 0x90, 0x1a, 0x04, 0x73, 0x12, 0x52, 0x62, 0x34, 0x1e, 0xcc, 0x45, 0x54, 0xa2, 0x6d, 0xc8, - 0xf4, 0x07, 0xa2, 0xd7, 0xc9, 0x29, 0x7e, 0xd3, 0xe2, 0x4f, 0xd0, 0xa1, 0x40, 0xe1, 0x11, 0x5e, - 0x79, 0x0e, 0xf3, 0xfe, 0x76, 0xe8, 0x1e, 0x14, 0x0e, 0x3b, 0x7b, 0x4d, 0xf5, 0xa4, 0x7d, 0x7c, - 0xd4, 0x6c, 0xb4, 0x9e, 0xb7, 0x9a, 0x7b, 0x85, 0x39, 0xb4, 0x0c, 0x8b, 0x5d, 0xbc, 0xdb, 0x3e, - 0xde, 0x6d, 0x74, 0x5b, 0x9d, 0xf6, 0xee, 0x8b, 0x82, 0x84, 0xde, 0x80, 0xe5, 0x76, 0xa7, 0xad, - 0x46, 0xcd, 0x89, 0xfa, 0x9b, 0x70, 0xef, 0x86, 0x26, 0xd5, 0x23, 0x16, 0xd1, 0x19, 0x75, 0x95, - 0x57, 0x12, 0xe4, 0xc3, 0xe8, 0x44, 0x2d, 0xdb, 0x50, 0x08, 0xf7, 0x57, 0x5d, 0x7e, 0xe4, 0xc2, - 0xde, 0xb6, 0x7a, 0xbb, 0xec, 0xa0, 0xc1, 0x2c, 0xf5, 0x23, 0x6b, 0x0f, 0xad, 0xc2, 0xa2, 0x69, - 0x1b, 0xe4, 0x4b, 0x75, 0xe0, 0x18, 0x1a, 0x23, 0x9e, 0x3c, 0x5f, 0x92, 0xca, 0x0b, 0x38, 0xc7, - 0x8d, 0x27, 0x81, 0x4d, 0xd1, 0x00, 0xed, 0x5a, 0x16, 0xd5, 0x35, 0x46, 0x5a, 0x86, 0x37, 0x63, - 0xe9, 0xc2, 0xce, 0x2b, 0xcd, 0xd4, 0x79, 0x1b, 0x70, 0x37, 0xb2, 0x85, 0x08, 0xf7, 0xbf, 0x39, - 0xf9, 0x2d, 0x01, 0xe9, 0x30, 0x60, 0xf4, 0x0c, 0x52, 0xa6, 0xed, 0x11, 0x97, 0xf1, 0x90, 0xb2, - 0xb5, 0x07, 0xb7, 0xb4, 0xdf, 0x83, 0x39, 0x2c, 0xc0, 0x3e, 0x2d, 0x48, 0x05, 0x3f, 0x73, 0xd3, - 0x69, 0x01, 0x38, 0xa0, 0xf1, 0xdd, 0x52, 0x33, 0xd2, 0xf8, 0x6e, 0x35, 0x48, 0x19, 0xc4, 0x22, - 0x8c, 0x88, 0xee, 0x35, 0x31, 0x42, 0x9f, 0x13, 0x20, 0xd1, 0x2a, 0xe4, 0xce, 0x34, 0x8f, 0xa8, - 0x57, 0xc4, 0xf5, 0xfc, 0x73, 0xed, 0x67, 0x3e, 0x79, 0x20, 0xe1, 0xac, 0x6f, 0x3d, 0x0d, 0x8c, - 0xf5, 0x2c, 0x64, 0xa8, 0x43, 0x5c, 0x9e, 0x8a, 0xfa, 0x0a, 0x3c, 0xd0, 0xa9, 0x7d, 0x6e, 0x99, - 0x3a, 0x53, 0x0d, 0xc2, 0x88, 0x38, 0x66, 0xcc, 0xd5, 0x18, 0xe9, 0x0d, 0x95, 0xef, 0x24, 0xc8, - 0x47, 0xcf, 0x09, 0x5a, 0x87, 0xe4, 0x05, 0x09, 0x5b, 0xf1, 0xe4, 0xb4, 0xfb, 0x20, 0x24, 0xc3, - 0x9d, 0x50, 0x8a, 0x9f, 0xe9, 0x24, 0x0e, 0x97, 0xe8, 0x31, 0x2c, 0x8f, 0xed, 0x4b, 0x0c, 0x9e, - 0xd6, 0x34, 0x2e, 0x84, 0x7f, 0xec, 0x09, 0xbb, 0xf2, 0x8f, 0x04, 0xd9, 0x1b, 0xc3, 0x01, 0x7d, - 0x06, 0x05, 0x3e, 0x54, 0x74, 0x6a, 0x7b, 0xa6, 0xc7, 0x88, 0xad, 0x0f, 0xf9, 0x15, 0xce, 0xd7, - 0x36, 0xa6, 0x0d, 0x16, 0xfe, 0xbb, 0x31, 0xe2, 0x1d, 0xcc, 0xe1, 0x25, 0x37, 0x6a, 0x1a, 0x6f, - 0x0e, 0x89, 0x98, 0xe6, 0xa0, 0x1c, 0xc2, 0xd2, 0x98, 0x27, 0x54, 0x82, 0x87, 0xb8, 0xb9, 0xbb, - 0xa7, 0x36, 0x3a, 0xed, 0xe3, 0xd6, 0x71, 0xb7, 0xd9, 0x6e, 0x7c, 0x32, 0x76, 0xed, 0x01, 0x52, - 0xc7, 0x5d, 0xdc, 0x69, 0xef, 0x17, 0x24, 0x94, 0x83, 0x74, 0xf3, 0xb4, 0xd9, 0xee, 0x9e, 0xf0, - 0x6b, 0x8e, 0xa0, 0x70, 0x23, 0x18, 0x3e, 0x75, 0x6a, 0x7f, 0xa5, 0x20, 0xb3, 0x17, 0x86, 0x81, - 0x5e, 0x42, 0x2a, 0x78, 0x7e, 0x20, 0x25, 0x36, 0xc6, 0xc8, 0xfb, 0xa9, 0xb8, 0x7a, 0x2b, 0x46, - 0xb4, 0xdc, 0xc7, 0xdf, 0xfe, 0xf9, 0xf7, 0x8f, 0x89, 0x35, 0xa5, 0xe4, 0xbf, 0xc7, 0xc4, 0xed, - 0xf4, 0xaa, 0x5f, 0x8d, 0x6e, 0xee, 0xd7, 0x5b, 0x16, 0x67, 0x6c, 0x49, 0xeb, 0xe8, 0x7b, 0x09, - 0xd2, 0xe1, 0x0c, 0x44, 0xef, 0xc6, 0xa7, 0x39, 0xfa, 0xbe, 0x28, 0xae, 0x4d, 0x41, 0x09, 0x19, - 0x4f, 0xb9, 0x8c, 0x47, 0x8a, 0x32, 0x59, 0x86, 0x2b, 0x38, 0xbe, 0x90, 0x9f, 0x25, 0x28, 0x8c, - 0xcf, 0x33, 0xf4, 0x24, 0x76, 0xab, 0x09, 0x03, 0xb3, 0xf8, 0x74, 0x46, 0xb4, 0x10, 0xf8, 0x8c, - 0x0b, 0xac, 0x2a, 0xeb, 0x93, 0x05, 0x9e, 0x8d, 0x71, 0x7d, 0xa1, 0x2f, 0x21, 0x15, 0x74, 0xe8, - 0x09, 0x15, 0x8b, 0x0c, 0xa7, 0x09, 0x15, 0x8b, 0xb6, 0xf8, 0x59, 0x2a, 0xa6, 0x73, 0xc6, 0x75, - 0xc5, 0xc4, 0x98, 0x9d, 0x54, 0xb1, 0xe8, 0x64, 0x9f, 0x54, 0xb1, 0xf1, 0x59, 0x3d, 0x4b, 0xc5, - 0x04, 0xc7, 0x17, 0xf2, 0x83, 0x04, 0xd9, 0x1b, 0x1d, 0x1c, 0xc5, 0xcf, 0xea, 0xd7, 0xc7, 0x48, - 0xb1, 0x3c, 0x1d, 0x28, 0x14, 0x6d, 0x70, 0x45, 0xeb, 0xca, 0xda, 0x64, 0x45, 0xda, 0x88, 0xb6, - 0x25, 0xad, 0xd7, 0x5f, 0x49, 0x70, 0x5f, 0xa7, 0xfd, 0xb8, 0x1d, 0xea, 0xf9, 0xeb, 0x6b, 0x77, - 0xe4, 0x7f, 0x9f, 0x1c, 0x49, 0x9f, 0xee, 0x08, 0x58, 0x8f, 0x5a, 0x9a, 0xdd, 0xab, 0x50, 0xb7, - 0x57, 0xed, 0x11, 0x9b, 0x7f, 0xbd, 0x54, 0x83, 0xbf, 0x34, 0xc7, 0xf4, 0x22, 0x5f, 0x38, 0xdb, - 0xd7, 0x8b, 0x5f, 0x12, 0x6f, 0xed, 0x07, 0xf4, 0x86, 0x45, 0x07, 0x46, 0xe5, 0xda, 0x7b, 0xe5, - 0x74, 0xf3, 0x2c, 0xc5, 0x9d, 0xbc, 0xf7, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x6b, 0xa3, 0xc8, - 0x39, 0x9f, 0x0d, 0x00, 0x00, + // 1312 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x5f, 0x6f, 0xdb, 0x54, + 0x14, 0xef, 0x4d, 0xdb, 0x2c, 0x39, 0xe9, 0x9f, 0xec, 0x76, 0xb0, 0x90, 0x6d, 0x22, 0xb8, 0x54, + 0xab, 0xba, 0x2d, 0x69, 0x03, 0x13, 0xd2, 0x3a, 0x21, 0x35, 0x69, 0xb6, 0x46, 0xac, 0x49, 0xb9, + 0xed, 0xc6, 0x1f, 0x09, 0x45, 0xae, 0x7d, 0x1b, 0x4c, 0x1d, 0x5f, 0xd7, 0xbe, 0x29, 0x44, 0x88, + 0x49, 0x80, 0xc6, 0x1b, 0x2f, 0xe3, 0x13, 0xf0, 0xc2, 0x03, 0xe2, 0x91, 0x27, 0xc4, 0xb7, 0xe0, + 0x91, 0x57, 0xbe, 0x01, 0x5f, 0x00, 0xf9, 0xfa, 0x3a, 0x89, 0x53, 0xbb, 0xf1, 0x24, 0xde, 0x7c, + 0xaf, 0x7f, 0xbf, 0x73, 0x7e, 0xe7, 0x9c, 0xeb, 0x73, 0xae, 0x61, 0xb5, 0xcb, 0x58, 0xd7, 0xa4, + 0x15, 0x5d, 0xe5, 0xaa, 0xcb, 0x99, 0x43, 0x2b, 0xe7, 0x5b, 0xa3, 0x45, 0xd9, 0x76, 0x18, 0x67, + 0x78, 0xc5, 0x07, 0x95, 0x47, 0xfb, 0xe7, 0x5b, 0xc5, 0x9b, 0x92, 0xa9, 0xda, 0x46, 0x45, 0xb5, + 0x2c, 0xc6, 0x55, 0x6e, 0x30, 0xcb, 0xf5, 0x29, 0xc5, 0x52, 0x94, 0x5d, 0x6a, 0x71, 0x83, 0x0f, + 0x24, 0xe2, 0xcd, 0x28, 0xc4, 0x59, 0x9f, 0x3a, 0x12, 0xa0, 0xfc, 0x8c, 0x60, 0xf1, 0x09, 0x63, + 0xa7, 0x7d, 0x9b, 0xd0, 0xb3, 0x3e, 0x75, 0x39, 0xbe, 0x05, 0x60, 0x3b, 0xec, 0x0b, 0xaa, 0xf1, + 0x8e, 0xa1, 0x17, 0x32, 0x25, 0xb4, 0x9e, 0x25, 0x59, 0xb9, 0xd3, 0xd4, 0x71, 0x1d, 0x16, 0x1c, + 0xaa, 0xea, 0x1d, 0x66, 0x0b, 0x25, 0x05, 0x54, 0x42, 0xeb, 0xb9, 0x6a, 0xa9, 0x1c, 0xa1, 0xbe, + 0x4c, 0xa8, 0xaa, 0xb7, 0x7d, 0x1c, 0xc9, 0x39, 0xa3, 0x05, 0xbe, 0x0b, 0x73, 0xa7, 0x74, 0xe0, + 0x16, 0x66, 0x4b, 0xb3, 0xeb, 0xb9, 0x6a, 0x21, 0x92, 0xfc, 0x01, 0x1d, 0x10, 0x81, 0x52, 0xfe, + 0x44, 0xb0, 0x14, 0x68, 0x74, 0x6d, 0x66, 0xb9, 0x14, 0xbf, 0x07, 0xf3, 0x27, 0xac, 0x6f, 0xe9, + 0x05, 0x24, 0x2c, 0xbc, 0x15, 0x69, 0xa1, 0x21, 0x32, 0x41, 0xa8, 0xdb, 0x37, 0x39, 0xf1, 0xf1, + 0x78, 0x1b, 0xae, 0xf4, 0x0c, 0xd7, 0x35, 0xac, 0x6e, 0x21, 0x95, 0x94, 0x1a, 0x30, 0xf0, 0xbb, + 0x90, 0xd1, 0xe9, 0x09, 0x75, 0x1c, 0xaa, 0x4f, 0x95, 0x3e, 0x44, 0x2a, 0x7f, 0xa4, 0x60, 0x99, + 0xf4, 0xad, 0x0f, 0xbd, 0xac, 0x27, 0x4f, 0xb2, 0xad, 0x3a, 0xdc, 0xf0, 0xb2, 0xe5, 0x01, 0x52, + 0x97, 0x24, 0xf9, 0x20, 0x00, 0x36, 0x75, 0x92, 0xb3, 0x47, 0x8b, 0xff, 0xa7, 0x52, 0x55, 0x98, + 0x17, 0xc7, 0xa5, 0x30, 0x2b, 0xd8, 0xc5, 0x48, 0xb6, 0x08, 0x6d, 0x6f, 0x86, 0xf8, 0x50, 0xfc, + 0x10, 0xb2, 0xdd, 0x33, 0xb3, 0xe3, 0xf3, 0xae, 0x08, 0xde, 0xad, 0x48, 0xde, 0xe3, 0x33, 0x33, + 0xa0, 0x66, 0xba, 0xf2, 0xb9, 0xb6, 0x00, 0x20, 0x98, 0x1d, 0x3e, 0xb0, 0xa9, 0xf2, 0x2d, 0x82, + 0xfc, 0x28, 0x79, 0xb2, 0xfa, 0xdb, 0x30, 0x7f, 0xac, 0x72, 0xed, 0x73, 0x19, 0xd2, 0x5a, 0xbc, + 0x28, 0xbf, 0x82, 0x35, 0x0f, 0x4c, 0x7c, 0x0e, 0xde, 0x0c, 0x22, 0x4a, 0x4d, 0x8b, 0x48, 0xc6, + 0xa3, 0xbc, 0x44, 0x70, 0xbd, 0x46, 0xbb, 0x86, 0x75, 0xe4, 0xa8, 0x96, 0xab, 0x6a, 0x5e, 0x66, + 0x12, 0x16, 0xf2, 0x63, 0x58, 0xe1, 0x23, 0xd2, 0xb0, 0x14, 0x20, 0x5c, 0xdf, 0x8e, 0x74, 0x3d, + 0xe6, 0x24, 0xa8, 0x08, 0xe6, 0x17, 0xf6, 0x94, 0x87, 0x50, 0xb8, 0xa8, 0x49, 0xe6, 0xa7, 0x04, + 0xb9, 0x31, 0x86, 0xc8, 0xd2, 0x02, 0x19, 0xdf, 0x52, 0x08, 0x2c, 0x13, 0x66, 0x9a, 0xc7, 0xaa, + 0x76, 0x9a, 0x30, 0x92, 0xe9, 0x36, 0x31, 0xe4, 0x47, 0x36, 0x7d, 0x25, 0xca, 0x6f, 0x29, 0x58, + 0xac, 0xb3, 0x5e, 0xcf, 0xe0, 0x09, 0xdd, 0x6c, 0xc3, 0x5c, 0x8f, 0xe9, 0xb4, 0x30, 0x5f, 0x42, + 0xeb, 0x4b, 0x31, 0x19, 0x0a, 0x19, 0x2c, 0xef, 0x33, 0x9d, 0x12, 0x41, 0xc2, 0x4a, 0x84, 0xc6, + 0xbd, 0x99, 0x90, 0x4a, 0xbc, 0x0d, 0xd9, 0x5e, 0x5f, 0xb6, 0xd1, 0x42, 0x5a, 0x7c, 0xc4, 0xd1, + 0x87, 0x73, 0x5f, 0xa2, 0xc8, 0x08, 0xaf, 0x3c, 0x82, 0x39, 0xcf, 0x1d, 0xbe, 0x06, 0xf9, 0xfd, + 0xf6, 0x6e, 0xa3, 0xf3, 0xb4, 0x75, 0x78, 0xd0, 0xa8, 0x37, 0x1f, 0x35, 0x1b, 0xbb, 0xf9, 0x19, + 0x7c, 0x15, 0x16, 0x8f, 0xc8, 0x4e, 0xeb, 0x70, 0xa7, 0x7e, 0xd4, 0x6c, 0xb7, 0x76, 0x9e, 0xe4, + 0x11, 0x7e, 0x0d, 0xae, 0xb6, 0xda, 0xad, 0x4e, 0x78, 0x3b, 0x55, 0x7b, 0x1d, 0xae, 0x8d, 0x1f, + 0x0b, 0x97, 0x9a, 0x54, 0xe3, 0xcc, 0x51, 0x5e, 0x20, 0x58, 0x0a, 0xa2, 0x93, 0xb5, 0x6c, 0x41, + 0x3e, 0xf0, 0xdf, 0x71, 0xc4, 0x69, 0x0e, 0xda, 0xe6, 0xea, 0xe5, 0xb2, 0xfd, 0xde, 0xb5, 0xdc, + 0x0b, 0xad, 0x5d, 0xbc, 0x0a, 0x8b, 0x86, 0xa5, 0xd3, 0xaf, 0x3a, 0x7d, 0x5b, 0x57, 0x39, 0x75, + 0x0b, 0x73, 0x25, 0xb4, 0x3e, 0x4f, 0x16, 0xc4, 0xe6, 0x53, 0x7f, 0x4f, 0x51, 0x01, 0xef, 0x98, + 0x26, 0xd3, 0x54, 0x4e, 0x9b, 0xba, 0x9b, 0xb0, 0x74, 0x41, 0x53, 0x47, 0x89, 0x9a, 0x7a, 0x1d, + 0x56, 0x42, 0x2e, 0x64, 0xb8, 0xaf, 0x66, 0xe4, 0xf7, 0x14, 0x64, 0x82, 0x80, 0xf1, 0x7d, 0x48, + 0x1b, 0x96, 0x4b, 0x1d, 0x2e, 0x42, 0xca, 0x55, 0x6f, 0x5c, 0xd2, 0xd9, 0xf7, 0x66, 0x88, 0x04, + 0x7b, 0x34, 0x3f, 0x15, 0xe2, 0xcc, 0x4d, 0xa7, 0xf9, 0x60, 0x9f, 0x26, 0xbc, 0xa5, 0x13, 0xd2, + 0x84, 0xb7, 0x2a, 0xa4, 0x75, 0x6a, 0x52, 0x4e, 0x65, 0x63, 0x8c, 0x8d, 0xd0, 0xe3, 0xf8, 0x48, + 0xbc, 0x0a, 0x0b, 0xc7, 0xaa, 0x4b, 0x3b, 0xe7, 0xd4, 0x71, 0xbd, 0x73, 0xed, 0x65, 0x7e, 0x76, + 0x0f, 0x91, 0x9c, 0xb7, 0xfb, 0xcc, 0xdf, 0xac, 0xe5, 0x20, 0xcb, 0x6c, 0xea, 0x88, 0x54, 0xd4, + 0x6e, 0xc1, 0x0d, 0x8d, 0x59, 0x27, 0xa6, 0xa1, 0xf1, 0x8e, 0x4e, 0x39, 0x95, 0xc7, 0x8c, 0x3b, + 0x2a, 0xa7, 0xdd, 0x81, 0xf2, 0x3d, 0x82, 0xa5, 0xf0, 0x39, 0xc1, 0x1b, 0x30, 0x7b, 0x4a, 0x83, + 0x2e, 0x1f, 0x9f, 0x76, 0x0f, 0x84, 0x0b, 0x70, 0x25, 0x90, 0xe2, 0x65, 0x7a, 0x96, 0x04, 0x4b, + 0x7c, 0x07, 0xae, 0x4e, 0xf8, 0xa5, 0xba, 0x48, 0x6b, 0x86, 0xe4, 0x83, 0x17, 0xbb, 0x72, 0x5f, + 0xf9, 0x17, 0x41, 0x6e, 0x6c, 0xee, 0xe0, 0xcf, 0x20, 0x2f, 0xe6, 0x95, 0xc6, 0x2c, 0xd7, 0x70, + 0x39, 0xb5, 0xb4, 0x81, 0xf8, 0x84, 0x97, 0xaa, 0x9b, 0xd3, 0x66, 0x96, 0x78, 0xae, 0x8f, 0x78, + 0x7b, 0x33, 0x64, 0xd9, 0x09, 0x6f, 0x4d, 0x36, 0x87, 0x54, 0x44, 0x73, 0x50, 0xf6, 0x61, 0x79, + 0xc2, 0x12, 0x2e, 0xc1, 0x4d, 0xd2, 0xd8, 0xd9, 0xed, 0xd4, 0xdb, 0xad, 0xc3, 0xe6, 0xe1, 0x51, + 0xa3, 0x55, 0xff, 0x64, 0xe2, 0xb3, 0x07, 0x48, 0x1f, 0x1e, 0x91, 0x76, 0xeb, 0x71, 0x1e, 0xe1, + 0x05, 0xc8, 0x34, 0x9e, 0x35, 0x5a, 0x47, 0x4f, 0xc5, 0x67, 0x8e, 0x21, 0x3f, 0x16, 0x8c, 0x3f, + 0xd0, 0x7e, 0x4c, 0x01, 0xbe, 0xd8, 0xe2, 0x31, 0x01, 0x10, 0xc1, 0x7f, 0xe9, 0x18, 0x9c, 0xca, + 0xb9, 0xb6, 0x95, 0x70, 0x3e, 0x88, 0xe8, 0x3f, 0xf2, 0x88, 0x7b, 0x33, 0x24, 0xeb, 0x04, 0x0b, + 0xdc, 0x86, 0xac, 0x7f, 0x01, 0xb0, 0xcc, 0x60, 0xda, 0x6d, 0xbe, 0x8a, 0xc9, 0xb6, 0x65, 0x8a, + 0xd1, 0xec, 0xc8, 0xe7, 0xe2, 0xfb, 0x90, 0x1d, 0xba, 0xc2, 0x5b, 0x70, 0xcd, 0x76, 0xe8, 0xb9, + 0xc1, 0xfa, 0x6e, 0xe7, 0xe2, 0x64, 0x58, 0x09, 0xde, 0x8d, 0xd9, 0x2e, 0x02, 0x64, 0x02, 0xbb, + 0xb5, 0xb4, 0xdf, 0xe8, 0xab, 0x7f, 0xa7, 0x21, 0xbb, 0x1b, 0x88, 0xc1, 0xcf, 0x21, 0xed, 0xdf, + 0xf4, 0xb0, 0x12, 0xa9, 0x34, 0x74, 0x55, 0x2d, 0xae, 0x5e, 0x8a, 0x91, 0x23, 0xe8, 0xce, 0x77, + 0x7f, 0xfd, 0xf3, 0x53, 0x6a, 0x4d, 0x29, 0x79, 0x57, 0x5f, 0xd9, 0xad, 0xdc, 0xca, 0xd7, 0xa3, + 0x4e, 0xf6, 0xcd, 0x03, 0x53, 0x30, 0x1e, 0xa0, 0x0d, 0xfc, 0x03, 0x82, 0x4c, 0x70, 0xdd, 0xc0, + 0x6f, 0x47, 0x1f, 0xbb, 0xf0, 0x55, 0xae, 0xb8, 0x36, 0x05, 0x25, 0x65, 0xdc, 0x13, 0x32, 0x6e, + 0x2b, 0x4a, 0xbc, 0x0c, 0x47, 0x72, 0x3c, 0x21, 0xbf, 0x20, 0xc8, 0x4f, 0xce, 0x77, 0x7c, 0x37, + 0xd2, 0x55, 0xcc, 0xd5, 0xa4, 0x78, 0x2f, 0x21, 0x5a, 0x0a, 0xbc, 0x2f, 0x04, 0x56, 0x94, 0x8d, + 0x78, 0x81, 0xc7, 0x13, 0x5c, 0x4f, 0xe8, 0x73, 0x48, 0xfb, 0x13, 0x2b, 0xa6, 0x62, 0xa1, 0x61, + 0x1d, 0x53, 0xb1, 0xf0, 0xc8, 0x4b, 0x52, 0x31, 0x4d, 0x30, 0x86, 0x15, 0x93, 0xd7, 0x8e, 0xb8, + 0x8a, 0x85, 0x6f, 0x3a, 0x71, 0x15, 0x9b, 0xbc, 0xbb, 0x24, 0xa9, 0x98, 0xe4, 0x78, 0x42, 0x5e, + 0x22, 0xc8, 0x8d, 0x4d, 0x34, 0x1c, 0x7d, 0x77, 0xb9, 0x38, 0x56, 0x8b, 0xeb, 0xd3, 0x81, 0x52, + 0xd1, 0xa6, 0x50, 0xb4, 0xa1, 0xac, 0xc5, 0x2b, 0x52, 0x47, 0xb4, 0x07, 0x68, 0xa3, 0xf6, 0x02, + 0xc1, 0x75, 0x8d, 0xf5, 0xa2, 0x3c, 0xd4, 0x96, 0x86, 0x9f, 0xdd, 0x81, 0xf7, 0x2b, 0x78, 0x80, + 0x3e, 0x7d, 0x28, 0x61, 0x5d, 0x66, 0xaa, 0x56, 0xb7, 0xcc, 0x9c, 0x6e, 0xa5, 0x4b, 0x2d, 0xf1, + 0xa3, 0x58, 0xf1, 0x5f, 0xa9, 0xb6, 0xe1, 0x86, 0x7e, 0x26, 0xb7, 0x87, 0x8b, 0x5f, 0x53, 0x6f, + 0x3c, 0xf6, 0xe9, 0x75, 0x93, 0xf5, 0xf5, 0xf2, 0xd0, 0x7a, 0xf9, 0xd9, 0xd6, 0x71, 0x5a, 0x18, + 0x79, 0xe7, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xb7, 0x0f, 0xc7, 0x4b, 0x0a, 0x0f, 0x00, 0x00, } diff --git a/vendor/google.golang.org/genproto/googleapis/datastore/v1/query.pb.go b/vendor/google.golang.org/genproto/googleapis/datastore/v1/query.pb.go index 43fe995d..977e6d8a 100644 --- a/vendor/google.golang.org/genproto/googleapis/datastore/v1/query.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/datastore/v1/query.pb.go @@ -160,7 +160,7 @@ const ( // The query is finished, but there may be more results after the end // cursor. QueryResultBatch_MORE_RESULTS_AFTER_CURSOR QueryResultBatch_MoreResultsType = 4 - // The query has been exhausted. + // The query is finished, and there are no more results. QueryResultBatch_NO_MORE_RESULTS QueryResultBatch_MoreResultsType = 3 ) diff --git a/vendor/google.golang.org/genproto/googleapis/datastore/v1beta3/datastore.pb.go b/vendor/google.golang.org/genproto/googleapis/datastore/v1beta3/datastore.pb.go index af9c0ed7..0e5191bd 100644 --- a/vendor/google.golang.org/genproto/googleapis/datastore/v1beta3/datastore.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/datastore/v1beta3/datastore.pb.go @@ -25,6 +25,7 @@ It has these top-level messages: Mutation MutationResult ReadOptions + TransactionOptions PartitionId Key ArrayValue @@ -388,6 +389,8 @@ func (m *RunQueryResponse) GetQuery() *Query { type BeginTransactionRequest struct { // The ID of the project against which to make the request. ProjectId string `protobuf:"bytes,8,opt,name=project_id,json=projectId" json:"project_id,omitempty"` + // Options for a new transaction. + TransactionOptions *TransactionOptions `protobuf:"bytes,10,opt,name=transaction_options,json=transactionOptions" json:"transaction_options,omitempty"` } func (m *BeginTransactionRequest) Reset() { *m = BeginTransactionRequest{} } @@ -402,6 +405,13 @@ func (m *BeginTransactionRequest) GetProjectId() string { return "" } +func (m *BeginTransactionRequest) GetTransactionOptions() *TransactionOptions { + if m != nil { + return m.TransactionOptions + } + return nil +} + // The response for [Datastore.BeginTransaction][google.datastore.v1beta3.Datastore.BeginTransaction]. type BeginTransactionResponse struct { // The transaction identifier (always present). @@ -1067,6 +1077,160 @@ func _ReadOptions_OneofSizer(msg proto.Message) (n int) { return n } +// Options for beginning a new transaction. +type TransactionOptions struct { + // The `mode` of the transaction, indicating whether write operations are + // supported. + // + // Types that are valid to be assigned to Mode: + // *TransactionOptions_ReadWrite_ + // *TransactionOptions_ReadOnly_ + Mode isTransactionOptions_Mode `protobuf_oneof:"mode"` +} + +func (m *TransactionOptions) Reset() { *m = TransactionOptions{} } +func (m *TransactionOptions) String() string { return proto.CompactTextString(m) } +func (*TransactionOptions) ProtoMessage() {} +func (*TransactionOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } + +type isTransactionOptions_Mode interface { + isTransactionOptions_Mode() +} + +type TransactionOptions_ReadWrite_ struct { + ReadWrite *TransactionOptions_ReadWrite `protobuf:"bytes,1,opt,name=read_write,json=readWrite,oneof"` +} +type TransactionOptions_ReadOnly_ struct { + ReadOnly *TransactionOptions_ReadOnly `protobuf:"bytes,2,opt,name=read_only,json=readOnly,oneof"` +} + +func (*TransactionOptions_ReadWrite_) isTransactionOptions_Mode() {} +func (*TransactionOptions_ReadOnly_) isTransactionOptions_Mode() {} + +func (m *TransactionOptions) GetMode() isTransactionOptions_Mode { + if m != nil { + return m.Mode + } + return nil +} + +func (m *TransactionOptions) GetReadWrite() *TransactionOptions_ReadWrite { + if x, ok := m.GetMode().(*TransactionOptions_ReadWrite_); ok { + return x.ReadWrite + } + return nil +} + +func (m *TransactionOptions) GetReadOnly() *TransactionOptions_ReadOnly { + if x, ok := m.GetMode().(*TransactionOptions_ReadOnly_); ok { + return x.ReadOnly + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*TransactionOptions) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _TransactionOptions_OneofMarshaler, _TransactionOptions_OneofUnmarshaler, _TransactionOptions_OneofSizer, []interface{}{ + (*TransactionOptions_ReadWrite_)(nil), + (*TransactionOptions_ReadOnly_)(nil), + } +} + +func _TransactionOptions_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*TransactionOptions) + // mode + switch x := m.Mode.(type) { + case *TransactionOptions_ReadWrite_: + b.EncodeVarint(1<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.ReadWrite); err != nil { + return err + } + case *TransactionOptions_ReadOnly_: + b.EncodeVarint(2<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.ReadOnly); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("TransactionOptions.Mode has unexpected type %T", x) + } + return nil +} + +func _TransactionOptions_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*TransactionOptions) + switch tag { + case 1: // mode.read_write + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(TransactionOptions_ReadWrite) + err := b.DecodeMessage(msg) + m.Mode = &TransactionOptions_ReadWrite_{msg} + return true, err + case 2: // mode.read_only + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(TransactionOptions_ReadOnly) + err := b.DecodeMessage(msg) + m.Mode = &TransactionOptions_ReadOnly_{msg} + return true, err + default: + return false, nil + } +} + +func _TransactionOptions_OneofSizer(msg proto.Message) (n int) { + m := msg.(*TransactionOptions) + // mode + switch x := m.Mode.(type) { + case *TransactionOptions_ReadWrite_: + s := proto.Size(x.ReadWrite) + n += proto.SizeVarint(1<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case *TransactionOptions_ReadOnly_: + s := proto.Size(x.ReadOnly) + n += proto.SizeVarint(2<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + +// Options specific to read / write transactions. +type TransactionOptions_ReadWrite struct { + // The transaction identifier of the transaction being retried. + PreviousTransaction []byte `protobuf:"bytes,1,opt,name=previous_transaction,json=previousTransaction,proto3" json:"previous_transaction,omitempty"` +} + +func (m *TransactionOptions_ReadWrite) Reset() { *m = TransactionOptions_ReadWrite{} } +func (m *TransactionOptions_ReadWrite) String() string { return proto.CompactTextString(m) } +func (*TransactionOptions_ReadWrite) ProtoMessage() {} +func (*TransactionOptions_ReadWrite) Descriptor() ([]byte, []int) { + return fileDescriptor0, []int{15, 0} +} + +func (m *TransactionOptions_ReadWrite) GetPreviousTransaction() []byte { + if m != nil { + return m.PreviousTransaction + } + return nil +} + +// Options specific to read-only transactions. +type TransactionOptions_ReadOnly struct { +} + +func (m *TransactionOptions_ReadOnly) Reset() { *m = TransactionOptions_ReadOnly{} } +func (m *TransactionOptions_ReadOnly) String() string { return proto.CompactTextString(m) } +func (*TransactionOptions_ReadOnly) ProtoMessage() {} +func (*TransactionOptions_ReadOnly) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15, 1} } + func init() { proto.RegisterType((*LookupRequest)(nil), "google.datastore.v1beta3.LookupRequest") proto.RegisterType((*LookupResponse)(nil), "google.datastore.v1beta3.LookupResponse") @@ -1083,6 +1247,9 @@ func init() { proto.RegisterType((*Mutation)(nil), "google.datastore.v1beta3.Mutation") proto.RegisterType((*MutationResult)(nil), "google.datastore.v1beta3.MutationResult") proto.RegisterType((*ReadOptions)(nil), "google.datastore.v1beta3.ReadOptions") + proto.RegisterType((*TransactionOptions)(nil), "google.datastore.v1beta3.TransactionOptions") + proto.RegisterType((*TransactionOptions_ReadWrite)(nil), "google.datastore.v1beta3.TransactionOptions.ReadWrite") + proto.RegisterType((*TransactionOptions_ReadOnly)(nil), "google.datastore.v1beta3.TransactionOptions.ReadOnly") proto.RegisterEnum("google.datastore.v1beta3.CommitRequest_Mode", CommitRequest_Mode_name, CommitRequest_Mode_value) proto.RegisterEnum("google.datastore.v1beta3.ReadOptions_ReadConsistency", ReadOptions_ReadConsistency_name, ReadOptions_ReadConsistency_value) } @@ -1343,82 +1510,88 @@ var _Datastore_serviceDesc = grpc.ServiceDesc{ func init() { proto.RegisterFile("google/datastore/v1beta3/datastore.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ - // 1218 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xcf, 0x72, 0xdb, 0xd4, - 0x17, 0xce, 0x75, 0x12, 0xc7, 0x39, 0xce, 0x1f, 0xf7, 0xfe, 0xfa, 0x03, 0x4d, 0x68, 0xc1, 0xa3, - 0x52, 0x6a, 0x42, 0xb1, 0x89, 0x4b, 0xa7, 0x10, 0xba, 0x88, 0xed, 0xb8, 0xb5, 0x87, 0xc6, 0x09, - 0xd7, 0x6e, 0x67, 0x60, 0xa3, 0x91, 0xa5, 0x1b, 0x23, 0x22, 0xeb, 0x2a, 0xd2, 0x75, 0x07, 0x0f, - 0xc3, 0x86, 0x15, 0x03, 0xc3, 0x0a, 0x78, 0x00, 0xb6, 0xb0, 0x06, 0x5e, 0x81, 0x19, 0x66, 0xd8, - 0xf0, 0x0a, 0x3c, 0x04, 0x4b, 0x46, 0x57, 0x57, 0x76, 0xe4, 0x56, 0xb6, 0xc2, 0xb0, 0xb3, 0x8e, - 0xbf, 0xef, 0x9c, 0xef, 0x9c, 0x73, 0x75, 0xce, 0x15, 0x94, 0x06, 0x8c, 0x0d, 0x6c, 0x5a, 0x31, - 0x75, 0xae, 0xfb, 0x9c, 0x79, 0xb4, 0xf2, 0x74, 0xaf, 0x4f, 0xb9, 0x7e, 0x67, 0x6a, 0x29, 0xbb, - 0x1e, 0xe3, 0x0c, 0x2b, 0x21, 0xb2, 0x3c, 0xb5, 0x4b, 0xe4, 0xce, 0x35, 0xe9, 0x43, 0x77, 0xad, - 0x8a, 0xee, 0x38, 0x8c, 0xeb, 0xdc, 0x62, 0x8e, 0x1f, 0xf2, 0x76, 0x6e, 0x26, 0x46, 0xa0, 0x0e, - 0xb7, 0xf8, 0x58, 0xc2, 0x5e, 0x4d, 0x84, 0x9d, 0x8f, 0xa8, 0x27, 0x51, 0xea, 0x4f, 0x08, 0x36, - 0x1f, 0x31, 0x76, 0x36, 0x72, 0x09, 0x3d, 0x1f, 0x51, 0x9f, 0xe3, 0xeb, 0x00, 0xae, 0xc7, 0x3e, - 0xa1, 0x06, 0xd7, 0x2c, 0x53, 0xc9, 0x15, 0x51, 0x69, 0x9d, 0xac, 0x4b, 0x4b, 0xdb, 0xc4, 0x2d, - 0xd8, 0xf0, 0xa8, 0x6e, 0x6a, 0xcc, 0x15, 0x9a, 0x14, 0x54, 0x44, 0xa5, 0x7c, 0xf5, 0x66, 0x39, - 0x29, 0x99, 0x32, 0xa1, 0xba, 0x79, 0x1c, 0x82, 0x49, 0xde, 0x9b, 0x3e, 0xe0, 0x3d, 0x58, 0x39, - 0xa3, 0x63, 0x5f, 0x59, 0x2e, 0x2e, 0x97, 0xf2, 0xd5, 0xeb, 0xc9, 0x1e, 0xde, 0xa7, 0x63, 0x22, - 0xa0, 0xea, 0xef, 0x08, 0xb6, 0x22, 0xb5, 0xbe, 0xcb, 0x1c, 0x9f, 0xe2, 0xfb, 0xb0, 0x7a, 0xca, - 0x46, 0x8e, 0xa9, 0x20, 0xe1, 0xe6, 0xb5, 0x64, 0x37, 0x4d, 0x51, 0x1d, 0x42, 0xfd, 0x91, 0xcd, - 0x49, 0x48, 0xc2, 0x07, 0xb0, 0x36, 0xb4, 0x7c, 0xdf, 0x72, 0x06, 0x4a, 0xe6, 0x52, 0xfc, 0x88, - 0x86, 0xdf, 0x85, 0x9c, 0x49, 0x4f, 0xa9, 0xe7, 0x51, 0x33, 0x5d, 0x26, 0x13, 0xb8, 0xfa, 0x47, - 0x06, 0xb6, 0xc9, 0xc8, 0xf9, 0x20, 0x68, 0x47, 0xfa, 0xea, 0xbb, 0xba, 0xc7, 0xad, 0xa0, 0x82, - 0x01, 0x20, 0xb3, 0xa8, 0xfa, 0x27, 0x11, 0xba, 0x6d, 0x92, 0xbc, 0x3b, 0x7d, 0xf8, 0x0f, 0xfb, - 0x78, 0x0f, 0x56, 0xc5, 0x89, 0x52, 0x96, 0x85, 0x8b, 0x57, 0x92, 0x5d, 0x88, 0x4c, 0x5b, 0x4b, - 0x24, 0xc4, 0xe3, 0x1a, 0xac, 0x0f, 0xce, 0x6d, 0x2d, 0x24, 0xaf, 0x09, 0xb2, 0x9a, 0x4c, 0x7e, - 0x78, 0x6e, 0x47, 0xfc, 0xdc, 0x40, 0xfe, 0xae, 0x6f, 0x00, 0x08, 0xba, 0xc6, 0xc7, 0x2e, 0x55, - 0xbf, 0x46, 0x50, 0x98, 0x16, 0x54, 0x1e, 0x90, 0x03, 0x58, 0xed, 0xeb, 0xdc, 0xf8, 0x58, 0x66, - 0xb8, 0xbb, 0x40, 0x5e, 0xd8, 0xdf, 0x7a, 0xc0, 0x20, 0x21, 0x11, 0xdf, 0x8d, 0x12, 0xcc, 0xa4, - 0x4a, 0x50, 0xa6, 0xa7, 0xbe, 0x03, 0x2f, 0xd6, 0xe9, 0xc0, 0x72, 0x7a, 0x9e, 0xee, 0xf8, 0xba, - 0x11, 0x14, 0x2b, 0x5d, 0x97, 0xd5, 0xfb, 0xa0, 0x3c, 0xcb, 0x94, 0xe9, 0x14, 0x21, 0xcf, 0xa7, - 0x66, 0x91, 0xd4, 0x06, 0xb9, 0x68, 0x52, 0x09, 0x6c, 0x13, 0x66, 0xdb, 0x7d, 0xdd, 0x38, 0x4b, - 0x79, 0xaa, 0x16, 0xfb, 0xc4, 0x50, 0x98, 0xfa, 0x0c, 0x95, 0xa8, 0xbf, 0x64, 0x60, 0xb3, 0xc1, - 0x86, 0x43, 0x8b, 0xa7, 0x0c, 0x73, 0x00, 0x2b, 0x43, 0x66, 0x52, 0x65, 0xb5, 0x88, 0x4a, 0x5b, - 0xd5, 0xdb, 0xc9, 0x65, 0x8c, 0x79, 0x2d, 0x1f, 0x31, 0x93, 0x12, 0xc1, 0xc4, 0xea, 0x73, 0x84, - 0xb6, 0x96, 0x62, 0x52, 0xf1, 0x01, 0xac, 0x0f, 0x47, 0x72, 0x62, 0x2a, 0x59, 0xf1, 0x46, 0xce, - 0x39, 0x55, 0x47, 0x12, 0x4a, 0xa6, 0x24, 0xf5, 0x01, 0xac, 0x04, 0x31, 0xf1, 0x55, 0x28, 0x1c, - 0x1d, 0x1f, 0x36, 0xb5, 0xc7, 0x9d, 0xee, 0x49, 0xb3, 0xd1, 0x7e, 0xd0, 0x6e, 0x1e, 0x16, 0x96, - 0xf0, 0x15, 0xd8, 0xec, 0x91, 0x5a, 0xa7, 0x5b, 0x6b, 0xf4, 0xda, 0xc7, 0x9d, 0xda, 0xa3, 0x02, - 0xc2, 0xff, 0x87, 0x2b, 0x9d, 0xe3, 0x8e, 0x16, 0x37, 0x67, 0xea, 0x2f, 0xc0, 0xd5, 0x0b, 0xc2, - 0x34, 0x9f, 0xda, 0xd4, 0xe0, 0xcc, 0x53, 0xbf, 0x42, 0xb0, 0x15, 0xa5, 0x28, 0xbb, 0xda, 0x85, - 0x42, 0x14, 0x5f, 0xf3, 0xc4, 0x09, 0x8c, 0xe6, 0x62, 0x29, 0x85, 0xf6, 0x70, 0x24, 0x6d, 0x0f, - 0x63, 0xcf, 0x3e, 0xbe, 0x01, 0x9b, 0x96, 0x63, 0xd2, 0x4f, 0xb5, 0x91, 0x6b, 0xea, 0x9c, 0xfa, - 0xca, 0x4a, 0x11, 0x95, 0x56, 0xc9, 0x86, 0x30, 0x3e, 0x0e, 0x6d, 0xea, 0x29, 0xe0, 0x9a, 0x6d, - 0x33, 0x43, 0xe7, 0xb4, 0x6d, 0xfa, 0x29, 0x3b, 0x19, 0x8d, 0x6e, 0x94, 0x7e, 0x74, 0xb7, 0xe0, - 0x7f, 0xb1, 0x38, 0x32, 0xf1, 0x7f, 0xe1, 0xe9, 0xb7, 0x0c, 0xe4, 0xa2, 0xd4, 0xf1, 0x3e, 0x64, - 0x2d, 0xc7, 0xa7, 0x1e, 0x17, 0xc9, 0xe5, 0xab, 0xc5, 0x45, 0xf3, 0xbb, 0xb5, 0x44, 0x24, 0x23, - 0xe0, 0x86, 0x95, 0x11, 0x27, 0x32, 0x25, 0x37, 0x64, 0x84, 0x5c, 0x11, 0x37, 0x7b, 0x19, 0xae, - 0x88, 0x7b, 0x0f, 0xb2, 0x26, 0xb5, 0x29, 0xa7, 0x72, 0xe8, 0xcd, 0xcf, 0x3a, 0x20, 0x86, 0x70, - 0x7c, 0x03, 0x36, 0xfa, 0xba, 0x4f, 0xb5, 0xa7, 0xd4, 0xf3, 0x83, 0xf3, 0x1f, 0xf4, 0x65, 0xb9, - 0x85, 0x48, 0x3e, 0xb0, 0x3e, 0x09, 0x8d, 0xf5, 0x3c, 0xac, 0x33, 0x97, 0x7a, 0xa2, 0x3c, 0xf5, - 0xeb, 0xf0, 0x92, 0xc1, 0x9c, 0x53, 0xdb, 0x32, 0xb8, 0x66, 0x52, 0x4e, 0xe5, 0x49, 0xe4, 0x9e, - 0xce, 0xe9, 0x60, 0xac, 0x7e, 0x89, 0x60, 0x2b, 0x7e, 0x8a, 0x70, 0x05, 0x96, 0xcf, 0x68, 0x34, - 0xcb, 0x17, 0xf4, 0x23, 0x40, 0x62, 0x05, 0xd6, 0x22, 0x3d, 0x41, 0x0b, 0x96, 0x49, 0xf4, 0x88, - 0xdf, 0x80, 0x2b, 0x33, 0xc1, 0xa9, 0x29, 0x4a, 0x9d, 0x23, 0x85, 0xe8, 0x8f, 0x43, 0x69, 0x57, - 0xff, 0x46, 0x90, 0xbf, 0xb0, 0x62, 0x70, 0x1f, 0x0a, 0x62, 0x3f, 0x19, 0xcc, 0xf1, 0x2d, 0x9f, - 0x53, 0xc7, 0x18, 0x8b, 0xf7, 0x7d, 0xab, 0x7a, 0x37, 0xd5, 0x8e, 0x12, 0xbf, 0x1b, 0x53, 0x72, - 0x6b, 0x89, 0x6c, 0x7b, 0x71, 0xd3, 0xec, 0x38, 0xc9, 0x3c, 0x67, 0x9c, 0xa8, 0x47, 0xb0, 0x3d, - 0xe3, 0x09, 0x17, 0xe1, 0x1a, 0x69, 0xd6, 0x0e, 0xb5, 0xc6, 0x71, 0xa7, 0xdb, 0xee, 0xf6, 0x9a, - 0x9d, 0xc6, 0x87, 0x33, 0x33, 0x02, 0x20, 0xdb, 0xed, 0x91, 0xe3, 0xce, 0xc3, 0x02, 0xc2, 0x1b, - 0x90, 0x6b, 0x3e, 0x69, 0x76, 0x7a, 0x8f, 0xc5, 0x4c, 0xc0, 0x50, 0xb8, 0x90, 0x91, 0x58, 0x5b, - 0xd5, 0x5f, 0xd7, 0x60, 0xfd, 0x30, 0xca, 0x05, 0x7f, 0x83, 0x20, 0x1b, 0xde, 0x71, 0xf0, 0xad, - 0xe4, 0x4c, 0x63, 0x77, 0xb6, 0x9d, 0xd2, 0x62, 0xa0, 0x1c, 0xda, 0x6f, 0x7d, 0xf1, 0xe7, 0x5f, - 0xdf, 0x66, 0x76, 0xd5, 0x9b, 0x93, 0xdb, 0xa0, 0x7c, 0xab, 0xfd, 0xca, 0x67, 0xd3, 0x37, 0xfe, - 0xf3, 0x7d, 0x5b, 0xd0, 0xf6, 0xd1, 0x2e, 0xfe, 0x1e, 0x41, 0x2e, 0x5a, 0xaa, 0xf8, 0xf5, 0x39, - 0xb5, 0x8f, 0xdf, 0x64, 0x76, 0x76, 0xd3, 0x40, 0xa5, 0xaa, 0xaa, 0x50, 0x75, 0x5b, 0xbd, 0xb5, - 0x40, 0x95, 0x27, 0x89, 0x81, 0xae, 0x9f, 0x11, 0x14, 0x66, 0xb7, 0x24, 0xde, 0x4b, 0x0e, 0x9a, - 0xb0, 0x8b, 0x77, 0xaa, 0x97, 0xa1, 0x48, 0xbd, 0xfb, 0x42, 0xef, 0xdb, 0x6a, 0x65, 0x81, 0xde, - 0xfe, 0x8c, 0x83, 0x40, 0x77, 0xd0, 0xdf, 0x70, 0xfa, 0xcf, 0xeb, 0x6f, 0x6c, 0x05, 0xce, 0xeb, - 0x6f, 0x7c, 0x91, 0xa4, 0xee, 0xaf, 0x21, 0x68, 0x93, 0xfe, 0xca, 0xdd, 0x3e, 0xb7, 0xbf, 0xf1, - 0x3b, 0xc5, 0xdc, 0xfe, 0xce, 0x5e, 0x15, 0x52, 0xf7, 0x57, 0x12, 0x03, 0x5d, 0x3f, 0x20, 0xc8, - 0x5f, 0xd8, 0x18, 0x78, 0xce, 0x7d, 0xe1, 0xd9, 0x05, 0xb6, 0xf3, 0x66, 0x4a, 0xb4, 0x14, 0x78, - 0x57, 0x08, 0xac, 0xa8, 0xbb, 0x0b, 0x04, 0xea, 0x53, 0xee, 0x3e, 0xda, 0xad, 0x7f, 0x87, 0xe0, - 0x9a, 0xc1, 0x86, 0x89, 0xb1, 0xea, 0x5b, 0x93, 0xf7, 0xfa, 0x24, 0xf8, 0xdc, 0x3a, 0x41, 0x1f, - 0xd5, 0x24, 0x76, 0xc0, 0x6c, 0xdd, 0x19, 0x94, 0x99, 0x37, 0xa8, 0x0c, 0xa8, 0x23, 0x3e, 0xc6, - 0x2a, 0xe1, 0x5f, 0xba, 0x6b, 0xf9, 0xcf, 0x7e, 0xb5, 0xbd, 0x37, 0xb1, 0xfc, 0x98, 0x79, 0xf9, - 0x61, 0xe8, 0xa3, 0x61, 0xb3, 0x91, 0x59, 0x9e, 0x84, 0x28, 0x3f, 0xd9, 0xab, 0x07, 0xd0, 0x7e, - 0x56, 0xb8, 0xbb, 0xf3, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0f, 0x31, 0x6a, 0x10, 0x8c, 0x0e, - 0x00, 0x00, + // 1323 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xdf, 0x6f, 0x1b, 0xc5, + 0x13, 0xcf, 0x3a, 0x89, 0x63, 0x8f, 0xf3, 0xc3, 0xdd, 0xf6, 0xfb, 0xc5, 0x32, 0x2d, 0x58, 0x57, + 0x4a, 0x4d, 0x28, 0x36, 0x71, 0x09, 0x15, 0xa1, 0x42, 0xb1, 0x1d, 0xb7, 0xb6, 0x68, 0xec, 0xb0, + 0x71, 0x5b, 0x81, 0x84, 0xac, 0xb3, 0x6f, 0x63, 0x8e, 0x9c, 0x6f, 0x2f, 0x77, 0xeb, 0x42, 0x84, + 0x78, 0xe1, 0x09, 0x81, 0x78, 0x02, 0xd4, 0x67, 0x5e, 0xe1, 0x19, 0xf8, 0x17, 0x90, 0x90, 0x78, + 0xe1, 0x5f, 0xe0, 0x8f, 0xe0, 0x11, 0xdd, 0xde, 0x9e, 0xed, 0xb3, 0x7b, 0xf6, 0x05, 0xf1, 0x76, + 0x3b, 0x37, 0x9f, 0x99, 0xcf, 0xcc, 0xec, 0xcd, 0xcc, 0x41, 0xbe, 0xcf, 0x58, 0xdf, 0xa0, 0x45, + 0x4d, 0xe5, 0xaa, 0xc3, 0x99, 0x4d, 0x8b, 0x4f, 0x76, 0xba, 0x94, 0xab, 0xb7, 0xc7, 0x92, 0x82, + 0x65, 0x33, 0xce, 0x70, 0xc6, 0xd3, 0x2c, 0x8c, 0xe5, 0x52, 0x33, 0x7b, 0x55, 0xda, 0x50, 0x2d, + 0xbd, 0xa8, 0x9a, 0x26, 0xe3, 0x2a, 0xd7, 0x99, 0xe9, 0x78, 0xb8, 0xec, 0x8d, 0x50, 0x0f, 0xd4, + 0xe4, 0x3a, 0x3f, 0x97, 0x6a, 0x2f, 0x85, 0xaa, 0x9d, 0x0d, 0xa9, 0x2d, 0xb5, 0x94, 0x9f, 0x10, + 0x6c, 0x3c, 0x60, 0xec, 0x74, 0x68, 0x11, 0x7a, 0x36, 0xa4, 0x0e, 0xc7, 0xd7, 0x00, 0x2c, 0x9b, + 0x7d, 0x4c, 0x7b, 0xbc, 0xa3, 0x6b, 0x99, 0x44, 0x0e, 0xe5, 0x93, 0x24, 0x29, 0x25, 0x0d, 0x0d, + 0xd7, 0x61, 0xdd, 0xa6, 0xaa, 0xd6, 0x61, 0x96, 0xe0, 0x94, 0x41, 0x39, 0x94, 0x4f, 0x95, 0x6e, + 0x14, 0xc2, 0x82, 0x29, 0x10, 0xaa, 0x6a, 0x2d, 0x4f, 0x99, 0xa4, 0xec, 0xf1, 0x01, 0xef, 0xc0, + 0xca, 0x29, 0x3d, 0x77, 0x32, 0xcb, 0xb9, 0xe5, 0x7c, 0xaa, 0x74, 0x2d, 0xdc, 0xc2, 0xbb, 0xf4, + 0x9c, 0x08, 0x55, 0xe5, 0x77, 0x04, 0x9b, 0x3e, 0x5b, 0xc7, 0x62, 0xa6, 0x43, 0xf1, 0x5d, 0x58, + 0x3d, 0x61, 0x43, 0x53, 0xcb, 0x20, 0x61, 0xe6, 0xe5, 0x70, 0x33, 0x35, 0x91, 0x1d, 0x42, 0x9d, + 0xa1, 0xc1, 0x89, 0x07, 0xc2, 0xfb, 0xb0, 0x36, 0xd0, 0x1d, 0x47, 0x37, 0xfb, 0x99, 0xd8, 0x85, + 0xf0, 0x3e, 0x0c, 0xbf, 0x05, 0x09, 0x8d, 0x9e, 0x50, 0xdb, 0xa6, 0x5a, 0xb4, 0x48, 0x46, 0xea, + 0xca, 0x1f, 0x31, 0xd8, 0x22, 0x43, 0xf3, 0x3d, 0xb7, 0x1c, 0xd1, 0xb3, 0x6f, 0xa9, 0x36, 0xd7, + 0xdd, 0x0c, 0xba, 0x0a, 0xb1, 0x45, 0xd9, 0x3f, 0xf2, 0xb5, 0x1b, 0x1a, 0x49, 0x59, 0xe3, 0xc3, + 0x7f, 0x58, 0xc7, 0x3b, 0xb0, 0x2a, 0x6e, 0x54, 0x66, 0x59, 0x98, 0x78, 0x31, 0xdc, 0x84, 0x88, + 0xb4, 0xbe, 0x44, 0x3c, 0x7d, 0x5c, 0x86, 0x64, 0xff, 0xcc, 0xe8, 0x78, 0xe0, 0x35, 0x01, 0x56, + 0xc2, 0xc1, 0xf7, 0xcf, 0x0c, 0x1f, 0x9f, 0xe8, 0xcb, 0xe7, 0xca, 0x3a, 0x80, 0x80, 0x77, 0xf8, + 0xb9, 0x45, 0x95, 0xaf, 0x11, 0xa4, 0xc7, 0x09, 0x95, 0x17, 0x64, 0x1f, 0x56, 0xbb, 0x2a, 0xef, + 0x7d, 0x24, 0x23, 0xdc, 0x5e, 0x40, 0xcf, 0xab, 0x6f, 0xc5, 0x45, 0x10, 0x0f, 0x88, 0x77, 0xfd, + 0x00, 0x63, 0x91, 0x02, 0x94, 0xe1, 0x29, 0x4f, 0x11, 0x3c, 0x57, 0xa1, 0x7d, 0xdd, 0x6c, 0xdb, + 0xaa, 0xe9, 0xa8, 0x3d, 0x37, 0x5b, 0x11, 0xcb, 0xfc, 0x21, 0x5c, 0xe6, 0x63, 0xd0, 0xa8, 0x46, + 0x20, 0xfc, 0xdf, 0x0a, 0xf7, 0x3f, 0xe1, 0xc9, 0x2f, 0x15, 0xe6, 0x33, 0x32, 0xe5, 0x2e, 0x64, + 0x66, 0x89, 0xc9, 0x74, 0xe5, 0x20, 0x35, 0x81, 0x10, 0x49, 0x5b, 0x27, 0x93, 0x22, 0x85, 0xc0, + 0x16, 0x61, 0x86, 0xd1, 0x55, 0x7b, 0xa7, 0x11, 0xc3, 0x59, 0x6c, 0x13, 0x43, 0x7a, 0x6c, 0xd3, + 0x63, 0xa2, 0xfc, 0x12, 0x83, 0x8d, 0x2a, 0x1b, 0x0c, 0x74, 0x1e, 0xd1, 0xcd, 0x3e, 0xac, 0x0c, + 0x98, 0x46, 0x33, 0xab, 0x39, 0x94, 0xdf, 0x9c, 0x97, 0xa6, 0x80, 0xd5, 0xc2, 0x21, 0xd3, 0x28, + 0x11, 0x48, 0xac, 0x3c, 0x83, 0x68, 0x7d, 0x29, 0x40, 0x15, 0xef, 0x43, 0x72, 0x30, 0x94, 0x1d, + 0x39, 0x13, 0x17, 0x5f, 0xfc, 0x9c, 0x5b, 0x7b, 0x28, 0x55, 0xc9, 0x18, 0xa4, 0xdc, 0x83, 0x15, + 0xd7, 0x27, 0xbe, 0x02, 0xe9, 0xc3, 0xd6, 0x41, 0xad, 0xf3, 0xb0, 0x79, 0x7c, 0x54, 0xab, 0x36, + 0xee, 0x35, 0x6a, 0x07, 0xe9, 0x25, 0x7c, 0x09, 0x36, 0xda, 0xa4, 0xdc, 0x3c, 0x2e, 0x57, 0xdb, + 0x8d, 0x56, 0xb3, 0xfc, 0x20, 0x8d, 0xf0, 0xff, 0xe0, 0x52, 0xb3, 0xd5, 0xec, 0x04, 0xc5, 0xb1, + 0xca, 0xff, 0xe1, 0xca, 0xe4, 0x2d, 0x71, 0xa8, 0x41, 0x7b, 0x9c, 0xd9, 0xca, 0x57, 0x08, 0x36, + 0xfd, 0x10, 0x65, 0x55, 0x8f, 0x21, 0xed, 0xfb, 0xef, 0xd8, 0xe2, 0x86, 0xfb, 0x7d, 0x37, 0x1f, + 0x81, 0xbb, 0xd7, 0xf2, 0xb6, 0x06, 0x81, 0xb3, 0x83, 0xaf, 0xc3, 0x86, 0x6e, 0x6a, 0xf4, 0xd3, + 0xce, 0xd0, 0xd2, 0x54, 0x4e, 0x9d, 0xcc, 0x4a, 0x0e, 0xe5, 0x57, 0xc9, 0xba, 0x10, 0x3e, 0xf4, + 0x64, 0xca, 0x09, 0xe0, 0xb2, 0x61, 0xb0, 0x9e, 0xca, 0x69, 0x43, 0x73, 0x22, 0x56, 0xd2, 0x1f, + 0x0d, 0x28, 0xfa, 0x68, 0xa8, 0xc3, 0xe5, 0x80, 0x1f, 0x19, 0xf8, 0xbf, 0xb0, 0xf4, 0x5b, 0x0c, + 0x12, 0x7e, 0xe8, 0x78, 0x0f, 0xe2, 0xba, 0xe9, 0x50, 0x9b, 0x8b, 0xe0, 0x52, 0xa5, 0xdc, 0xa2, + 0xf9, 0x50, 0x5f, 0x22, 0x12, 0xe1, 0x62, 0xbd, 0xcc, 0x88, 0x1b, 0x19, 0x11, 0xeb, 0x21, 0x3c, + 0xac, 0xf0, 0x1b, 0xbf, 0x08, 0x56, 0xf8, 0xbd, 0x03, 0x71, 0x8d, 0x1a, 0x94, 0x53, 0xd9, 0x54, + 0xe7, 0x47, 0xed, 0x02, 0x3d, 0x75, 0x7c, 0x1d, 0xd6, 0xbb, 0xaa, 0x43, 0x3b, 0x4f, 0xa8, 0xed, + 0xb8, 0xf7, 0xdf, 0xad, 0xcb, 0x72, 0x1d, 0x91, 0x94, 0x2b, 0x7d, 0xe4, 0x09, 0x2b, 0x29, 0x48, + 0x32, 0x8b, 0xda, 0x22, 0x3d, 0x95, 0x6b, 0xf0, 0x7c, 0x8f, 0x99, 0x27, 0x86, 0xde, 0xe3, 0x1d, + 0x8d, 0x72, 0x2a, 0x6f, 0x22, 0xb7, 0x55, 0x4e, 0xfb, 0xe7, 0xca, 0x97, 0x08, 0x36, 0x83, 0xb7, + 0x08, 0x17, 0x61, 0xf9, 0x94, 0xfa, 0xb3, 0x62, 0x41, 0x3d, 0x5c, 0x4d, 0x9c, 0x81, 0x35, 0x9f, + 0x8f, 0x5b, 0x82, 0x65, 0xe2, 0x1f, 0xf1, 0xab, 0x70, 0x69, 0xca, 0x39, 0xd5, 0x44, 0xaa, 0x13, + 0x24, 0xed, 0xbf, 0x38, 0x90, 0x72, 0xe5, 0x6f, 0x04, 0xa9, 0x89, 0x11, 0x86, 0xbb, 0x90, 0x16, + 0xf3, 0xaf, 0xc7, 0x4c, 0x47, 0x77, 0x38, 0x35, 0x7b, 0xe7, 0xe2, 0x7b, 0xdf, 0x2c, 0xed, 0x46, + 0x9a, 0x81, 0xe2, 0xb9, 0x3a, 0x06, 0xd7, 0x97, 0xc8, 0x96, 0x1d, 0x14, 0x4d, 0xb7, 0x93, 0xd8, + 0x33, 0xda, 0x89, 0x72, 0x08, 0x5b, 0x53, 0x96, 0x70, 0x0e, 0xae, 0x92, 0x5a, 0xf9, 0xa0, 0x53, + 0x6d, 0x35, 0x8f, 0x1b, 0xc7, 0xed, 0x5a, 0xb3, 0xfa, 0xfe, 0x54, 0x8f, 0x00, 0x88, 0x1f, 0xb7, + 0x49, 0xab, 0x79, 0x3f, 0x8d, 0xf0, 0x3a, 0x24, 0x6a, 0x8f, 0x6a, 0xcd, 0xf6, 0x43, 0xd1, 0x13, + 0x30, 0xa4, 0x27, 0x22, 0xf2, 0xc6, 0xe2, 0xd3, 0x18, 0xe0, 0xd9, 0xc9, 0x80, 0x1f, 0x03, 0x88, + 0x0c, 0x7c, 0x62, 0xeb, 0x9c, 0xca, 0xe9, 0xf8, 0xe6, 0x45, 0x66, 0x8b, 0x48, 0xc1, 0x63, 0x17, + 0x5d, 0x5f, 0x22, 0x49, 0xdb, 0x3f, 0xe0, 0x36, 0x24, 0xbd, 0xd5, 0xc2, 0x34, 0xfc, 0x99, 0xb9, + 0x7b, 0x61, 0xbb, 0x2d, 0xd3, 0x10, 0xa3, 0xde, 0x96, 0xcf, 0xd9, 0x77, 0x20, 0x39, 0xf2, 0x87, + 0x77, 0xe0, 0x8a, 0x65, 0xd3, 0x27, 0x3a, 0x1b, 0x3a, 0x9d, 0xd9, 0xd1, 0x72, 0xd9, 0x7f, 0x37, + 0x61, 0x3b, 0x0b, 0x90, 0xf0, 0xed, 0x56, 0xe2, 0xde, 0xa4, 0x28, 0xfd, 0xba, 0x06, 0xc9, 0x03, + 0x9f, 0x11, 0xfe, 0x06, 0x41, 0xdc, 0xdb, 0x2e, 0xf1, 0xcd, 0x70, 0xbe, 0x81, 0x6d, 0x39, 0x9b, + 0x5f, 0xac, 0x28, 0xc7, 0xd9, 0xeb, 0x5f, 0xfc, 0xf9, 0xd7, 0xb7, 0xb1, 0x6d, 0xe5, 0xc6, 0x68, + 0x0f, 0x97, 0xfd, 0xce, 0x29, 0x7e, 0x36, 0xee, 0x85, 0x9f, 0xef, 0x19, 0x02, 0xb6, 0x87, 0xb6, + 0xf1, 0xf7, 0x08, 0x12, 0xfe, 0x3a, 0x83, 0x5f, 0x99, 0x73, 0x2b, 0x83, 0x3b, 0x64, 0x76, 0x3b, + 0x8a, 0xaa, 0x64, 0x55, 0x12, 0xac, 0x6e, 0x29, 0x37, 0x17, 0xb0, 0xb2, 0x25, 0xd0, 0xe5, 0xf5, + 0x33, 0x82, 0xf4, 0xf4, 0xfe, 0x80, 0x77, 0xc2, 0x9d, 0x86, 0x2c, 0x41, 0xd9, 0xd2, 0x45, 0x20, + 0x92, 0xef, 0x9e, 0xe0, 0xfb, 0x86, 0x52, 0x5c, 0xc0, 0xb7, 0x3b, 0x65, 0xc0, 0xe5, 0xed, 0xd6, + 0xd7, 0x9b, 0x8b, 0xf3, 0xea, 0x1b, 0x58, 0x0e, 0xe6, 0xd5, 0x37, 0x38, 0x62, 0x23, 0xd7, 0xb7, + 0x27, 0x60, 0xa3, 0xfa, 0xca, 0xad, 0x67, 0x6e, 0x7d, 0x83, 0xdb, 0xd6, 0xdc, 0xfa, 0x4e, 0x2f, + 0x51, 0x91, 0xeb, 0x2b, 0x81, 0x2e, 0xaf, 0x1f, 0x10, 0xa4, 0x26, 0x66, 0x29, 0x9e, 0xb3, 0x49, + 0xcd, 0x8e, 0xf6, 0xec, 0x6b, 0x11, 0xb5, 0x25, 0xc1, 0x5d, 0x41, 0xb0, 0xa8, 0x6c, 0x2f, 0x20, + 0xa8, 0x8e, 0xb1, 0x7b, 0x68, 0xbb, 0xf2, 0x1d, 0x82, 0xab, 0x3d, 0x36, 0x08, 0xf5, 0x55, 0xd9, + 0x1c, 0x7d, 0xd7, 0x47, 0xee, 0x8f, 0xee, 0x11, 0xfa, 0xa0, 0x2c, 0x75, 0xfb, 0xcc, 0x50, 0xcd, + 0x7e, 0x81, 0xd9, 0xfd, 0x62, 0x9f, 0x9a, 0xe2, 0x37, 0xb8, 0xe8, 0xbd, 0x52, 0x2d, 0xdd, 0x99, + 0xfd, 0x5f, 0x7e, 0x7b, 0x24, 0xf9, 0x31, 0xf6, 0xc2, 0x7d, 0xcf, 0x46, 0xd5, 0x60, 0x43, 0xad, + 0x30, 0x72, 0x51, 0x78, 0xb4, 0x53, 0x71, 0x55, 0xbb, 0x71, 0x61, 0xee, 0xf6, 0x3f, 0x01, 0x00, + 0x00, 0xff, 0xff, 0xfe, 0xa6, 0x17, 0x82, 0x06, 0x10, 0x00, 0x00, } diff --git a/vendor/google.golang.org/genproto/googleapis/datastore/v1beta3/query.pb.go b/vendor/google.golang.org/genproto/googleapis/datastore/v1beta3/query.pb.go index 35dbbb64..42bc09e9 100644 --- a/vendor/google.golang.org/genproto/googleapis/datastore/v1beta3/query.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/datastore/v1beta3/query.pb.go @@ -160,7 +160,7 @@ const ( // The query is finished, but there may be more results after the end // cursor. QueryResultBatch_MORE_RESULTS_AFTER_CURSOR QueryResultBatch_MoreResultsType = 4 - // The query has been exhausted. + // The query is finished, and there are no more results. QueryResultBatch_NO_MORE_RESULTS QueryResultBatch_MoreResultsType = 3 ) diff --git a/vendor/google.golang.org/genproto/googleapis/devtools/cloudbuild/v1/cloudbuild.pb.go b/vendor/google.golang.org/genproto/googleapis/devtools/cloudbuild/v1/cloudbuild.pb.go index 4534af73..0ec93f0f 100644 --- a/vendor/google.golang.org/genproto/googleapis/devtools/cloudbuild/v1/cloudbuild.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/devtools/cloudbuild/v1/cloudbuild.pb.go @@ -13,12 +13,14 @@ It has these top-level messages: Source BuiltImage BuildStep + Volume Results Build BuildOperationMetadata SourceProvenance FileHashes Hash + Secret CreateBuildRequest GetBuildRequest ListBuildsRequest @@ -106,7 +108,7 @@ var Build_Status_value = map[string]int32{ func (x Build_Status) String() string { return proto.EnumName(Build_Status_name, int32(x)) } -func (Build_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{6, 0} } +func (Build_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{7, 0} } // Specifies the hash algorithm, if any. type Hash_HashType int32 @@ -130,7 +132,7 @@ var Hash_HashType_value = map[string]int32{ func (x Hash_HashType) String() string { return proto.EnumName(Hash_HashType_name, int32(x)) } -func (Hash_HashType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{10, 0} } +func (Hash_HashType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{11, 0} } // Specifies the manner in which the build should be verified, if at all. type BuildOptions_VerifyOption int32 @@ -155,7 +157,7 @@ func (x BuildOptions_VerifyOption) String() string { return proto.EnumName(BuildOptions_VerifyOption_name, int32(x)) } func (BuildOptions_VerifyOption) EnumDescriptor() ([]byte, []int) { - return fileDescriptor0, []int{23, 0} + return fileDescriptor0, []int{25, 0} } // Specifies the behavior when there is an error in the substitution checks. @@ -182,7 +184,7 @@ func (x BuildOptions_SubstitutionOption) String() string { return proto.EnumName(BuildOptions_SubstitutionOption_name, int32(x)) } func (BuildOptions_SubstitutionOption) EnumDescriptor() ([]byte, []int) { - return fileDescriptor0, []int{23, 1} + return fileDescriptor0, []int{25, 1} } // StorageSource describes the location of the source in an archive file in @@ -591,6 +593,18 @@ type BuildStep struct { // Optional entrypoint to be used instead of the build step image's default // If unset, the image's default will be used. Entrypoint string `protobuf:"bytes,7,opt,name=entrypoint" json:"entrypoint,omitempty"` + // A list of environment variables which are encrypted using a Cloud KMS + // crypto key. These values must be specified in the build's secrets. + SecretEnv []string `protobuf:"bytes,8,rep,name=secret_env,json=secretEnv" json:"secret_env,omitempty"` + // List of volumes to mount into the build step. + // + // Each volume will be created as an empty volume prior to execution of the + // build step. Upon completion of the build, volumes and their contents will + // be discarded. + // + // Using a named volume in only one step is not valid as it is indicative + // of a mis-configured build request. + Volumes []*Volume `protobuf:"bytes,9,rep,name=volumes" json:"volumes,omitempty"` } func (m *BuildStep) Reset() { *m = BuildStep{} } @@ -647,6 +661,54 @@ func (m *BuildStep) GetEntrypoint() string { return "" } +func (m *BuildStep) GetSecretEnv() []string { + if m != nil { + return m.SecretEnv + } + return nil +} + +func (m *BuildStep) GetVolumes() []*Volume { + if m != nil { + return m.Volumes + } + return nil +} + +// Volume describes a Docker container volume which is mounted into build steps +// in order to persist files across build step execution. +type Volume struct { + // Name of the volume to mount. + // + // Volume names must be unique per build step and must be valid names for + // Docker volumes. Each named volume must be used by at least two build steps. + Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + // Path at which to mount the volume. + // + // Paths must be absolute and cannot conflict with other volume paths on the + // same build step or with certain reserved volume paths. + Path string `protobuf:"bytes,2,opt,name=path" json:"path,omitempty"` +} + +func (m *Volume) Reset() { *m = Volume{} } +func (m *Volume) String() string { return proto.CompactTextString(m) } +func (*Volume) ProtoMessage() {} +func (*Volume) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } + +func (m *Volume) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *Volume) GetPath() string { + if m != nil { + return m.Path + } + return "" +} + // Results describes the artifacts created by the build pipeline. type Results struct { // Images that were built as a part of the build. @@ -658,7 +720,7 @@ type Results struct { func (m *Results) Reset() { *m = Results{} } func (m *Results) String() string { return proto.CompactTextString(m) } func (*Results) ProtoMessage() {} -func (*Results) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } +func (*Results) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } func (m *Results) GetImages() []*BuiltImage { if m != nil { @@ -759,12 +821,14 @@ type Build struct { Substitutions map[string]string `protobuf:"bytes,29,rep,name=substitutions" json:"substitutions,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` // Tags for annotation of a Build. These are not docker tags. Tags []string `protobuf:"bytes,31,rep,name=tags" json:"tags,omitempty"` + // Secrets to decrypt using Cloud KMS. + Secrets []*Secret `protobuf:"bytes,32,rep,name=secrets" json:"secrets,omitempty"` } func (m *Build) Reset() { *m = Build{} } func (m *Build) String() string { return proto.CompactTextString(m) } func (*Build) ProtoMessage() {} -func (*Build) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } +func (*Build) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } func (m *Build) GetId() string { if m != nil { @@ -899,6 +963,13 @@ func (m *Build) GetTags() []string { return nil } +func (m *Build) GetSecrets() []*Secret { + if m != nil { + return m.Secrets + } + return nil +} + // Metadata for build operations. type BuildOperationMetadata struct { // The build that the operation is tracking. @@ -908,7 +979,7 @@ type BuildOperationMetadata struct { func (m *BuildOperationMetadata) Reset() { *m = BuildOperationMetadata{} } func (m *BuildOperationMetadata) String() string { return proto.CompactTextString(m) } func (*BuildOperationMetadata) ProtoMessage() {} -func (*BuildOperationMetadata) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } +func (*BuildOperationMetadata) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } func (m *BuildOperationMetadata) GetBuild() *Build { if m != nil { @@ -942,7 +1013,7 @@ type SourceProvenance struct { func (m *SourceProvenance) Reset() { *m = SourceProvenance{} } func (m *SourceProvenance) String() string { return proto.CompactTextString(m) } func (*SourceProvenance) ProtoMessage() {} -func (*SourceProvenance) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } +func (*SourceProvenance) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } func (m *SourceProvenance) GetResolvedStorageSource() *StorageSource { if m != nil { @@ -975,7 +1046,7 @@ type FileHashes struct { func (m *FileHashes) Reset() { *m = FileHashes{} } func (m *FileHashes) String() string { return proto.CompactTextString(m) } func (*FileHashes) ProtoMessage() {} -func (*FileHashes) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } +func (*FileHashes) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } func (m *FileHashes) GetFileHash() []*Hash { if m != nil { @@ -995,7 +1066,7 @@ type Hash struct { func (m *Hash) Reset() { *m = Hash{} } func (m *Hash) String() string { return proto.CompactTextString(m) } func (*Hash) ProtoMessage() {} -func (*Hash) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } +func (*Hash) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } func (m *Hash) GetType() Hash_HashType { if m != nil { @@ -1011,6 +1082,39 @@ func (m *Hash) GetValue() []byte { return nil } +// Secret pairs a set of secret environment variables containing encrypted +// values with the Cloud KMS key to use to decrypt the value. +type Secret struct { + // Cloud KMS key name to use to decrypt these envs. + KmsKeyName string `protobuf:"bytes,1,opt,name=kms_key_name,json=kmsKeyName" json:"kms_key_name,omitempty"` + // Map of environment variable name to its encrypted value. + // + // Secret environment variables must be unique across all of a build's + // secrets, and must be used by at least one build step. Values can be at most + // 1 KB in size. There can be at most ten secret values across all of a + // build's secrets. + SecretEnv map[string][]byte `protobuf:"bytes,3,rep,name=secret_env,json=secretEnv" json:"secret_env,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (m *Secret) Reset() { *m = Secret{} } +func (m *Secret) String() string { return proto.CompactTextString(m) } +func (*Secret) ProtoMessage() {} +func (*Secret) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } + +func (m *Secret) GetKmsKeyName() string { + if m != nil { + return m.KmsKeyName + } + return "" +} + +func (m *Secret) GetSecretEnv() map[string][]byte { + if m != nil { + return m.SecretEnv + } + return nil +} + // Request to create a new build. type CreateBuildRequest struct { // ID of the project. @@ -1022,7 +1126,7 @@ type CreateBuildRequest struct { func (m *CreateBuildRequest) Reset() { *m = CreateBuildRequest{} } func (m *CreateBuildRequest) String() string { return proto.CompactTextString(m) } func (*CreateBuildRequest) ProtoMessage() {} -func (*CreateBuildRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } +func (*CreateBuildRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } func (m *CreateBuildRequest) GetProjectId() string { if m != nil { @@ -1049,7 +1153,7 @@ type GetBuildRequest struct { func (m *GetBuildRequest) Reset() { *m = GetBuildRequest{} } func (m *GetBuildRequest) String() string { return proto.CompactTextString(m) } func (*GetBuildRequest) ProtoMessage() {} -func (*GetBuildRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } +func (*GetBuildRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} } func (m *GetBuildRequest) GetProjectId() string { if m != nil { @@ -1080,7 +1184,7 @@ type ListBuildsRequest struct { func (m *ListBuildsRequest) Reset() { *m = ListBuildsRequest{} } func (m *ListBuildsRequest) String() string { return proto.CompactTextString(m) } func (*ListBuildsRequest) ProtoMessage() {} -func (*ListBuildsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } +func (*ListBuildsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } func (m *ListBuildsRequest) GetProjectId() string { if m != nil { @@ -1121,7 +1225,7 @@ type ListBuildsResponse struct { func (m *ListBuildsResponse) Reset() { *m = ListBuildsResponse{} } func (m *ListBuildsResponse) String() string { return proto.CompactTextString(m) } func (*ListBuildsResponse) ProtoMessage() {} -func (*ListBuildsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} } +func (*ListBuildsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } func (m *ListBuildsResponse) GetBuilds() []*Build { if m != nil { @@ -1148,7 +1252,7 @@ type CancelBuildRequest struct { func (m *CancelBuildRequest) Reset() { *m = CancelBuildRequest{} } func (m *CancelBuildRequest) String() string { return proto.CompactTextString(m) } func (*CancelBuildRequest) ProtoMessage() {} -func (*CancelBuildRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } +func (*CancelBuildRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } func (m *CancelBuildRequest) GetProjectId() string { if m != nil { @@ -1198,7 +1302,7 @@ type BuildTrigger struct { func (m *BuildTrigger) Reset() { *m = BuildTrigger{} } func (m *BuildTrigger) String() string { return proto.CompactTextString(m) } func (*BuildTrigger) ProtoMessage() {} -func (*BuildTrigger) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } +func (*BuildTrigger) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } type isBuildTrigger_BuildTemplate interface { isBuildTrigger_BuildTemplate() @@ -1358,7 +1462,7 @@ type CreateBuildTriggerRequest struct { func (m *CreateBuildTriggerRequest) Reset() { *m = CreateBuildTriggerRequest{} } func (m *CreateBuildTriggerRequest) String() string { return proto.CompactTextString(m) } func (*CreateBuildTriggerRequest) ProtoMessage() {} -func (*CreateBuildTriggerRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } +func (*CreateBuildTriggerRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } func (m *CreateBuildTriggerRequest) GetProjectId() string { if m != nil { @@ -1385,7 +1489,7 @@ type GetBuildTriggerRequest struct { func (m *GetBuildTriggerRequest) Reset() { *m = GetBuildTriggerRequest{} } func (m *GetBuildTriggerRequest) String() string { return proto.CompactTextString(m) } func (*GetBuildTriggerRequest) ProtoMessage() {} -func (*GetBuildTriggerRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } +func (*GetBuildTriggerRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} } func (m *GetBuildTriggerRequest) GetProjectId() string { if m != nil { @@ -1410,7 +1514,7 @@ type ListBuildTriggersRequest struct { func (m *ListBuildTriggersRequest) Reset() { *m = ListBuildTriggersRequest{} } func (m *ListBuildTriggersRequest) String() string { return proto.CompactTextString(m) } func (*ListBuildTriggersRequest) ProtoMessage() {} -func (*ListBuildTriggersRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } +func (*ListBuildTriggersRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} } func (m *ListBuildTriggersRequest) GetProjectId() string { if m != nil { @@ -1428,7 +1532,7 @@ type ListBuildTriggersResponse struct { func (m *ListBuildTriggersResponse) Reset() { *m = ListBuildTriggersResponse{} } func (m *ListBuildTriggersResponse) String() string { return proto.CompactTextString(m) } func (*ListBuildTriggersResponse) ProtoMessage() {} -func (*ListBuildTriggersResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} } +func (*ListBuildTriggersResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} } func (m *ListBuildTriggersResponse) GetTriggers() []*BuildTrigger { if m != nil { @@ -1448,7 +1552,7 @@ type DeleteBuildTriggerRequest struct { func (m *DeleteBuildTriggerRequest) Reset() { *m = DeleteBuildTriggerRequest{} } func (m *DeleteBuildTriggerRequest) String() string { return proto.CompactTextString(m) } func (*DeleteBuildTriggerRequest) ProtoMessage() {} -func (*DeleteBuildTriggerRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} } +func (*DeleteBuildTriggerRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} } func (m *DeleteBuildTriggerRequest) GetProjectId() string { if m != nil { @@ -1477,7 +1581,7 @@ type UpdateBuildTriggerRequest struct { func (m *UpdateBuildTriggerRequest) Reset() { *m = UpdateBuildTriggerRequest{} } func (m *UpdateBuildTriggerRequest) String() string { return proto.CompactTextString(m) } func (*UpdateBuildTriggerRequest) ProtoMessage() {} -func (*UpdateBuildTriggerRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} } +func (*UpdateBuildTriggerRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} } func (m *UpdateBuildTriggerRequest) GetProjectId() string { if m != nil { @@ -1513,7 +1617,7 @@ type BuildOptions struct { func (m *BuildOptions) Reset() { *m = BuildOptions{} } func (m *BuildOptions) String() string { return proto.CompactTextString(m) } func (*BuildOptions) ProtoMessage() {} -func (*BuildOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} } +func (*BuildOptions) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} } func (m *BuildOptions) GetSourceProvenanceHash() []Hash_HashType { if m != nil { @@ -1542,12 +1646,14 @@ func init() { proto.RegisterType((*Source)(nil), "google.devtools.cloudbuild.v1.Source") proto.RegisterType((*BuiltImage)(nil), "google.devtools.cloudbuild.v1.BuiltImage") proto.RegisterType((*BuildStep)(nil), "google.devtools.cloudbuild.v1.BuildStep") + proto.RegisterType((*Volume)(nil), "google.devtools.cloudbuild.v1.Volume") proto.RegisterType((*Results)(nil), "google.devtools.cloudbuild.v1.Results") proto.RegisterType((*Build)(nil), "google.devtools.cloudbuild.v1.Build") proto.RegisterType((*BuildOperationMetadata)(nil), "google.devtools.cloudbuild.v1.BuildOperationMetadata") proto.RegisterType((*SourceProvenance)(nil), "google.devtools.cloudbuild.v1.SourceProvenance") proto.RegisterType((*FileHashes)(nil), "google.devtools.cloudbuild.v1.FileHashes") proto.RegisterType((*Hash)(nil), "google.devtools.cloudbuild.v1.Hash") + proto.RegisterType((*Secret)(nil), "google.devtools.cloudbuild.v1.Secret") proto.RegisterType((*CreateBuildRequest)(nil), "google.devtools.cloudbuild.v1.CreateBuildRequest") proto.RegisterType((*GetBuildRequest)(nil), "google.devtools.cloudbuild.v1.GetBuildRequest") proto.RegisterType((*ListBuildsRequest)(nil), "google.devtools.cloudbuild.v1.ListBuildsRequest") @@ -1964,135 +2070,144 @@ var _CloudBuild_serviceDesc = grpc.ServiceDesc{ func init() { proto.RegisterFile("google/devtools/cloudbuild/v1/cloudbuild.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ - // 2077 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x59, 0x5b, 0x6f, 0xdb, 0xd8, - 0x11, 0x36, 0x25, 0x59, 0x97, 0x91, 0x2f, 0xcc, 0xd9, 0xac, 0x43, 0x2b, 0xeb, 0x8d, 0xcb, 0xec, - 0x6e, 0xbd, 0xd9, 0x5d, 0xa9, 0x76, 0x90, 0xc6, 0xeb, 0x6c, 0xb3, 0xb6, 0x65, 0xc5, 0x36, 0xd6, - 0x91, 0x52, 0x4a, 0x4a, 0xd0, 0x1b, 0x58, 0x4a, 0x3c, 0xa6, 0xd9, 0x50, 0x24, 0x4b, 0x1e, 0xa9, - 0x71, 0x82, 0xa0, 0x17, 0xa0, 0x7d, 0x6d, 0x81, 0x3e, 0xf6, 0xa1, 0x6d, 0x7e, 0x40, 0x51, 0x14, - 0x28, 0xfa, 0xd2, 0xfe, 0x8a, 0xfe, 0x85, 0x3e, 0xf6, 0x47, 0x14, 0xe7, 0x42, 0x89, 0x92, 0x92, - 0x52, 0x6a, 0xd0, 0x97, 0x80, 0x67, 0xce, 0x7c, 0x33, 0x73, 0xe6, 0xcc, 0x99, 0xf9, 0x14, 0x43, - 0xd9, 0xf2, 0x3c, 0xcb, 0xc1, 0x15, 0x13, 0x0f, 0x88, 0xe7, 0x39, 0x61, 0xa5, 0xeb, 0x78, 0x7d, - 0xb3, 0xd3, 0xb7, 0x1d, 0xb3, 0x32, 0xd8, 0x8e, 0xad, 0xca, 0x7e, 0xe0, 0x11, 0x0f, 0x6d, 0x70, - 0xfd, 0x72, 0xa4, 0x5f, 0x8e, 0x69, 0x0c, 0xb6, 0x4b, 0xef, 0x09, 0x73, 0x86, 0x6f, 0x57, 0x0c, - 0xd7, 0xf5, 0x88, 0x41, 0x6c, 0xcf, 0x0d, 0x39, 0xb8, 0x74, 0x53, 0xec, 0x3a, 0x9e, 0x6b, 0x05, - 0x7d, 0xd7, 0xb5, 0x5d, 0xab, 0xe2, 0xf9, 0x38, 0x18, 0x53, 0x7a, 0x5f, 0x28, 0xb1, 0x55, 0xa7, - 0x7f, 0x5e, 0x31, 0xfb, 0x5c, 0x41, 0xec, 0x5f, 0x9f, 0xdc, 0xc7, 0x3d, 0x9f, 0x5c, 0x8a, 0xcd, - 0x1b, 0x93, 0x9b, 0xc4, 0xee, 0xe1, 0x90, 0x18, 0x3d, 0x9f, 0x2b, 0xa8, 0x3a, 0x2c, 0x37, 0x89, - 0x17, 0x18, 0x16, 0x6e, 0x7a, 0xfd, 0xa0, 0x8b, 0xd1, 0x1a, 0x64, 0x3b, 0xfd, 0xee, 0x53, 0x4c, - 0x14, 0x69, 0x53, 0xda, 0x2a, 0x68, 0x62, 0x45, 0xe5, 0x5e, 0xe7, 0x47, 0xb8, 0x4b, 0x94, 0x14, - 0x97, 0xf3, 0x15, 0x7a, 0x1f, 0xc0, 0xc2, 0xae, 0x88, 0x59, 0x49, 0x6f, 0x4a, 0x5b, 0x69, 0x2d, - 0x26, 0x51, 0xff, 0x2a, 0x01, 0x68, 0xd8, 0xf7, 0x84, 0xf9, 0x0d, 0x00, 0x3f, 0xf0, 0x28, 0x52, - 0xb7, 0x4d, 0xe1, 0xa2, 0x20, 0x24, 0xa7, 0x26, 0xba, 0x0e, 0x85, 0x00, 0xfb, 0x9e, 0xee, 0x1a, - 0x3d, 0x2c, 0x1c, 0xe5, 0xa9, 0xa0, 0x6e, 0xf4, 0x30, 0xfa, 0x1a, 0x14, 0x3b, 0x81, 0xe1, 0x76, - 0x2f, 0xf8, 0x36, 0xf5, 0x55, 0x38, 0x59, 0xd0, 0x80, 0x0b, 0x99, 0xca, 0x75, 0xc8, 0x13, 0xc3, - 0xe2, 0xfb, 0x19, 0xb1, 0x9f, 0x23, 0x86, 0xc5, 0x36, 0x6f, 0x00, 0x74, 0xbd, 0x5e, 0xcf, 0x26, - 0x7a, 0x78, 0x61, 0x28, 0x8b, 0x62, 0xbb, 0xc0, 0x65, 0xcd, 0x0b, 0xe3, 0x10, 0x20, 0x1f, 0xe0, - 0x81, 0x1d, 0xd2, 0xb8, 0xff, 0x26, 0x41, 0x56, 0xc4, 0xdc, 0x86, 0x95, 0x90, 0xe7, 0x48, 0x0f, - 0x99, 0x84, 0x45, 0x56, 0xdc, 0xf9, 0xb4, 0xfc, 0x5f, 0x2f, 0xbf, 0x3c, 0x96, 0xd8, 0x93, 0x05, - 0x6d, 0x39, 0x1c, 0xcb, 0xf4, 0x19, 0x14, 0xd9, 0x59, 0x85, 0xcd, 0x34, 0xb3, 0xf9, 0x71, 0x82, - 0xcd, 0x51, 0x2a, 0xe9, 0xc9, 0x83, 0xe1, 0xea, 0x30, 0x0f, 0x59, 0x6e, 0x48, 0xdd, 0x05, 0x38, - 0xec, 0xdb, 0x0e, 0x39, 0xed, 0x19, 0x16, 0x46, 0x08, 0x32, 0x2c, 0x1b, 0x3c, 0xd5, 0xec, 0x9b, - 0xde, 0xa5, 0x69, 0x5b, 0x38, 0x24, 0x3c, 0x87, 0x9a, 0x58, 0xa9, 0xaf, 0x24, 0x28, 0x50, 0xa8, - 0xd9, 0x24, 0xd8, 0x7f, 0x2d, 0x52, 0x86, 0x34, 0x76, 0x07, 0x4a, 0x6a, 0x33, 0xbd, 0x55, 0xd0, - 0xe8, 0x27, 0xd5, 0x32, 0x02, 0x2b, 0x54, 0xd2, 0x4c, 0xc4, 0xbe, 0xa9, 0x96, 0x69, 0x07, 0xfc, - 0x02, 0x34, 0xfa, 0x89, 0x56, 0x20, 0x65, 0x9b, 0x3c, 0xe5, 0x5a, 0xca, 0x36, 0xd1, 0x3a, 0xe4, - 0x7f, 0x62, 0xd8, 0x44, 0x3f, 0xf7, 0x02, 0x25, 0xcb, 0x90, 0x39, 0xba, 0x7e, 0xe0, 0x05, 0xb4, - 0xa0, 0xb0, 0x4b, 0x82, 0x4b, 0xdf, 0xb3, 0x5d, 0xa2, 0xe4, 0x18, 0x24, 0x26, 0x51, 0x9f, 0x41, - 0x4e, 0xc3, 0x61, 0xdf, 0x21, 0x21, 0x3a, 0x80, 0xac, 0x4d, 0x0f, 0x19, 0xb2, 0x80, 0x92, 0x93, - 0x37, 0x4a, 0x8b, 0x26, 0x80, 0xe8, 0x16, 0x5c, 0x61, 0xdb, 0x7a, 0x48, 0xb0, 0xaf, 0x0b, 0x6b, - 0xfc, 0x2c, 0xab, 0x9d, 0x28, 0x15, 0x0c, 0x12, 0xaa, 0xaf, 0x0a, 0xb0, 0xc8, 0xd2, 0x23, 0x8e, - 0x23, 0x0d, 0x8f, 0x33, 0x5e, 0xd5, 0xf2, 0x64, 0x55, 0x57, 0x21, 0x1b, 0x12, 0x83, 0xf4, 0x43, - 0x56, 0x38, 0x2b, 0x3b, 0x9f, 0xcc, 0x10, 0xa7, 0x59, 0x6e, 0x32, 0x88, 0x26, 0xa0, 0xe8, 0x26, - 0x2c, 0xf3, 0x2f, 0xdd, 0xc4, 0xc4, 0xb0, 0x1d, 0x45, 0x61, 0x6e, 0x96, 0xb8, 0xf0, 0x88, 0xc9, - 0xd0, 0xb7, 0xa2, 0x2a, 0x10, 0xe5, 0xf4, 0x61, 0x52, 0x89, 0x32, 0x65, 0x4d, 0x80, 0xd0, 0x7d, - 0x58, 0xa4, 0x79, 0x08, 0x95, 0x22, 0xcb, 0xe7, 0xd6, 0x2c, 0x71, 0xd2, 0x04, 0x69, 0x1c, 0x86, - 0xf6, 0x21, 0x17, 0xf0, 0xbb, 0x51, 0x80, 0xf9, 0xff, 0x28, 0xb1, 0x9c, 0x99, 0xb6, 0x16, 0xc1, - 0xd0, 0x3d, 0x28, 0x76, 0x03, 0x6c, 0x10, 0xac, 0xd3, 0x4e, 0xa5, 0x64, 0x99, 0x95, 0x52, 0x64, - 0x25, 0x6a, 0x63, 0xe5, 0x56, 0xd4, 0xc6, 0x34, 0xe0, 0xea, 0x54, 0x80, 0x3e, 0x07, 0x08, 0x89, - 0x11, 0x10, 0x8e, 0xcd, 0x25, 0x62, 0x0b, 0x4c, 0x9b, 0x41, 0xef, 0x41, 0xf1, 0xdc, 0x76, 0xed, - 0xf0, 0x82, 0x63, 0xf3, 0xc9, 0x7e, 0xb9, 0x3a, 0x03, 0xdf, 0x86, 0x1c, 0x45, 0x79, 0x7d, 0xa2, - 0x2c, 0x31, 0xe0, 0xfa, 0x14, 0xf0, 0x48, 0x34, 0x6d, 0x2d, 0xd2, 0xa4, 0x8f, 0x50, 0x94, 0xdb, - 0x32, 0x2b, 0xb7, 0xa8, 0x22, 0x6f, 0x40, 0xd1, 0xf1, 0xac, 0x50, 0x17, 0x5d, 0xf8, 0x1d, 0xfe, - 0x00, 0xa8, 0xe8, 0x90, 0x77, 0xe2, 0xef, 0xc3, 0x15, 0x7e, 0x5d, 0xba, 0x1f, 0x78, 0x03, 0xec, - 0x1a, 0x6e, 0x17, 0x2b, 0xef, 0x32, 0xbf, 0x95, 0x99, 0xae, 0xfb, 0xd1, 0x10, 0xa6, 0xc9, 0xe1, - 0x84, 0x04, 0x6d, 0x81, 0xcc, 0x1f, 0x04, 0x09, 0x6c, 0xcb, 0xc2, 0x01, 0x2d, 0xe8, 0x35, 0x16, - 0xc3, 0x0a, 0x93, 0xb7, 0xb8, 0xf8, 0xd4, 0x44, 0x35, 0xc8, 0x79, 0x3e, 0x9b, 0x54, 0xca, 0x35, - 0xe6, 0x7d, 0xa6, 0xb2, 0x6e, 0x70, 0x88, 0x16, 0x61, 0xd1, 0x35, 0xc8, 0x39, 0x9e, 0xa5, 0xf7, - 0x03, 0x47, 0x59, 0xe7, 0xdd, 0xc8, 0xf1, 0xac, 0x76, 0xe0, 0xa0, 0x1f, 0xc0, 0x72, 0xd8, 0xef, - 0x84, 0xc4, 0x26, 0x7d, 0xee, 0x65, 0x83, 0x15, 0xe5, 0xdd, 0xd9, 0x1e, 0x4f, 0x1c, 0x59, 0xa3, - 0xdd, 0x43, 0x1b, 0xb7, 0x46, 0x1b, 0x17, 0x31, 0xac, 0x50, 0xb9, 0xc1, 0x1b, 0x17, 0xfd, 0x2e, - 0xed, 0x03, 0x9a, 0x06, 0xd2, 0x76, 0xf6, 0x14, 0x5f, 0x8a, 0xe7, 0x4e, 0x3f, 0xd1, 0x55, 0x58, - 0x1c, 0x18, 0x4e, 0x3f, 0x1a, 0x51, 0x7c, 0xb1, 0x97, 0xda, 0x95, 0xd4, 0x9f, 0x42, 0x96, 0xbf, - 0x5b, 0x84, 0x60, 0xa5, 0xd9, 0x3a, 0x68, 0xb5, 0x9b, 0x7a, 0xbb, 0xfe, 0x55, 0xbd, 0xf1, 0xa4, - 0x2e, 0x2f, 0x20, 0x80, 0xec, 0xb7, 0xdb, 0xb5, 0x76, 0xed, 0x48, 0x96, 0x50, 0x11, 0x72, 0x4f, - 0x1a, 0xda, 0x57, 0xa7, 0xf5, 0x63, 0x39, 0x45, 0x17, 0xcd, 0x76, 0xb5, 0x5a, 0x6b, 0x36, 0xe5, - 0x34, 0x5d, 0x3c, 0x38, 0x38, 0x3d, 0x6b, 0x6b, 0x35, 0x39, 0x43, 0xcd, 0x9c, 0xd6, 0x5b, 0x35, - 0xad, 0x7e, 0x70, 0xa6, 0xd7, 0x34, 0xad, 0xa1, 0xc9, 0x8b, 0x54, 0xa1, 0x75, 0xfa, 0xb0, 0xd6, - 0x68, 0xb7, 0xe4, 0x2c, 0x5a, 0x86, 0x42, 0xf5, 0xa0, 0x5e, 0xad, 0x9d, 0x9d, 0xd5, 0x8e, 0xe4, - 0x9c, 0xda, 0x82, 0x35, 0x91, 0x67, 0x31, 0x81, 0x1f, 0x62, 0x62, 0x98, 0x06, 0x31, 0xd0, 0x1e, - 0x2c, 0xb2, 0x24, 0xb1, 0x83, 0x14, 0x77, 0x3e, 0x98, 0x25, 0x8f, 0x1a, 0x87, 0xa8, 0x7f, 0x4c, - 0x83, 0x3c, 0x59, 0x3c, 0xc8, 0x84, 0x6b, 0x01, 0x0e, 0x3d, 0x67, 0x80, 0x69, 0xfb, 0x1c, 0x1b, - 0x90, 0xe9, 0xf9, 0x07, 0xa4, 0xf6, 0x6e, 0x64, 0x6c, 0x9c, 0x90, 0x7c, 0x0f, 0xae, 0x0e, 0xbd, - 0xc4, 0xe7, 0x65, 0x76, 0xce, 0x79, 0xa9, 0xa1, 0xc8, 0x4c, 0x8c, 0x8e, 0xfc, 0x90, 0x3e, 0x7b, - 0x07, 0xeb, 0x17, 0x46, 0x78, 0x81, 0x43, 0x25, 0xc3, 0x2a, 0xec, 0xcb, 0x39, 0x5f, 0x51, 0xf9, - 0x81, 0xed, 0xe0, 0x13, 0x66, 0x81, 0x57, 0x1a, 0x9c, 0x0f, 0x05, 0xa5, 0x0b, 0x58, 0x9d, 0xd8, - 0x7e, 0x4d, 0x3d, 0x7d, 0x19, 0xaf, 0xa7, 0xe4, 0x43, 0x8d, 0x0c, 0xc6, 0x4b, 0xaf, 0x0e, 0x30, - 0xda, 0x40, 0xfb, 0x50, 0x18, 0x9e, 0x4c, 0x91, 0xd8, 0xb9, 0x6e, 0x26, 0x98, 0xa5, 0x48, 0x2d, - 0x1f, 0xc5, 0xae, 0xfe, 0x4c, 0x82, 0x0c, 0xfd, 0x40, 0xfb, 0x90, 0x21, 0x97, 0x3e, 0x27, 0x02, - 0x2b, 0x89, 0x97, 0x4a, 0x21, 0xec, 0x9f, 0xd6, 0xa5, 0x8f, 0x35, 0x86, 0x1c, 0x7f, 0x2f, 0x4b, - 0x22, 0x68, 0x75, 0x13, 0xf2, 0x91, 0x1e, 0xca, 0x43, 0xa6, 0xde, 0xa8, 0xd7, 0xf8, 0x1b, 0x69, - 0x9e, 0x1c, 0xec, 0xdc, 0xf9, 0xa6, 0x2c, 0xa9, 0x1e, 0xa0, 0x2a, 0x6b, 0xef, 0xbc, 0x18, 0xf1, - 0x8f, 0xfb, 0x38, 0x24, 0x49, 0x1c, 0x72, 0x58, 0xe7, 0xa9, 0xf9, 0xeb, 0x7c, 0x1f, 0x56, 0x8f, - 0x31, 0x99, 0xc7, 0x1b, 0xa7, 0x02, 0xa9, 0x88, 0x0a, 0xa8, 0xbf, 0x92, 0xe0, 0xca, 0x99, 0x1d, - 0x72, 0x1b, 0xe1, 0x8c, 0x46, 0xae, 0x43, 0xc1, 0x67, 0xaf, 0xc7, 0x7e, 0xce, 0x73, 0xb4, 0xa8, - 0xe5, 0xa9, 0xa0, 0x69, 0x3f, 0xe7, 0x94, 0x99, 0x6e, 0x12, 0xef, 0x29, 0x76, 0x05, 0x63, 0x63, - 0xea, 0x2d, 0x2a, 0xa0, 0x73, 0xe4, 0xdc, 0x76, 0x08, 0x0e, 0xd8, 0xd0, 0x2a, 0x68, 0x62, 0xa5, - 0x3e, 0x07, 0x14, 0x8f, 0x23, 0xf4, 0x3d, 0x37, 0xc4, 0xe8, 0x0b, 0x4a, 0xef, 0xa9, 0x44, 0xd4, - 0xc4, 0x6c, 0xd9, 0x11, 0x18, 0xf4, 0x11, 0xac, 0xba, 0xf8, 0x19, 0xd1, 0x63, 0xf1, 0xf0, 0x93, - 0x2f, 0x53, 0xf1, 0xa3, 0x28, 0x26, 0xb5, 0x0a, 0xa8, 0x4a, 0x5f, 0x86, 0xf3, 0x36, 0x99, 0xfc, - 0x65, 0x06, 0x96, 0x0e, 0x63, 0x23, 0x67, 0x8a, 0x75, 0x6d, 0x42, 0xd1, 0xc4, 0x61, 0x37, 0xb0, - 0xd9, 0x24, 0x61, 0x8c, 0xa3, 0xa0, 0xc5, 0x45, 0xa8, 0x05, 0x72, 0x34, 0xc6, 0x08, 0xee, 0xf9, - 0x8e, 0x41, 0x22, 0x5a, 0x30, 0x47, 0xdf, 0x58, 0x15, 0x26, 0x5a, 0xc2, 0x02, 0xfa, 0x22, 0x2a, - 0xb0, 0xcc, 0xec, 0x05, 0x76, 0xb2, 0x20, 0x4a, 0x0c, 0xbd, 0x07, 0xec, 0x89, 0x31, 0x6a, 0x9d, - 0x17, 0xbf, 0x41, 0x86, 0x92, 0x49, 0xfe, 0xb3, 0x38, 0x17, 0xff, 0x29, 0x41, 0xde, 0xb4, 0x43, - 0xa3, 0xe3, 0x60, 0x53, 0x29, 0x6c, 0x4a, 0x5b, 0x79, 0x6d, 0xb8, 0x46, 0xe6, 0xe4, 0x34, 0xe5, - 0x14, 0xef, 0xfe, 0x2c, 0xc1, 0x8b, 0x0b, 0x48, 0x1e, 0xaa, 0x6f, 0x3f, 0x40, 0x0f, 0x65, 0x58, - 0x11, 0xfc, 0x43, 0xa4, 0x5b, 0xfd, 0xb9, 0x04, 0xeb, 0xb1, 0x2e, 0x20, 0x82, 0x99, 0xb1, 0xa8, - 0x6a, 0x90, 0x13, 0xd7, 0x27, 0xda, 0xc1, 0x27, 0x73, 0x1c, 0x58, 0x8b, 0xb0, 0xea, 0x63, 0x58, - 0x8b, 0xfa, 0xc2, 0x7c, 0xfe, 0x37, 0x00, 0x62, 0x44, 0x8a, 0x9f, 0xb6, 0x40, 0x22, 0x0e, 0xa5, - 0x7e, 0x0e, 0xca, 0xf0, 0x91, 0x0a, 0xc3, 0x33, 0xf6, 0x0c, 0xd5, 0x84, 0xf5, 0xd7, 0x40, 0xc5, - 0x33, 0x3f, 0x86, 0xbc, 0x70, 0x12, 0x3d, 0xf4, 0xb9, 0xce, 0x3d, 0x04, 0xab, 0xdf, 0x81, 0xf5, - 0x23, 0xec, 0xe0, 0xff, 0x29, 0xf7, 0x09, 0x67, 0xff, 0x83, 0x04, 0xeb, 0x6d, 0xdf, 0x34, 0xfe, - 0x0f, 0xb6, 0xe3, 0xd7, 0x9e, 0x7e, 0x8b, 0x6b, 0xff, 0x7b, 0x5a, 0xb4, 0x20, 0xc1, 0x5a, 0x51, - 0x07, 0xd6, 0xa6, 0xb8, 0xf7, 0x68, 0xc4, 0xce, 0x3b, 0x1c, 0xaf, 0x4e, 0xb2, 0x6f, 0x36, 0x6e, - 0x7d, 0x4a, 0xab, 0x58, 0x12, 0xb0, 0xa9, 0x0f, 0x70, 0x60, 0x9f, 0x5f, 0xea, 0x9c, 0x2c, 0x8b, - 0x9f, 0x8f, 0xbb, 0x73, 0xf0, 0xec, 0xf2, 0x63, 0x66, 0x80, 0xaf, 0x28, 0xc5, 0x12, 0x86, 0xe3, - 0x62, 0xe4, 0xc1, 0x3b, 0xf1, 0x67, 0x1c, 0x79, 0xcb, 0x30, 0x6f, 0xf7, 0xe7, 0xf1, 0x16, 0x7f, - 0xfc, 0xc2, 0x27, 0x0a, 0xa7, 0x64, 0x6a, 0x19, 0x96, 0xc6, 0x02, 0x90, 0x61, 0xa9, 0xde, 0x68, - 0xe9, 0x8f, 0x6b, 0xda, 0xe9, 0x83, 0xd3, 0xda, 0x91, 0xbc, 0x80, 0x96, 0x20, 0x3f, 0x5c, 0x49, - 0xea, 0x9d, 0xf1, 0xb6, 0x22, 0x50, 0x2b, 0x00, 0x0f, 0xdb, 0xcd, 0x96, 0xfe, 0xf0, 0xa0, 0x55, - 0x3d, 0x91, 0x17, 0xd0, 0x2a, 0x14, 0x0f, 0xce, 0xce, 0x1a, 0x4f, 0xf4, 0xb3, 0x46, 0xa3, 0x59, - 0x93, 0xa5, 0x9d, 0x7f, 0x17, 0x01, 0xaa, 0x34, 0x58, 0xfe, 0xab, 0xfd, 0x37, 0x12, 0x14, 0x63, - 0x8d, 0x04, 0x6d, 0x27, 0x9c, 0x6c, 0x9a, 0x7a, 0x94, 0x36, 0x22, 0x48, 0xec, 0xbf, 0xec, 0xca, - 0x43, 0xaa, 0xad, 0x56, 0x7e, 0xf1, 0xcf, 0x7f, 0xfd, 0x36, 0xf5, 0xb1, 0xba, 0x59, 0x19, 0x6c, - 0x57, 0x44, 0xb1, 0x86, 0x95, 0x17, 0xa3, 0x42, 0x7e, 0x59, 0xe1, 0x93, 0x74, 0x4f, 0x0c, 0x83, - 0x5f, 0x4b, 0x90, 0x8f, 0x1a, 0x0b, 0x2a, 0x27, 0xc4, 0x33, 0xc1, 0x4c, 0x4a, 0x33, 0x0d, 0x1e, - 0xf5, 0x33, 0x16, 0xd3, 0xd7, 0xd1, 0x87, 0x49, 0x31, 0x55, 0x5e, 0xd8, 0xe6, 0x4b, 0xf4, 0x3b, - 0x09, 0x60, 0xc4, 0x1b, 0xd0, 0x37, 0x12, 0x7c, 0x4c, 0x51, 0x9d, 0xd2, 0xf6, 0x1c, 0x08, 0xde, - 0xad, 0xd4, 0x2d, 0x16, 0xa2, 0x8a, 0x12, 0xd3, 0x86, 0x7e, 0x4f, 0xaf, 0x70, 0xc4, 0x2c, 0x92, - 0xaf, 0x70, 0x8a, 0x85, 0xcc, 0x98, 0xb5, 0xbb, 0x2c, 0xa4, 0x6d, 0xf5, 0xd3, 0x99, 0xb2, 0xb6, - 0xd7, 0x65, 0x7e, 0xf6, 0xa4, 0x5b, 0xe8, 0xcf, 0xd2, 0x18, 0x67, 0x8d, 0xb8, 0xcb, 0xee, 0xec, - 0xb5, 0x36, 0xde, 0x08, 0x4b, 0xf3, 0x74, 0x2e, 0xf5, 0x36, 0x0b, 0xfb, 0x33, 0x55, 0x7d, 0x73, - 0xd8, 0x51, 0x6b, 0xdf, 0x8b, 0xba, 0x1c, 0xfa, 0x93, 0x34, 0x62, 0xbd, 0x51, 0xbc, 0x77, 0x66, - 0xac, 0xc5, 0xb7, 0x09, 0x56, 0xe4, 0x18, 0x55, 0x92, 0x83, 0xad, 0xbc, 0x18, 0x75, 0xfb, 0x97, - 0xe8, 0x2f, 0x71, 0x8e, 0x1d, 0xcd, 0x3e, 0x74, 0x77, 0xd6, 0xc2, 0x9b, 0x18, 0xb4, 0xa5, 0xdd, - 0xf9, 0x81, 0xa2, 0x70, 0x6f, 0xb1, 0x13, 0x7c, 0x80, 0x66, 0x48, 0x37, 0x2d, 0x5d, 0x34, 0x3d, - 0x4a, 0x13, 0x0b, 0xe3, 0x8d, 0xd3, 0xb7, 0xb4, 0x36, 0xc5, 0x0a, 0x6b, 0x3d, 0x9f, 0x5c, 0x46, - 0x69, 0xbd, 0x35, 0x77, 0x5a, 0xff, 0x21, 0x01, 0x9a, 0x1e, 0xc8, 0x89, 0x11, 0xbe, 0x71, 0x86, - 0xcf, 0x57, 0x0d, 0xfb, 0x2c, 0xec, 0xbd, 0x9d, 0x79, 0xc3, 0x1e, 0xd6, 0xf1, 0xe1, 0x53, 0x50, - 0xba, 0x5e, 0x2f, 0xf2, 0x39, 0xe6, 0xea, 0x91, 0xf4, 0xdd, 0x63, 0x21, 0xb7, 0x3c, 0xc7, 0x70, - 0xad, 0xb2, 0x17, 0x58, 0x15, 0x0b, 0xbb, 0x2c, 0x77, 0x15, 0xbe, 0x65, 0xf8, 0x76, 0xf8, 0x86, - 0x3f, 0xfc, 0xdc, 0x1b, 0xad, 0x5e, 0xa5, 0xd2, 0xc7, 0xd5, 0xc3, 0x4e, 0x96, 0x21, 0x6f, 0xff, - 0x27, 0x00, 0x00, 0xff, 0xff, 0x1b, 0x69, 0xcf, 0xc4, 0x31, 0x1a, 0x00, 0x00, + // 2209 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x59, 0xdb, 0x72, 0x1b, 0x49, + 0x19, 0xf6, 0x48, 0xb2, 0x0e, 0xbf, 0x7c, 0xd0, 0xf6, 0x66, 0x9d, 0xb1, 0xb2, 0xd9, 0x98, 0xc9, + 0xee, 0xe2, 0xcd, 0xee, 0x4a, 0x6b, 0x87, 0x90, 0xac, 0x13, 0x12, 0xdb, 0xb2, 0x62, 0xbb, 0xe2, + 0xc8, 0x61, 0x24, 0x25, 0xc5, 0xa9, 0x86, 0xb1, 0xa6, 0x2d, 0x0f, 0x1e, 0xcd, 0x0c, 0xd3, 0x2d, + 0xb1, 0x4e, 0x2a, 0x05, 0x6c, 0x15, 0xdc, 0x42, 0x15, 0x97, 0x5c, 0x70, 0x78, 0x00, 0x8a, 0xa2, + 0x8a, 0xe2, 0x86, 0x7d, 0x0a, 0x1e, 0x01, 0x2e, 0x79, 0x08, 0xaa, 0x0f, 0x23, 0x8d, 0xa4, 0x84, + 0x19, 0x91, 0xe2, 0x26, 0x99, 0xfe, 0xbb, 0xff, 0x43, 0xff, 0xc7, 0xaf, 0x65, 0xa8, 0x74, 0x3d, + 0xaf, 0xeb, 0xe0, 0xaa, 0x85, 0x07, 0xd4, 0xf3, 0x1c, 0x52, 0xed, 0x38, 0x5e, 0xdf, 0x3a, 0xe9, + 0xdb, 0x8e, 0x55, 0x1d, 0x6c, 0x44, 0x56, 0x15, 0x3f, 0xf0, 0xa8, 0x87, 0xae, 0x8a, 0xf3, 0x95, + 0xf0, 0x7c, 0x25, 0x72, 0x62, 0xb0, 0x51, 0x7e, 0x57, 0x8a, 0x33, 0x7d, 0xbb, 0x6a, 0xba, 0xae, + 0x47, 0x4d, 0x6a, 0x7b, 0x2e, 0x11, 0xcc, 0xe5, 0xeb, 0x72, 0xd7, 0xf1, 0xdc, 0x6e, 0xd0, 0x77, + 0x5d, 0xdb, 0xed, 0x56, 0x3d, 0x1f, 0x07, 0x63, 0x87, 0xde, 0x93, 0x87, 0xf8, 0xea, 0xa4, 0x7f, + 0x5a, 0xb5, 0xfa, 0xe2, 0x80, 0xdc, 0xbf, 0x32, 0xb9, 0x8f, 0x7b, 0x3e, 0xbd, 0x90, 0x9b, 0xd7, + 0x26, 0x37, 0xa9, 0xdd, 0xc3, 0x84, 0x9a, 0x3d, 0x5f, 0x1c, 0xd0, 0x0c, 0x58, 0x6c, 0x52, 0x2f, + 0x30, 0xbb, 0xb8, 0xe9, 0xf5, 0x83, 0x0e, 0x46, 0x2b, 0x90, 0x3d, 0xe9, 0x77, 0xce, 0x31, 0x55, + 0x95, 0x35, 0x65, 0xbd, 0xa0, 0xcb, 0x15, 0xa3, 0x7b, 0x27, 0x3f, 0xc2, 0x1d, 0xaa, 0xa6, 0x04, + 0x5d, 0xac, 0xd0, 0x7b, 0x00, 0x5d, 0xec, 0x4a, 0x9b, 0xd5, 0xf4, 0x9a, 0xb2, 0x9e, 0xd6, 0x23, + 0x14, 0xed, 0xaf, 0x0a, 0x80, 0x8e, 0x7d, 0x4f, 0x8a, 0xbf, 0x0a, 0xe0, 0x07, 0x1e, 0xe3, 0x34, + 0x6c, 0x4b, 0xaa, 0x28, 0x48, 0xca, 0xa1, 0x85, 0xae, 0x40, 0x21, 0xc0, 0xbe, 0x67, 0xb8, 0x66, + 0x0f, 0x4b, 0x45, 0x79, 0x46, 0x68, 0x98, 0x3d, 0x8c, 0xbe, 0x06, 0xc5, 0x93, 0xc0, 0x74, 0x3b, + 0x67, 0x62, 0x9b, 0xe9, 0x2a, 0x1c, 0xcc, 0xe9, 0x20, 0x88, 0xfc, 0xc8, 0x15, 0xc8, 0x53, 0xb3, + 0x2b, 0xf6, 0x33, 0x72, 0x3f, 0x47, 0xcd, 0x2e, 0xdf, 0xbc, 0x06, 0xd0, 0xf1, 0x7a, 0x3d, 0x9b, + 0x1a, 0xe4, 0xcc, 0x54, 0xe7, 0xe5, 0x76, 0x41, 0xd0, 0x9a, 0x67, 0xe6, 0x2e, 0x40, 0x3e, 0xc0, + 0x03, 0x9b, 0x30, 0xbb, 0xff, 0xa6, 0x40, 0x56, 0xda, 0xdc, 0x86, 0x25, 0x22, 0x7c, 0x64, 0x10, + 0x4e, 0xe1, 0x96, 0x15, 0x37, 0x3f, 0xa9, 0xfc, 0xd7, 0xe0, 0x57, 0xc6, 0x1c, 0x7b, 0x30, 0xa7, + 0x2f, 0x92, 0x31, 0x4f, 0x1f, 0x41, 0x91, 0xdf, 0x55, 0xca, 0x4c, 0x73, 0x99, 0x1f, 0xc5, 0xc8, + 0x1c, 0xb9, 0x92, 0xdd, 0x3c, 0x18, 0xae, 0x76, 0xf3, 0x90, 0x15, 0x82, 0xb4, 0x3b, 0x00, 0xbb, + 0x7d, 0xdb, 0xa1, 0x87, 0x3d, 0xb3, 0x8b, 0x11, 0x82, 0x0c, 0xf7, 0x86, 0x70, 0x35, 0xff, 0x66, + 0xb1, 0xb4, 0xec, 0x2e, 0x26, 0x54, 0xf8, 0x50, 0x97, 0x2b, 0xed, 0xcb, 0x14, 0x14, 0x18, 0xab, + 0xd5, 0xa4, 0xd8, 0x7f, 0x25, 0x67, 0x09, 0xd2, 0xd8, 0x1d, 0xa8, 0xa9, 0xb5, 0xf4, 0x7a, 0x41, + 0x67, 0x9f, 0xec, 0x94, 0x19, 0x74, 0x89, 0x9a, 0xe6, 0x24, 0xfe, 0xcd, 0x4e, 0x59, 0x76, 0x20, + 0x02, 0xa0, 0xb3, 0x4f, 0xb4, 0x04, 0x29, 0xdb, 0x12, 0x2e, 0xd7, 0x53, 0xb6, 0x85, 0x56, 0x21, + 0xff, 0x13, 0xd3, 0xa6, 0xc6, 0xa9, 0x17, 0xa8, 0x59, 0xce, 0x99, 0x63, 0xeb, 0x87, 0x5e, 0xc0, + 0x12, 0x0a, 0xbb, 0x34, 0xb8, 0xf0, 0x3d, 0xdb, 0xa5, 0x6a, 0x8e, 0xb3, 0x44, 0x28, 0x2c, 0x83, + 0x08, 0xee, 0x04, 0x98, 0x1a, 0xcc, 0x92, 0x3c, 0x67, 0x2e, 0x08, 0x4a, 0xdd, 0x1d, 0xa0, 0x07, + 0x90, 0x1b, 0x78, 0x4e, 0xbf, 0x87, 0x89, 0x5a, 0x58, 0x4b, 0xaf, 0x17, 0x37, 0x3f, 0x88, 0xf1, + 0xe8, 0x53, 0x7e, 0x5a, 0x0f, 0xb9, 0xb4, 0xcf, 0x20, 0x2b, 0x48, 0xaf, 0x74, 0x00, 0x82, 0x8c, + 0x6f, 0xd2, 0x33, 0x99, 0x9b, 0xfc, 0x5b, 0xfb, 0x02, 0x72, 0x3a, 0x26, 0x7d, 0x87, 0x12, 0xb4, + 0x03, 0x59, 0x9b, 0xb9, 0x9d, 0x70, 0x17, 0xc5, 0x87, 0x73, 0x14, 0x28, 0x5d, 0x32, 0xa2, 0x1b, + 0xf0, 0x16, 0xdf, 0x36, 0x08, 0xc5, 0xbe, 0x21, 0xa5, 0x09, 0xef, 0x2e, 0x9f, 0x84, 0xc1, 0xe1, + 0x2c, 0x44, 0xfb, 0x67, 0x01, 0xe6, 0x79, 0xc0, 0xa4, 0x83, 0x95, 0xa1, 0x83, 0xc7, 0xeb, 0xac, + 0x34, 0x59, 0x67, 0x35, 0xc8, 0x12, 0x6a, 0xd2, 0x3e, 0xe1, 0x17, 0x59, 0xda, 0xfc, 0x38, 0x81, + 0x9d, 0x56, 0xa5, 0xc9, 0x59, 0x74, 0xc9, 0x8a, 0xae, 0xc3, 0xa2, 0xf8, 0x32, 0x2c, 0x4c, 0x4d, + 0xdb, 0x51, 0x55, 0xae, 0x66, 0x41, 0x10, 0xf7, 0x38, 0x0d, 0x7d, 0x2b, 0xcc, 0x4b, 0x99, 0xe0, + 0x71, 0xe1, 0x10, 0xe9, 0xac, 0x4b, 0x26, 0x74, 0x1f, 0xe6, 0x99, 0x1f, 0x88, 0x5a, 0xe4, 0xfe, + 0x5c, 0x4f, 0x62, 0x27, 0x73, 0x90, 0x2e, 0xd8, 0xd0, 0x36, 0xe4, 0x02, 0x11, 0x1b, 0x15, 0xb8, + 0xfe, 0x0f, 0x63, 0x0b, 0x8c, 0x9f, 0xd6, 0x43, 0x36, 0x74, 0x17, 0x8a, 0x9d, 0x00, 0x9b, 0x14, + 0x1b, 0xac, 0x77, 0xaa, 0x59, 0x2e, 0xa5, 0x1c, 0x4a, 0x09, 0x1b, 0x6b, 0xa5, 0x15, 0x36, 0x56, + 0x1d, 0xc4, 0x71, 0x46, 0x40, 0x9f, 0x03, 0x10, 0x6a, 0x06, 0x54, 0xf0, 0xe6, 0x62, 0x79, 0x0b, + 0xfc, 0x34, 0x67, 0xbd, 0x0b, 0xc5, 0x53, 0xdb, 0xb5, 0xc9, 0x99, 0xe0, 0xcd, 0xc7, 0xeb, 0x15, + 0xc7, 0x39, 0xf3, 0x4d, 0xc8, 0x31, 0x2e, 0xaf, 0x4f, 0xd5, 0x05, 0xce, 0xb8, 0x3a, 0xc5, 0xb8, + 0x27, 0xc7, 0x88, 0x1e, 0x9e, 0x64, 0x6d, 0x41, 0xa6, 0xdb, 0x22, 0x4f, 0xb7, 0x30, 0x23, 0xaf, + 0x41, 0xd1, 0xf1, 0xba, 0xc4, 0x90, 0x73, 0xe1, 0x6d, 0x51, 0x92, 0x8c, 0xb4, 0x2b, 0x66, 0xc3, + 0xf7, 0xe1, 0x2d, 0x11, 0x2e, 0xc3, 0x0f, 0xbc, 0x01, 0x76, 0x4d, 0xb7, 0x83, 0xd5, 0x77, 0xb8, + 0xde, 0x6a, 0xa2, 0x70, 0x3f, 0x19, 0xb2, 0xe9, 0x25, 0x32, 0x41, 0x41, 0xeb, 0x50, 0x12, 0x05, + 0x41, 0x03, 0xbb, 0xdb, 0xc5, 0x01, 0x4b, 0xe8, 0x15, 0x6e, 0xc3, 0x12, 0xa7, 0xb7, 0x04, 0xf9, + 0xd0, 0x42, 0x75, 0xc8, 0x79, 0x3e, 0x9f, 0x9d, 0xea, 0x65, 0xae, 0x3d, 0x51, 0x5a, 0x1f, 0x0b, + 0x16, 0x3d, 0xe4, 0x45, 0x97, 0x21, 0xe7, 0x78, 0x5d, 0xa3, 0x1f, 0x38, 0xea, 0xaa, 0xe8, 0x8f, + 0x8e, 0xd7, 0x6d, 0x07, 0x0e, 0xfa, 0x01, 0x2c, 0x92, 0xfe, 0x09, 0xa1, 0x36, 0xed, 0x0b, 0x2d, + 0x57, 0x79, 0x52, 0xde, 0x4e, 0x56, 0x3c, 0x51, 0xce, 0x3a, 0xeb, 0x67, 0xfa, 0xb8, 0x34, 0xd6, + 0x5b, 0xa8, 0xd9, 0x25, 0xea, 0x35, 0xd1, 0x4a, 0xd9, 0x37, 0x6b, 0x67, 0xa2, 0xb7, 0x11, 0x75, + 0x2d, 0x51, 0x3b, 0x6b, 0xf2, 0xd3, 0x7a, 0xc8, 0x55, 0xde, 0x06, 0x34, 0xad, 0x99, 0x75, 0xe8, + 0x73, 0x7c, 0x21, 0xfb, 0x05, 0xfb, 0x44, 0x97, 0x60, 0x7e, 0x60, 0x3a, 0xfd, 0x70, 0xea, 0x8a, + 0xc5, 0x56, 0xea, 0x8e, 0xa2, 0xfd, 0x14, 0xb2, 0xa2, 0xf0, 0x11, 0x82, 0xa5, 0x66, 0x6b, 0xa7, + 0xd5, 0x6e, 0x1a, 0xed, 0xc6, 0xa3, 0xc6, 0xf1, 0xb3, 0x46, 0x69, 0x0e, 0x01, 0x64, 0xbf, 0xdd, + 0xae, 0xb7, 0xeb, 0x7b, 0x25, 0x05, 0x15, 0x21, 0xf7, 0xec, 0x58, 0x7f, 0x74, 0xd8, 0xd8, 0x2f, + 0xa5, 0xd8, 0xa2, 0xd9, 0xae, 0xd5, 0xea, 0xcd, 0x66, 0x29, 0xcd, 0x16, 0x0f, 0x77, 0x0e, 0x8f, + 0xda, 0x7a, 0xbd, 0x94, 0x61, 0x62, 0x0e, 0x1b, 0xad, 0xba, 0xde, 0xd8, 0x39, 0x32, 0xea, 0xba, + 0x7e, 0xac, 0x97, 0xe6, 0xd9, 0x81, 0xd6, 0xe1, 0xe3, 0xfa, 0x71, 0xbb, 0x55, 0xca, 0xa2, 0x45, + 0x28, 0xd4, 0x76, 0x1a, 0xb5, 0xfa, 0xd1, 0x51, 0x7d, 0xaf, 0x94, 0xd3, 0x5a, 0xb0, 0x22, 0x03, + 0x25, 0x41, 0xc5, 0x63, 0x4c, 0x4d, 0xcb, 0xa4, 0x26, 0xda, 0x82, 0x79, 0x7e, 0x71, 0x7e, 0x91, + 0xe2, 0xe6, 0xfb, 0x49, 0x02, 0xa1, 0x0b, 0x16, 0xed, 0x0f, 0x69, 0x28, 0x4d, 0x66, 0x1f, 0xb2, + 0xe0, 0x72, 0x80, 0x89, 0xe7, 0x0c, 0x30, 0xeb, 0xbf, 0x63, 0x33, 0x3f, 0x3d, 0xfb, 0xcc, 0xd7, + 0xdf, 0x09, 0x85, 0x8d, 0x63, 0xac, 0xef, 0xc1, 0xa5, 0xa1, 0x96, 0x28, 0x04, 0xc8, 0xce, 0x08, + 0x01, 0x74, 0x14, 0x8a, 0x89, 0x20, 0xac, 0x1f, 0xb2, 0xbe, 0xe1, 0x60, 0xe3, 0xcc, 0x24, 0x67, + 0x98, 0xa8, 0x19, 0x9e, 0x35, 0x0f, 0x66, 0x2c, 0xc3, 0xca, 0x43, 0xdb, 0xc1, 0x07, 0x5c, 0x82, + 0x48, 0x55, 0x38, 0x1d, 0x12, 0xca, 0x67, 0xb0, 0x3c, 0xb1, 0xfd, 0x8a, 0x7c, 0x7a, 0x10, 0xcd, + 0xa7, 0xf8, 0x4b, 0x8d, 0x04, 0x46, 0x53, 0xaf, 0x01, 0x30, 0xda, 0x40, 0xdb, 0x50, 0x18, 0xde, + 0x4c, 0x55, 0xf8, 0xbd, 0xae, 0xc7, 0x88, 0x65, 0x9c, 0x7a, 0x3e, 0xb4, 0x5d, 0xfb, 0x99, 0x02, + 0x19, 0xf6, 0x81, 0xb6, 0x21, 0x43, 0x2f, 0x7c, 0x31, 0xda, 0x97, 0x62, 0x83, 0xca, 0x58, 0xf8, + 0x3f, 0xad, 0x0b, 0x1f, 0xeb, 0x9c, 0x73, 0xbc, 0x5e, 0x16, 0xa4, 0xd1, 0xda, 0x1a, 0xe4, 0xc3, + 0x73, 0x28, 0x0f, 0x99, 0xc6, 0x71, 0xa3, 0x2e, 0x6a, 0xa4, 0x79, 0xb0, 0xb3, 0x79, 0xeb, 0x9b, + 0x25, 0x45, 0xfb, 0x8a, 0xe1, 0x4a, 0x5e, 0x9b, 0x68, 0x0d, 0x16, 0xce, 0x7b, 0xc4, 0x38, 0xc7, + 0x17, 0x46, 0x04, 0x67, 0xc0, 0x79, 0x8f, 0x3c, 0xc2, 0x17, 0x1c, 0xb1, 0x36, 0xc7, 0xb0, 0x4e, + 0x9a, 0x5f, 0xf9, 0x1b, 0x89, 0x1a, 0x80, 0xfc, 0xaf, 0xee, 0x0e, 0x44, 0xfc, 0x46, 0x08, 0xa9, + 0x7c, 0x0f, 0x96, 0xc6, 0x37, 0xe3, 0xba, 0xc1, 0x42, 0x34, 0x24, 0x1e, 0xa0, 0x1a, 0x9f, 0x6f, + 0xa2, 0x98, 0xf0, 0x8f, 0xfb, 0x98, 0xd0, 0x38, 0x58, 0x3f, 0xac, 0xd3, 0xd4, 0xec, 0x75, 0xba, + 0x0d, 0xcb, 0xfb, 0x98, 0xce, 0xa2, 0x4d, 0x60, 0xa1, 0x54, 0x88, 0x85, 0xb4, 0x5f, 0x2a, 0xf0, + 0xd6, 0x91, 0x4d, 0x84, 0x0c, 0x92, 0x50, 0xc8, 0x15, 0x28, 0xf8, 0xbc, 0xfa, 0xed, 0xe7, 0xc2, + 0x0b, 0xf3, 0x7a, 0x9e, 0x11, 0x9a, 0xf6, 0x73, 0xf1, 0x8a, 0x61, 0x9b, 0xd4, 0x3b, 0xc7, 0xae, + 0x04, 0xd1, 0xfc, 0x78, 0x8b, 0x11, 0xd8, 0x20, 0x3d, 0xb5, 0x1d, 0x8a, 0x03, 0x3e, 0xb5, 0x0b, + 0xba, 0x5c, 0x69, 0xcf, 0x01, 0x45, 0xed, 0x20, 0xbe, 0xe7, 0x12, 0x8c, 0xee, 0xb1, 0x17, 0x17, + 0xa3, 0xc8, 0x9c, 0x4e, 0xe6, 0x1d, 0xc9, 0x83, 0x3e, 0x84, 0x65, 0x17, 0x7f, 0x41, 0x8d, 0x88, + 0x3d, 0xe2, 0xe6, 0x8b, 0x8c, 0xfc, 0x24, 0xb4, 0x49, 0xab, 0x01, 0xaa, 0xb1, 0xca, 0x76, 0xde, + 0xc4, 0x93, 0xbf, 0xc8, 0xc0, 0xc2, 0x6e, 0x64, 0xe6, 0x4e, 0xc1, 0xce, 0x35, 0x28, 0x5a, 0x98, + 0x74, 0x02, 0x9b, 0x8f, 0x52, 0x0e, 0xb9, 0x0a, 0x7a, 0x94, 0x84, 0x5a, 0x50, 0x0a, 0xe7, 0x38, + 0xc5, 0x3d, 0xdf, 0x31, 0x69, 0x88, 0x8b, 0x66, 0xe8, 0x7b, 0xcb, 0x52, 0x44, 0x4b, 0x4a, 0x40, + 0xf7, 0xc2, 0x04, 0xcb, 0x24, 0x4f, 0xb0, 0x83, 0x39, 0x99, 0x62, 0xe8, 0x5d, 0xe0, 0x2d, 0x82, + 0x17, 0x61, 0x5e, 0x3e, 0x0b, 0x87, 0x94, 0x49, 0x00, 0x38, 0x3f, 0x13, 0x00, 0x2c, 0x43, 0xde, + 0xb2, 0x89, 0x79, 0xe2, 0x60, 0x4b, 0x2d, 0xac, 0x29, 0xeb, 0x79, 0x7d, 0xb8, 0x46, 0xd6, 0x24, + 0x9c, 0x10, 0x18, 0xf7, 0x7e, 0x12, 0xe3, 0x65, 0x00, 0xe2, 0x51, 0xc5, 0x9b, 0x03, 0x80, 0xdd, + 0x12, 0x2c, 0x49, 0x00, 0x26, 0xdd, 0xad, 0xfd, 0x5c, 0x81, 0xd5, 0x48, 0x17, 0x90, 0xc6, 0x24, + 0x4c, 0xaa, 0x3a, 0xe4, 0x64, 0xf8, 0x64, 0x3b, 0xf8, 0x78, 0x86, 0x0b, 0xeb, 0x21, 0xaf, 0xf6, + 0x14, 0x56, 0xc2, 0xbe, 0x30, 0x9b, 0xfe, 0xab, 0x00, 0x11, 0x24, 0x29, 0x6e, 0x5b, 0xa0, 0x21, + 0x88, 0xd4, 0x3e, 0x07, 0x75, 0x58, 0xa4, 0x52, 0x70, 0xc2, 0x9e, 0xa1, 0x59, 0xb0, 0xfa, 0x0a, + 0x56, 0x59, 0xe6, 0xfb, 0x90, 0x97, 0x4a, 0xc2, 0x42, 0x9f, 0xe9, 0xde, 0x43, 0x66, 0xed, 0x3b, + 0xb0, 0xba, 0x87, 0x1d, 0xfc, 0x3f, 0xf9, 0x3e, 0xe6, 0xee, 0xbf, 0x57, 0x60, 0xb5, 0xed, 0x5b, + 0xe6, 0xff, 0x41, 0x76, 0x34, 0xec, 0xe9, 0x37, 0x08, 0xfb, 0xdf, 0xd3, 0xb2, 0x05, 0x49, 0xd8, + 0x8e, 0x4e, 0x60, 0x65, 0xea, 0xf1, 0x31, 0x82, 0x08, 0xb3, 0x0e, 0xf7, 0x4b, 0x93, 0xcf, 0x0f, + 0x0e, 0x17, 0x7c, 0x06, 0x0b, 0xb9, 0x13, 0xb0, 0x65, 0x0c, 0x70, 0x60, 0x9f, 0x5e, 0x18, 0xe2, + 0xb5, 0x20, 0xdf, 0xcf, 0x77, 0x66, 0x78, 0x68, 0x54, 0x9e, 0x72, 0x01, 0x62, 0xc5, 0x20, 0xa2, + 0x14, 0x1c, 0x25, 0x23, 0x0f, 0xde, 0x8e, 0x96, 0x71, 0xa8, 0x2d, 0xc3, 0xb5, 0xdd, 0x9f, 0x45, + 0x5b, 0xb4, 0xf8, 0xa5, 0x4e, 0x44, 0xa6, 0x68, 0x5a, 0x05, 0x16, 0xc6, 0x0c, 0x28, 0xc1, 0x42, + 0xe3, 0xb8, 0x65, 0x3c, 0xad, 0xeb, 0x87, 0x0f, 0x0f, 0xeb, 0x7b, 0xa5, 0x39, 0xb4, 0x00, 0xf9, + 0xe1, 0x4a, 0xd1, 0x6e, 0x8d, 0xb7, 0x15, 0xc9, 0xb5, 0x04, 0xf0, 0xb8, 0xdd, 0x6c, 0x19, 0x8f, + 0x77, 0x5a, 0xb5, 0x83, 0xd2, 0x1c, 0x5a, 0x86, 0xe2, 0xce, 0xd1, 0xd1, 0xf1, 0x33, 0xe3, 0xe8, + 0xf8, 0xb8, 0x59, 0x2f, 0x29, 0x9b, 0xff, 0x2e, 0x02, 0xd4, 0x98, 0xb1, 0xe2, 0x67, 0x8b, 0x5f, + 0x2b, 0x50, 0x8c, 0x34, 0x12, 0xb4, 0x11, 0x73, 0xb3, 0x69, 0xe8, 0x51, 0xbe, 0x1a, 0xb2, 0x44, + 0x7e, 0x45, 0xad, 0x0c, 0x9f, 0x0a, 0x5a, 0xf5, 0xcb, 0x7f, 0xfc, 0xeb, 0x37, 0xa9, 0x8f, 0xb4, + 0xb5, 0xea, 0x60, 0xa3, 0x2a, 0x93, 0x95, 0x54, 0x5f, 0x8c, 0x12, 0xf9, 0x65, 0x55, 0x4c, 0xd2, + 0x2d, 0x39, 0x0c, 0x7e, 0xa5, 0x40, 0x3e, 0x6c, 0x2c, 0xa8, 0x12, 0x63, 0xcf, 0x04, 0x32, 0x29, + 0x27, 0x1a, 0x3c, 0xda, 0xa7, 0xdc, 0xa6, 0xaf, 0xa3, 0x0f, 0xe2, 0x6c, 0xaa, 0xbe, 0xb0, 0xad, + 0x97, 0xe8, 0xb7, 0x0a, 0xc0, 0x08, 0x37, 0xa0, 0xcf, 0x62, 0x74, 0x4c, 0x41, 0x9d, 0xf2, 0xc6, + 0x0c, 0x1c, 0xa2, 0x5b, 0x69, 0xeb, 0xdc, 0x44, 0x0d, 0xc5, 0xba, 0x0d, 0xfd, 0x8e, 0x85, 0x70, + 0x84, 0x2c, 0xe2, 0x43, 0x38, 0x85, 0x42, 0x12, 0x7a, 0xed, 0x36, 0x37, 0x69, 0x43, 0xfb, 0x24, + 0x91, 0xd7, 0xb6, 0x3a, 0x5c, 0xcf, 0x96, 0x72, 0x03, 0xfd, 0x59, 0x19, 0xc3, 0xac, 0x21, 0x76, + 0xb9, 0x93, 0x3c, 0xd7, 0xc6, 0x1b, 0x61, 0x79, 0x96, 0xce, 0xa5, 0xdd, 0xe4, 0x66, 0x7f, 0xaa, + 0x69, 0xaf, 0x37, 0x3b, 0x6c, 0xed, 0x5b, 0x61, 0x97, 0x43, 0x7f, 0x52, 0x46, 0xa8, 0x37, 0xb4, + 0xf7, 0x56, 0xc2, 0x5c, 0x7c, 0x13, 0x63, 0xa5, 0x8f, 0x51, 0x35, 0xde, 0xd8, 0xea, 0x8b, 0x51, + 0xb7, 0x7f, 0x89, 0xfe, 0x12, 0xc5, 0xd8, 0xe1, 0xec, 0x43, 0xb7, 0x93, 0x26, 0xde, 0xc4, 0xa0, + 0x2d, 0xdf, 0x99, 0x9d, 0x51, 0x26, 0xee, 0x0d, 0x7e, 0x83, 0xf7, 0x51, 0x02, 0x77, 0xb3, 0xd4, + 0x45, 0xd3, 0xa3, 0x34, 0x36, 0x31, 0x5e, 0x3b, 0x7d, 0xcb, 0x2b, 0x53, 0xa8, 0xb0, 0xde, 0xf3, + 0xe9, 0x45, 0xe8, 0xd6, 0x1b, 0x33, 0xbb, 0xf5, 0x2b, 0x05, 0xd0, 0xf4, 0x40, 0x8e, 0xb5, 0xf0, + 0xb5, 0x33, 0x7c, 0xb6, 0x6c, 0xd8, 0xe6, 0x66, 0x6f, 0x6d, 0xce, 0x6a, 0xf6, 0x30, 0x8f, 0x77, + 0xcf, 0x41, 0xed, 0x78, 0xbd, 0x50, 0xe7, 0x98, 0xaa, 0x27, 0xca, 0x77, 0xf7, 0x25, 0xbd, 0xeb, + 0x39, 0xa6, 0xdb, 0xad, 0x78, 0x41, 0xb7, 0xda, 0xc5, 0x2e, 0xf7, 0x5d, 0x55, 0x6c, 0x99, 0xbe, + 0x4d, 0x5e, 0xf3, 0xb7, 0xb8, 0xbb, 0xa3, 0xd5, 0x1f, 0x53, 0xe9, 0xfd, 0xda, 0xee, 0x49, 0x96, + 0x73, 0xde, 0xfc, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xec, 0x36, 0x27, 0x4f, 0xc4, 0x1b, 0x00, + 0x00, } diff --git a/vendor/google.golang.org/genproto/googleapis/devtools/clouddebugger/v2/controller.pb.go b/vendor/google.golang.org/genproto/googleapis/devtools/clouddebugger/v2/controller.pb.go index 4f1a7b5d..1e54c283 100644 --- a/vendor/google.golang.org/genproto/googleapis/devtools/clouddebugger/v2/controller.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/devtools/clouddebugger/v2/controller.pb.go @@ -81,6 +81,9 @@ func (m *RegisterDebuggeeRequest) GetDebuggee() *Debuggee { type RegisterDebuggeeResponse struct { // Debuggee resource. // The field `id` is guranteed to be set (in addition to the echoed fields). + // If the field `is_disabled` is set to `true`, the agent should disable + // itself by removing all breakpoints and detaching from the application. + // It should however continue to poll `RegisterDebuggee` until reenabled. Debuggee *Debuggee `protobuf:"bytes,1,opt,name=debuggee" json:"debuggee,omitempty"` } @@ -100,16 +103,17 @@ func (m *RegisterDebuggeeResponse) GetDebuggee() *Debuggee { type ListActiveBreakpointsRequest struct { // Identifies the debuggee. DebuggeeId string `protobuf:"bytes,1,opt,name=debuggee_id,json=debuggeeId" json:"debuggee_id,omitempty"` - // A wait token that, if specified, blocks the method call until the list - // of active breakpoints has changed, or a server selected timeout has - // expired. The value should be set from the last returned response. + // A token that, if specified, blocks the method call until the list + // of active breakpoints has changed, or a server-selected timeout has + // expired. The value should be set from the `next_wait_token` field in + // the last response. The initial value should be set to `"init"`. WaitToken string `protobuf:"bytes,2,opt,name=wait_token,json=waitToken" json:"wait_token,omitempty"` - // If set to `true`, returns `google.rpc.Code.OK` status and sets the - // `wait_expired` response field to `true` when the server-selected timeout - // has expired (recommended). + // If set to `true` (recommended), returns `google.rpc.Code.OK` status and + // sets the `wait_expired` response field to `true` when the server-selected + // timeout has expired. // - // If set to `false`, returns `google.rpc.Code.ABORTED` status when the - // server-selected timeout has expired (deprecated). + // If set to `false` (deprecated), returns `google.rpc.Code.ABORTED` status + // when the server-selected timeout has expired. SuccessOnTimeout bool `protobuf:"varint,3,opt,name=success_on_timeout,json=successOnTimeout" json:"success_on_timeout,omitempty"` } @@ -144,11 +148,12 @@ type ListActiveBreakpointsResponse struct { // List of all active breakpoints. // The fields `id` and `location` are guaranteed to be set on each breakpoint. Breakpoints []*Breakpoint `protobuf:"bytes,1,rep,name=breakpoints" json:"breakpoints,omitempty"` - // A wait token that can be used in the next method call to block until + // A token that can be used in the next method call to block until // the list of breakpoints changes. NextWaitToken string `protobuf:"bytes,2,opt,name=next_wait_token,json=nextWaitToken" json:"next_wait_token,omitempty"` - // The `wait_expired` field is set to true by the server when the - // request times out and the field `success_on_timeout` is set to true. + // If set to `true`, indicates that there is no change to the + // list of active breakpoints and the server-selected timeout has expired. + // The `breakpoints` field would be empty and should be ignored. WaitExpired bool `protobuf:"varint,3,opt,name=wait_expired,json=waitExpired" json:"wait_expired,omitempty"` } @@ -183,7 +188,8 @@ type UpdateActiveBreakpointRequest struct { // Identifies the debuggee being debugged. DebuggeeId string `protobuf:"bytes,1,opt,name=debuggee_id,json=debuggeeId" json:"debuggee_id,omitempty"` // Updated breakpoint information. - // The field 'id' must be set. + // The field `id` must be set. + // The agent must echo all Breakpoint specification fields in the update. Breakpoint *Breakpoint `protobuf:"bytes,2,opt,name=breakpoint" json:"breakpoint,omitempty"` } @@ -238,18 +244,18 @@ const _ = grpc.SupportPackageIsVersion4 type Controller2Client interface { // Registers the debuggee with the controller service. // - // All agents attached to the same application should call this method with - // the same request content to get back the same stable `debuggee_id`. Agents - // should call this method again whenever `google.rpc.Code.NOT_FOUND` is - // returned from any controller method. + // All agents attached to the same application must call this method with + // exactly the same request content to get back the same stable `debuggee_id`. + // Agents should call this method again whenever `google.rpc.Code.NOT_FOUND` + // is returned from any controller method. // - // This allows the controller service to disable the agent or recover from any - // data loss. If the debuggee is disabled by the server, the response will - // have `is_disabled` set to `true`. + // This protocol allows the controller service to disable debuggees, recover + // from data loss, or change the `debuggee_id` format. Agents must handle + // `debuggee_id` value changing upon re-registration. RegisterDebuggee(ctx context.Context, in *RegisterDebuggeeRequest, opts ...grpc.CallOption) (*RegisterDebuggeeResponse, error) // Returns the list of all active breakpoints for the debuggee. // - // The breakpoint specification (location, condition, and expression + // The breakpoint specification (`location`, `condition`, and `expressions` // fields) is semantically immutable, although the field values may // change. For example, an agent may update the location line number // to reflect the actual line where the breakpoint was set, but this @@ -262,12 +268,11 @@ type Controller2Client interface { // setting those breakpoints again. ListActiveBreakpoints(ctx context.Context, in *ListActiveBreakpointsRequest, opts ...grpc.CallOption) (*ListActiveBreakpointsResponse, error) // Updates the breakpoint state or mutable fields. - // The entire Breakpoint message must be sent back to the controller - // service. + // The entire Breakpoint message must be sent back to the controller service. // // Updates to active breakpoint fields are only allowed if the new value // does not change the breakpoint specification. Updates to the `location`, - // `condition` and `expression` fields should not alter the breakpoint + // `condition` and `expressions` fields should not alter the breakpoint // semantics. These may only make changes such as canonicalizing a value // or snapping the location to the correct line of code. UpdateActiveBreakpoint(ctx context.Context, in *UpdateActiveBreakpointRequest, opts ...grpc.CallOption) (*UpdateActiveBreakpointResponse, error) @@ -313,18 +318,18 @@ func (c *controller2Client) UpdateActiveBreakpoint(ctx context.Context, in *Upda type Controller2Server interface { // Registers the debuggee with the controller service. // - // All agents attached to the same application should call this method with - // the same request content to get back the same stable `debuggee_id`. Agents - // should call this method again whenever `google.rpc.Code.NOT_FOUND` is - // returned from any controller method. + // All agents attached to the same application must call this method with + // exactly the same request content to get back the same stable `debuggee_id`. + // Agents should call this method again whenever `google.rpc.Code.NOT_FOUND` + // is returned from any controller method. // - // This allows the controller service to disable the agent or recover from any - // data loss. If the debuggee is disabled by the server, the response will - // have `is_disabled` set to `true`. + // This protocol allows the controller service to disable debuggees, recover + // from data loss, or change the `debuggee_id` format. Agents must handle + // `debuggee_id` value changing upon re-registration. RegisterDebuggee(context.Context, *RegisterDebuggeeRequest) (*RegisterDebuggeeResponse, error) // Returns the list of all active breakpoints for the debuggee. // - // The breakpoint specification (location, condition, and expression + // The breakpoint specification (`location`, `condition`, and `expressions` // fields) is semantically immutable, although the field values may // change. For example, an agent may update the location line number // to reflect the actual line where the breakpoint was set, but this @@ -337,12 +342,11 @@ type Controller2Server interface { // setting those breakpoints again. ListActiveBreakpoints(context.Context, *ListActiveBreakpointsRequest) (*ListActiveBreakpointsResponse, error) // Updates the breakpoint state or mutable fields. - // The entire Breakpoint message must be sent back to the controller - // service. + // The entire Breakpoint message must be sent back to the controller service. // // Updates to active breakpoint fields are only allowed if the new value // does not change the breakpoint specification. Updates to the `location`, - // `condition` and `expression` fields should not alter the breakpoint + // `condition` and `expressions` fields should not alter the breakpoint // semantics. These may only make changes such as canonicalizing a value // or snapping the location to the correct line of code. UpdateActiveBreakpoint(context.Context, *UpdateActiveBreakpointRequest) (*UpdateActiveBreakpointResponse, error) @@ -430,41 +434,42 @@ var _Controller2_serviceDesc = grpc.ServiceDesc{ func init() { proto.RegisterFile("google/devtools/clouddebugger/v2/controller.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ - // 572 bytes of a gzipped FileDescriptorProto + // 589 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0xdd, 0x6a, 0xd4, 0x40, - 0x14, 0x66, 0x5a, 0x94, 0xf6, 0x44, 0x69, 0x19, 0x50, 0x97, 0xd8, 0xea, 0x36, 0x48, 0x29, 0xeb, - 0x92, 0xc1, 0xe8, 0x8d, 0x2b, 0xf8, 0xb3, 0xfe, 0x21, 0xb4, 0x5a, 0x96, 0x8a, 0xe0, 0xcd, 0x92, - 0x4d, 0x8e, 0x61, 0x68, 0x76, 0x26, 0x66, 0x26, 0x6b, 0xa5, 0xf4, 0xc6, 0x2b, 0x41, 0xf1, 0xc6, - 0x87, 0x11, 0x7c, 0x0d, 0x7d, 0x04, 0xaf, 0x7c, 0x0a, 0xd9, 0x64, 0xf6, 0xaf, 0xed, 0x36, 0xed, - 0xe2, 0x65, 0xbe, 0x73, 0xbe, 0x73, 0xbe, 0x6f, 0x72, 0xce, 0x81, 0x5b, 0x91, 0x94, 0x51, 0x8c, - 0x2c, 0xc4, 0x9e, 0x96, 0x32, 0x56, 0x2c, 0x88, 0x65, 0x16, 0x86, 0xd8, 0xc9, 0xa2, 0x08, 0x53, - 0xd6, 0xf3, 0x58, 0x20, 0x85, 0x4e, 0x65, 0x1c, 0x63, 0xea, 0x26, 0xa9, 0xd4, 0x92, 0x56, 0x0b, - 0x8a, 0x3b, 0xa0, 0xb8, 0x13, 0x14, 0xb7, 0xe7, 0xd9, 0x2b, 0xa6, 0xa8, 0x9f, 0x70, 0xe6, 0x0b, - 0x21, 0xb5, 0xaf, 0xb9, 0x14, 0xaa, 0xe0, 0xdb, 0x37, 0x4b, 0x5b, 0x86, 0xbe, 0xf6, 0x4d, 0xf2, - 0x55, 0x93, 0x9c, 0x7f, 0x75, 0xb2, 0x77, 0x0c, 0xbb, 0x89, 0xfe, 0x58, 0x04, 0x1d, 0x1f, 0xae, - 0xb4, 0x30, 0xe2, 0x4a, 0x63, 0xfa, 0xa4, 0xa0, 0x63, 0x0b, 0xdf, 0x67, 0xa8, 0x34, 0x7d, 0x06, - 0x0b, 0xa6, 0x22, 0x56, 0x48, 0x95, 0x6c, 0x58, 0x5e, 0xcd, 0x2d, 0xd3, 0xed, 0x0e, 0x8b, 0x0c, - 0xb9, 0x4e, 0x07, 0x2a, 0x47, 0x5b, 0xa8, 0x44, 0x0a, 0x85, 0xff, 0xad, 0xc7, 0x57, 0x02, 0x2b, - 0x9b, 0x5c, 0xe9, 0x47, 0x81, 0xe6, 0x3d, 0x6c, 0xa6, 0xe8, 0xef, 0x26, 0x92, 0x0b, 0xad, 0x06, - 0x66, 0xae, 0x83, 0x35, 0x48, 0x6e, 0xf3, 0x30, 0xef, 0xb5, 0xd8, 0x82, 0x01, 0xf4, 0x22, 0xa4, - 0xab, 0x00, 0x1f, 0x7c, 0xae, 0xdb, 0x5a, 0xee, 0xa2, 0xa8, 0xcc, 0xe5, 0xf1, 0xc5, 0x3e, 0xb2, - 0xd3, 0x07, 0x68, 0x1d, 0xa8, 0xca, 0x82, 0x00, 0x95, 0x6a, 0x4b, 0xd1, 0xd6, 0xbc, 0x8b, 0x32, - 0xd3, 0x95, 0xf9, 0x2a, 0xd9, 0x58, 0x68, 0x2d, 0x9b, 0xc8, 0x2b, 0xb1, 0x53, 0xe0, 0xce, 0x4f, - 0x02, 0xab, 0x53, 0xe4, 0x18, 0xe3, 0x2f, 0xc1, 0xea, 0x8c, 0xe0, 0x0a, 0xa9, 0xce, 0x6f, 0x58, - 0x5e, 0xbd, 0xdc, 0xfb, 0xa8, 0x56, 0x6b, 0xbc, 0x00, 0x5d, 0x87, 0x25, 0x81, 0x7b, 0xba, 0x7d, - 0xc4, 0xc3, 0xc5, 0x3e, 0xfc, 0x66, 0xe8, 0x63, 0x0d, 0x2e, 0xe4, 0x29, 0xb8, 0x97, 0xf0, 0x14, - 0x43, 0xe3, 0xc0, 0xea, 0x63, 0x4f, 0x0b, 0xc8, 0xf9, 0x46, 0x60, 0xf5, 0x75, 0x12, 0xfa, 0x1a, - 0x0f, 0xcb, 0x3f, 0xf5, 0x63, 0x6e, 0x02, 0x8c, 0xc4, 0xe5, 0x42, 0xce, 0x6a, 0x6e, 0x8c, 0xef, - 0x54, 0xe1, 0xda, 0x34, 0x3d, 0xc5, 0x6b, 0x7a, 0x5f, 0xce, 0x81, 0xf5, 0x78, 0xb8, 0x64, 0x1e, - 0xfd, 0x41, 0x60, 0xf9, 0xf0, 0xcc, 0xd1, 0xbb, 0xe5, 0x02, 0xa6, 0xac, 0x82, 0xdd, 0x98, 0x85, - 0x5a, 0x68, 0x73, 0xea, 0x9f, 0x7e, 0xfd, 0xf9, 0x3e, 0xb7, 0xee, 0xac, 0x4d, 0x5e, 0x02, 0x36, - 0x78, 0x2e, 0xc5, 0x52, 0x43, 0x6d, 0x90, 0x1a, 0xfd, 0x4d, 0xe0, 0xd2, 0xb1, 0x93, 0x43, 0xef, - 0x97, 0x6b, 0x38, 0x69, 0x03, 0xec, 0x07, 0x33, 0xf3, 0x8d, 0x91, 0x46, 0x6e, 0xe4, 0x0e, 0xf5, - 0xa6, 0x1a, 0xd9, 0x1f, 0x9b, 0x8a, 0x03, 0x36, 0x3e, 0x9e, 0x7f, 0x09, 0x5c, 0x3e, 0xfe, 0x1f, - 0xd2, 0x53, 0xe8, 0x3a, 0x71, 0x1a, 0xed, 0x87, 0xb3, 0x17, 0x30, 0xce, 0xb6, 0x72, 0x67, 0xcf, - 0xed, 0xe6, 0xd9, 0x9d, 0xb1, 0xfd, 0xd1, 0x87, 0xcb, 0xc3, 0x83, 0x06, 0xa9, 0x35, 0x3f, 0x13, - 0xb8, 0x11, 0xc8, 0x6e, 0xa9, 0xac, 0xe6, 0xd2, 0x68, 0x66, 0xb7, 0xfb, 0xd7, 0x78, 0x9b, 0xbc, - 0xdd, 0x32, 0xa4, 0x48, 0xc6, 0xbe, 0x88, 0x5c, 0x99, 0x46, 0x2c, 0x42, 0x91, 0xdf, 0x6a, 0x56, - 0x84, 0xfc, 0x84, 0xab, 0xe9, 0x87, 0xff, 0xde, 0x04, 0xd0, 0x39, 0x9f, 0x33, 0x6f, 0xff, 0x0b, - 0x00, 0x00, 0xff, 0xff, 0xe1, 0x6e, 0xc8, 0x51, 0xa4, 0x06, 0x00, 0x00, + 0x14, 0x66, 0x5a, 0x94, 0xf6, 0x44, 0x69, 0x19, 0x50, 0x43, 0x6c, 0x75, 0x1b, 0xa4, 0x94, 0x5a, + 0x32, 0x18, 0xbd, 0x71, 0x05, 0x7f, 0xb6, 0x6a, 0x11, 0x5a, 0x2d, 0x4b, 0x55, 0xf0, 0x66, 0xc9, + 0x26, 0xc7, 0x30, 0x34, 0x9d, 0x89, 0x99, 0xc9, 0x5a, 0x29, 0xbd, 0xf1, 0x56, 0xf1, 0xc6, 0x47, + 0xf0, 0xce, 0x17, 0x10, 0x7c, 0x0d, 0x7d, 0x04, 0xaf, 0x7c, 0x0a, 0xc9, 0xdf, 0xee, 0xf6, 0x67, + 0x9b, 0x76, 0xf1, 0x32, 0xdf, 0x9c, 0xef, 0x3b, 0xdf, 0x37, 0x39, 0x73, 0xe0, 0x56, 0x28, 0x65, + 0x18, 0x21, 0x0b, 0xb0, 0xa7, 0xa5, 0x8c, 0x14, 0xf3, 0x23, 0x99, 0x06, 0x01, 0x76, 0xd3, 0x30, + 0xc4, 0x84, 0xf5, 0x5c, 0xe6, 0x4b, 0xa1, 0x13, 0x19, 0x45, 0x98, 0x38, 0x71, 0x22, 0xb5, 0xa4, + 0x8d, 0x82, 0xe2, 0x54, 0x14, 0xe7, 0x00, 0xc5, 0xe9, 0xb9, 0xd6, 0x5c, 0x29, 0xea, 0xc5, 0x9c, + 0x79, 0x42, 0x48, 0xed, 0x69, 0x2e, 0x85, 0x2a, 0xf8, 0xd6, 0xcd, 0xda, 0x96, 0x81, 0xa7, 0xbd, + 0xb2, 0xf8, 0x6a, 0x59, 0x9c, 0x7f, 0x75, 0xd3, 0xb7, 0x0c, 0x77, 0x62, 0xfd, 0xa1, 0x38, 0xb4, + 0x3d, 0xb8, 0xd2, 0xc6, 0x90, 0x2b, 0x8d, 0xc9, 0xe3, 0x82, 0x8e, 0x6d, 0x7c, 0x97, 0xa2, 0xd2, + 0xf4, 0x29, 0x4c, 0x95, 0x8a, 0x68, 0x92, 0x06, 0x59, 0x32, 0xdc, 0x65, 0xa7, 0xce, 0xb7, 0xd3, + 0x17, 0xe9, 0x73, 0xed, 0x2e, 0x98, 0x47, 0x5b, 0xa8, 0x58, 0x0a, 0x85, 0xff, 0xad, 0xc7, 0x67, + 0x02, 0x73, 0xeb, 0x5c, 0xe9, 0x47, 0xbe, 0xe6, 0x3d, 0x6c, 0x25, 0xe8, 0x6d, 0xc7, 0x92, 0x0b, + 0xad, 0xaa, 0x30, 0xd7, 0xc1, 0xa8, 0x8a, 0x3b, 0x3c, 0xc8, 0x7b, 0x4d, 0xb7, 0xa1, 0x82, 0x9e, + 0x05, 0x74, 0x1e, 0xe0, 0xbd, 0xc7, 0x75, 0x47, 0xcb, 0x6d, 0x14, 0xe6, 0x44, 0x7e, 0x3e, 0x9d, + 0x21, 0x5b, 0x19, 0x40, 0x57, 0x80, 0xaa, 0xd4, 0xf7, 0x51, 0xa9, 0x8e, 0x14, 0x1d, 0xcd, 0x77, + 0x50, 0xa6, 0xda, 0x9c, 0x6c, 0x90, 0xa5, 0xa9, 0xf6, 0x6c, 0x79, 0xf2, 0x42, 0x6c, 0x15, 0xb8, + 0xfd, 0x93, 0xc0, 0xfc, 0x08, 0x3b, 0x65, 0xf0, 0xe7, 0x60, 0x74, 0x07, 0xb0, 0x49, 0x1a, 0x93, + 0x4b, 0x86, 0xbb, 0x52, 0x9f, 0x7d, 0xa0, 0xd5, 0x1e, 0x16, 0xa0, 0x8b, 0x30, 0x23, 0x70, 0x57, + 0x77, 0x8e, 0x64, 0xb8, 0x98, 0xc1, 0xaf, 0xfb, 0x39, 0x16, 0xe0, 0x42, 0x5e, 0x82, 0xbb, 0x31, + 0x4f, 0x30, 0x28, 0x13, 0x18, 0x19, 0xf6, 0xa4, 0x80, 0xec, 0x2f, 0x04, 0xe6, 0x5f, 0xc6, 0x81, + 0xa7, 0xf1, 0xb0, 0xfd, 0x53, 0x5f, 0xe6, 0x3a, 0xc0, 0xc0, 0x5c, 0x6e, 0xe4, 0xac, 0xe1, 0x86, + 0xf8, 0x76, 0x03, 0xae, 0x8d, 0xf2, 0x53, 0xdc, 0xa6, 0xfb, 0xe9, 0x1c, 0x18, 0xab, 0xfd, 0x47, + 0xe6, 0xd2, 0x1f, 0x04, 0x66, 0x0f, 0xcf, 0x1c, 0xbd, 0x5b, 0x6f, 0x60, 0xc4, 0x53, 0xb0, 0x9a, + 0xe3, 0x50, 0x0b, 0x6f, 0xf6, 0xca, 0xc7, 0x5f, 0x7f, 0xbe, 0x4e, 0x2c, 0xda, 0x0b, 0x07, 0x37, + 0x01, 0xab, 0xae, 0x4b, 0xb1, 0xa4, 0xa4, 0x36, 0xc9, 0x32, 0xfd, 0x4d, 0xe0, 0xd2, 0xb1, 0x93, + 0x43, 0xef, 0xd7, 0x7b, 0x38, 0xe9, 0x05, 0x58, 0x0f, 0xc6, 0xe6, 0x97, 0x41, 0x9a, 0x79, 0x90, + 0x3b, 0xd4, 0x1d, 0x19, 0x64, 0x6f, 0x68, 0x2a, 0xf6, 0xd9, 0xf0, 0x78, 0xfe, 0x25, 0x70, 0xf9, + 0xf8, 0x7f, 0x48, 0x4f, 0xe1, 0xeb, 0xc4, 0x69, 0xb4, 0x1e, 0x8e, 0x2f, 0x50, 0x26, 0xdb, 0xc8, + 0x93, 0xad, 0x59, 0xad, 0xb3, 0x27, 0x63, 0x7b, 0x83, 0x0f, 0x87, 0x07, 0xfb, 0x4d, 0xb2, 0xdc, + 0xfa, 0x46, 0xe0, 0x86, 0x2f, 0x77, 0x6a, 0x6d, 0xb5, 0x66, 0x06, 0x33, 0xbb, 0x99, 0x6d, 0xe3, + 0x4d, 0xf2, 0x66, 0xa3, 0x24, 0x85, 0x32, 0xf2, 0x44, 0xe8, 0xc8, 0x24, 0x64, 0x21, 0x8a, 0x7c, + 0x57, 0xb3, 0xe2, 0xc8, 0x8b, 0xb9, 0x1a, 0xbd, 0xf8, 0xef, 0x1d, 0x00, 0xbe, 0x4f, 0x98, 0x6b, + 0x85, 0xde, 0x6a, 0x06, 0x57, 0x9b, 0x33, 0x71, 0x5e, 0xb9, 0xdd, 0xf3, 0xb9, 0xe8, 0xed, 0x7f, + 0x01, 0x00, 0x00, 0xff, 0xff, 0x05, 0xef, 0x37, 0xb4, 0xbf, 0x06, 0x00, 0x00, } diff --git a/vendor/google.golang.org/genproto/googleapis/devtools/clouddebugger/v2/data.pb.go b/vendor/google.golang.org/genproto/googleapis/devtools/clouddebugger/v2/data.pb.go index 0235d926..b41e215e 100644 --- a/vendor/google.golang.org/genproto/googleapis/devtools/clouddebugger/v2/data.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/devtools/clouddebugger/v2/data.pb.go @@ -659,31 +659,34 @@ func (m *Breakpoint) GetLabels() map[string]string { return nil } -// Represents the application to debug. The application may include one or more +// Represents the debugged application. The application may include one or more // replicated processes executing the same code. Each of these processes is // attached with a debugger agent, carrying out the debugging commands. -// The agents attached to the same debuggee are identified by using exactly the -// same field values when registering. +// Agents attached to the same debuggee identify themselves as such by using +// exactly the same Debuggee message value when registering. type Debuggee struct { // Unique identifier for the debuggee generated by the controller service. Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` // Project the debuggee is associated with. - // Use the project number when registering a Google Cloud Platform project. + // Use project number or id when registering a Google Cloud Platform project. Project string `protobuf:"bytes,2,opt,name=project" json:"project,omitempty"` - // Debuggee uniquifier within the project. - // Any string that identifies the application within the project can be used. - // Including environment and version or build IDs is recommended. + // Uniquifier to further distiguish the application. + // It is possible that different applications might have identical values in + // the debuggee message, thus, incorrectly identified as a single application + // by the Controller service. This field adds salt to further distiguish the + // application. Agents should consider seeding this field with value that + // identifies the code, binary, configuration and environment. Uniquifier string `protobuf:"bytes,3,opt,name=uniquifier" json:"uniquifier,omitempty"` // Human readable description of the debuggee. // Including a human-readable project name, environment name and version // information is recommended. Description string `protobuf:"bytes,4,opt,name=description" json:"description,omitempty"` - // If set to `true`, indicates that the debuggee is considered as inactive by - // the Controller service. + // If set to `true`, indicates that Controller service does not detect any + // activity from the debuggee agents and the application is possibly stopped. IsInactive bool `protobuf:"varint,5,opt,name=is_inactive,json=isInactive" json:"is_inactive,omitempty"` - // Version ID of the agent release. The version ID is structured as - // following: `domain/type/vmajor.minor` (for example - // `google.com/gcp-java/v1.1`). + // Version ID of the agent. + // Schema: `domain/language-platform/vmajor.minor` (for example + // `google.com/java-gcp/v1.1`). AgentVersion string `protobuf:"bytes,6,opt,name=agent_version,json=agentVersion" json:"agent_version,omitempty"` // If set to `true`, indicates that the agent should disable itself and // detach from the debuggee. @@ -694,17 +697,11 @@ type Debuggee struct { Status *StatusMessage `protobuf:"bytes,8,opt,name=status" json:"status,omitempty"` // References to the locations and revisions of the source code used in the // deployed application. - // - // NOTE: This field is deprecated. Consumers should use - // `ext_source_contexts` if it is not empty. Debug agents should populate - // both this field and `ext_source_contexts`. SourceContexts []*google_devtools_source_v1.SourceContext `protobuf:"bytes,9,rep,name=source_contexts,json=sourceContexts" json:"source_contexts,omitempty"` // References to the locations and revisions of the source code used in the // deployed application. // - // Contexts describing a remote repo related to the source code - // have a `category` label of `remote_repo`. Source snapshot source - // contexts have a `category` of `snapshot`. + // NOTE: this field is experimental and can be ignored. ExtSourceContexts []*google_devtools_source_v1.ExtendedSourceContext `protobuf:"bytes,13,rep,name=ext_source_contexts,json=extSourceContexts" json:"ext_source_contexts,omitempty"` // A set of custom debuggee properties, populated by the agent, to be // displayed to the user. @@ -809,83 +806,84 @@ func init() { func init() { proto.RegisterFile("google/devtools/clouddebugger/v2/data.proto", fileDescriptor1) } var fileDescriptor1 = []byte{ - // 1239 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0x5f, 0x73, 0xda, 0xc6, - 0x16, 0x0f, 0x7f, 0x0c, 0xd2, 0xc1, 0x60, 0x65, 0x6f, 0x72, 0x47, 0xf1, 0xcd, 0x75, 0x18, 0x6e, - 0x1e, 0x3c, 0xb7, 0x19, 0x48, 0xc8, 0xb4, 0x93, 0x34, 0x4f, 0x18, 0xcb, 0x2e, 0x13, 0x02, 0x64, - 0xb1, 0xdd, 0x4e, 0x5f, 0xd4, 0x35, 0x5a, 0x54, 0x35, 0x42, 0x52, 0x77, 0x17, 0xea, 0xbc, 0x76, - 0xf2, 0x31, 0xfa, 0x11, 0xfa, 0x9d, 0xfa, 0xd6, 0xcf, 0xd1, 0xd9, 0xd5, 0x8a, 0x88, 0xa4, 0x2d, - 0x71, 0x93, 0xb7, 0xb3, 0xbf, 0xfd, 0x9d, 0xdf, 0x8a, 0xb3, 0xbf, 0x73, 0x24, 0xe0, 0x33, 0x3f, - 0x8e, 0xfd, 0x90, 0x76, 0x3c, 0xba, 0x12, 0x71, 0x1c, 0xf2, 0xce, 0x2c, 0x8c, 0x97, 0x9e, 0x47, - 0x2f, 0x97, 0xbe, 0x4f, 0x59, 0x67, 0xd5, 0xed, 0x78, 0x44, 0x90, 0x76, 0xc2, 0x62, 0x11, 0xa3, - 0x66, 0x4a, 0x6e, 0x67, 0xe4, 0xf6, 0x06, 0xb9, 0xbd, 0xea, 0xee, 0xdf, 0xd5, 0x72, 0x24, 0x09, - 0x3a, 0x24, 0x8a, 0x62, 0x41, 0x44, 0x10, 0x47, 0x3c, 0xcd, 0xdf, 0x6f, 0xbf, 0x7b, 0x18, 0x8f, - 0x97, 0x6c, 0x46, 0x3b, 0xab, 0x47, 0x3a, 0x72, 0x67, 0x71, 0x24, 0xe8, 0x95, 0xd0, 0xfc, 0x7b, - 0x9a, 0xaf, 0x56, 0x97, 0xcb, 0x79, 0x47, 0x04, 0x0b, 0xca, 0x05, 0x59, 0x24, 0x9a, 0x70, 0xf0, - 0x2e, 0xe1, 0x27, 0x46, 0x92, 0x84, 0x32, 0x7d, 0x60, 0xeb, 0x14, 0xea, 0x27, 0x31, 0x5b, 0x10, - 0xf1, 0x82, 0x72, 0x4e, 0x7c, 0x8a, 0xfe, 0x0d, 0x95, 0xb9, 0x02, 0xec, 0x42, 0xb3, 0x70, 0x68, - 0x62, 0xbd, 0x42, 0x07, 0x00, 0x09, 0x61, 0x64, 0x41, 0x05, 0x65, 0xdc, 0x2e, 0x36, 0x4b, 0x87, - 0x26, 0xce, 0x21, 0xad, 0x37, 0x25, 0xa8, 0x4f, 0x05, 0x11, 0x4b, 0x9e, 0x29, 0xdd, 0x01, 0x23, - 0xe0, 0x2e, 0x65, 0x2c, 0x66, 0x4a, 0xcb, 0xc0, 0xd5, 0x80, 0x3b, 0x72, 0x89, 0x2e, 0xc0, 0x64, - 0x74, 0x4e, 0x19, 0x77, 0x45, 0x6c, 0x17, 0x9b, 0x85, 0xc3, 0x46, 0xf7, 0x69, 0x7b, 0x5b, 0xe9, - 0xda, 0x1b, 0xf2, 0x6d, 0x2c, 0x05, 0x68, 0x34, 0xa3, 0xd8, 0x48, 0xb5, 0xce, 0x62, 0xf4, 0x12, - 0x6a, 0x1e, 0xe5, 0x33, 0x16, 0x24, 0xb2, 0xa8, 0x76, 0xa9, 0x59, 0x38, 0xac, 0x75, 0x3b, 0xdb, - 0x95, 0x37, 0x4a, 0x80, 0xf3, 0x1a, 0xad, 0x5f, 0x0b, 0x60, 0xae, 0x8f, 0x42, 0x7b, 0x50, 0x3b, - 0x1f, 0x4d, 0x27, 0x4e, 0x7f, 0x70, 0x32, 0x70, 0x8e, 0xad, 0x1b, 0xe8, 0x00, 0xf6, 0x8f, 0xb0, - 0xd3, 0x7b, 0x3e, 0x19, 0x0f, 0x46, 0x67, 0xee, 0x74, 0x7c, 0x8e, 0xfb, 0x8e, 0x3b, 0x1c, 0xf7, - 0x7b, 0x67, 0x83, 0xf1, 0xc8, 0x2a, 0x21, 0x1b, 0x6e, 0xe5, 0xf6, 0xfb, 0xe3, 0xd1, 0xf1, 0x40, - 0xed, 0x94, 0xd1, 0x1d, 0xb8, 0x9d, 0xdb, 0x71, 0xbe, 0x99, 0x60, 0x67, 0x3a, 0x95, 0x5b, 0x55, - 0x84, 0xa0, 0x91, 0xdb, 0xea, 0x9d, 0x3a, 0x96, 0x81, 0x6e, 0x42, 0xfd, 0xa2, 0x87, 0x07, 0xbd, - 0xa3, 0xa1, 0xe3, 0x8e, 0x7a, 0x2f, 0x1c, 0x6b, 0x47, 0xd2, 0xd6, 0xd0, 0x45, 0x6f, 0x78, 0xee, - 0x58, 0x95, 0xd6, 0x13, 0x68, 0x4c, 0x95, 0x51, 0x86, 0xf1, 0x4c, 0x39, 0x0b, 0x21, 0x28, 0x27, - 0x44, 0x7c, 0xaf, 0xaf, 0x53, 0xc5, 0x12, 0x0b, 0x83, 0x88, 0xaa, 0xd2, 0xef, 0x60, 0x15, 0xb7, - 0x7e, 0x29, 0x82, 0x71, 0x41, 0x58, 0x40, 0x2e, 0x43, 0x2a, 0x09, 0x11, 0x59, 0xd0, 0x2c, 0x49, - 0xc6, 0xe8, 0x16, 0xec, 0xac, 0x48, 0xb8, 0x4c, 0xb3, 0x4c, 0x9c, 0x2e, 0x24, 0x53, 0xbc, 0x4e, - 0xa8, 0x5d, 0x49, 0x99, 0x32, 0x46, 0xc7, 0x50, 0x5d, 0xd0, 0xc5, 0xa5, 0x34, 0x4a, 0xa9, 0x59, - 0x3a, 0xac, 0x75, 0xff, 0xbf, 0xfd, 0x0a, 0xb2, 0xa3, 0x71, 0x96, 0x8a, 0xfa, 0xb0, 0xb7, 0x22, - 0xcc, 0x15, 0x12, 0x75, 0x83, 0xc8, 0xa3, 0x57, 0x76, 0x59, 0x5d, 0xe8, 0x7f, 0x32, 0xb5, 0xcc, - 0xd4, 0xed, 0x41, 0x24, 0x1e, 0x77, 0x2f, 0xe4, 0xf3, 0xe0, 0xfa, 0x8a, 0xb0, 0x33, 0x99, 0x32, - 0x90, 0x19, 0xe8, 0x14, 0x2a, 0x5c, 0xd9, 0xc6, 0xde, 0xf9, 0x50, 0x33, 0x6c, 0xd8, 0x0c, 0xeb, - 0xf4, 0xd6, 0x9b, 0x22, 0xc0, 0x54, 0x90, 0xd9, 0xab, 0x13, 0x69, 0x79, 0xb4, 0x0f, 0xc6, 0x7c, - 0x19, 0xcd, 0x94, 0xcd, 0xd2, 0x22, 0xad, 0xd7, 0x68, 0x08, 0x46, 0xa8, 0xab, 0xaf, 0x6a, 0x55, - 0xeb, 0x3e, 0xfc, 0x80, 0x53, 0x37, 0x6e, 0x0d, 0xaf, 0x15, 0xd0, 0x57, 0x60, 0x12, 0xe6, 0x2f, - 0x17, 0x34, 0x12, 0xff, 0xa4, 0x9c, 0x6f, 0x93, 0xd1, 0x11, 0x54, 0xa4, 0x6a, 0xc8, 0xed, 0xf2, - 0xb5, 0x65, 0x74, 0x66, 0xeb, 0x37, 0x03, 0xe0, 0x88, 0x51, 0xf2, 0x2a, 0x89, 0x83, 0x48, 0xa0, - 0x06, 0x14, 0x03, 0x4f, 0x17, 0xa0, 0x18, 0x78, 0xe8, 0x39, 0x54, 0x48, 0x5a, 0x94, 0xba, 0xea, - 0xea, 0xc7, 0xdb, 0x8f, 0x78, 0xab, 0xd6, 0xee, 0xa9, 0x54, 0xac, 0x25, 0x3e, 0x71, 0x1d, 0xef, - 0x82, 0x39, 0x8b, 0x23, 0x2f, 0x58, 0x4f, 0x06, 0x13, 0xbf, 0x05, 0x50, 0x13, 0x6a, 0xf4, 0x2a, - 0x61, 0x94, 0x73, 0x39, 0x8d, 0x55, 0x81, 0x4c, 0x9c, 0x87, 0xd0, 0x03, 0x40, 0x61, 0xec, 0xbb, - 0x8b, 0xd4, 0x17, 0xae, 0x1e, 0x92, 0x0d, 0x25, 0x64, 0x85, 0xb1, 0xaf, 0x0d, 0x93, 0x8e, 0x12, - 0x84, 0xc1, 0x94, 0xec, 0x90, 0xae, 0x68, 0x68, 0xef, 0xa9, 0x5a, 0x7c, 0x7e, 0xad, 0x5a, 0x0c, - 0x63, 0x7f, 0x28, 0x93, 0xe5, 0x2f, 0x48, 0x23, 0x74, 0x1f, 0x1a, 0x01, 0x77, 0xe7, 0x41, 0x44, - 0x42, 0x57, 0xba, 0x92, 0x2a, 0x4f, 0x1b, 0x78, 0x37, 0xe0, 0x27, 0x12, 0x94, 0xc6, 0xa5, 0xe8, - 0x19, 0xd4, 0x66, 0x8c, 0x12, 0x41, 0x5d, 0xf9, 0x2e, 0xb0, 0x6b, 0xaa, 0x70, 0xfb, 0xef, 0xb5, - 0xcc, 0x59, 0xf6, 0xa2, 0xc0, 0x90, 0xd2, 0x25, 0x80, 0x9e, 0x02, 0xa4, 0xfa, 0x2a, 0x77, 0x77, - 0x6b, 0xae, 0xa9, 0xd8, 0x2a, 0xf5, 0xbf, 0x00, 0x4b, 0x4e, 0x99, 0x4b, 0x17, 0x24, 0x08, 0x6d, - 0x2b, 0x2d, 0xb0, 0x44, 0x1c, 0x09, 0xe4, 0x1a, 0x11, 0x3e, 0xaa, 0x11, 0xd1, 0x18, 0x76, 0xb9, - 0xec, 0x43, 0x77, 0x2e, 0x1b, 0x91, 0xdb, 0x55, 0xe5, 0xe5, 0x07, 0x1f, 0x24, 0xa7, 0xbb, 0x17, - 0xd7, 0xf8, 0x3a, 0xe6, 0xc8, 0x85, 0xdb, 0x54, 0xce, 0x32, 0x22, 0xa8, 0xe7, 0xe6, 0x4d, 0x60, - 0x5c, 0xbb, 0x4b, 0x6e, 0xad, 0x85, 0x9c, 0x9c, 0x73, 0x5e, 0x42, 0x63, 0xa5, 0x19, 0xe9, 0x34, - 0xb3, 0xcd, 0x6b, 0x2b, 0xd7, 0x33, 0x05, 0x35, 0xdb, 0xd0, 0x04, 0x2a, 0x21, 0xb9, 0xa4, 0x21, - 0xb7, 0x6f, 0x2a, 0xa9, 0x27, 0xd7, 0xf3, 0x96, 0x4a, 0x75, 0x22, 0xc1, 0x5e, 0x63, 0xad, 0xb3, - 0xff, 0x14, 0x6a, 0x39, 0x18, 0x59, 0x50, 0x7a, 0x45, 0x5f, 0xeb, 0xce, 0x96, 0xe1, 0x9f, 0x8f, - 0xff, 0x2f, 0x8b, 0x4f, 0x0a, 0xad, 0x03, 0xa8, 0xa4, 0x9d, 0x8b, 0x6a, 0x50, 0xed, 0xf7, 0x26, - 0x67, 0xe7, 0xd8, 0xb1, 0x6e, 0xa0, 0x2a, 0x94, 0x86, 0xe3, 0x53, 0xab, 0xd0, 0x7a, 0x00, 0x46, - 0xe6, 0x66, 0x64, 0x40, 0x79, 0x30, 0x3a, 0x19, 0x5b, 0x37, 0x24, 0xf7, 0xeb, 0x1e, 0x1e, 0x0d, - 0x46, 0xa7, 0x56, 0x01, 0x99, 0xb0, 0xe3, 0x60, 0x3c, 0xc6, 0x56, 0xb1, 0xf5, 0x7b, 0x19, 0x8c, - 0xe3, 0xf4, 0xb9, 0xe9, 0x7b, 0xf3, 0xc5, 0x86, 0x6a, 0xc2, 0xe2, 0x1f, 0xe8, 0x4c, 0xe8, 0xc7, - 0xc8, 0x96, 0xf2, 0xfb, 0x64, 0x19, 0x05, 0x3f, 0x2e, 0x83, 0x79, 0x40, 0x99, 0xee, 0xef, 0x1c, - 0x22, 0x1b, 0x3c, 0xff, 0x69, 0x50, 0x56, 0x84, 0x3c, 0x84, 0xee, 0x41, 0x2d, 0xe0, 0x6e, 0x10, - 0xc9, 0xe9, 0xb3, 0xca, 0x7a, 0x0b, 0x02, 0x3e, 0xd0, 0x08, 0xfa, 0x1f, 0xd4, 0x89, 0x4f, 0x23, - 0xe1, 0xae, 0x28, 0x93, 0x37, 0xab, 0xdf, 0x79, 0xbb, 0x0a, 0xbc, 0x48, 0x31, 0xad, 0xe2, 0x05, - 0x5c, 0xde, 0x93, 0x67, 0x57, 0x33, 0x95, 0x63, 0x8d, 0xe4, 0x1a, 0xc1, 0xf8, 0xb8, 0x46, 0x78, - 0x09, 0x7b, 0x9b, 0xdf, 0x84, 0x5c, 0xfb, 0xea, 0xf0, 0x3d, 0xc5, 0x94, 0xd7, 0x5e, 0x3d, 0xd2, - 0xe3, 0xb1, 0x9f, 0x26, 0xe0, 0x06, 0xcf, 0x2f, 0x39, 0xfa, 0x0e, 0xfe, 0x45, 0xaf, 0x84, 0xfb, - 0xae, 0x6c, 0x5d, 0xc9, 0x3e, 0xfc, 0x1b, 0x59, 0xe7, 0x4a, 0xd0, 0xc8, 0xa3, 0xde, 0xa6, 0xfc, - 0x4d, 0x7a, 0x25, 0xa6, 0x9b, 0x27, 0x8c, 0xd6, 0xc6, 0xad, 0x29, 0xd1, 0x2f, 0xb6, 0xff, 0xfa, - 0xcc, 0x0c, 0x9f, 0xd8, 0xb6, 0x47, 0x3f, 0x17, 0xe0, 0xfe, 0x2c, 0x5e, 0x6c, 0x7d, 0x80, 0x23, - 0xf3, 0x98, 0x08, 0x32, 0x91, 0xc3, 0x6f, 0x52, 0xf8, 0xf6, 0x85, 0xa6, 0xfb, 0x71, 0x48, 0x22, - 0xbf, 0x1d, 0x33, 0xbf, 0xe3, 0xd3, 0x48, 0x8d, 0xc6, 0x4e, 0xba, 0x45, 0x92, 0x80, 0xff, 0xf5, - 0xbf, 0x85, 0x67, 0x1b, 0xc0, 0x65, 0x45, 0x65, 0x3e, 0xfe, 0x23, 0x00, 0x00, 0xff, 0xff, 0x00, - 0xbf, 0x9b, 0x7e, 0x66, 0x0c, 0x00, 0x00, + // 1251 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xdd, 0x72, 0xda, 0x46, + 0x14, 0x0e, 0x3f, 0x06, 0xe9, 0x60, 0x30, 0xd9, 0x26, 0x1d, 0xc5, 0x4d, 0x1d, 0x86, 0xe6, 0xc2, + 0xd3, 0x66, 0x20, 0x21, 0xd3, 0x4e, 0xd2, 0x5c, 0x61, 0x2c, 0xbb, 0x4c, 0x08, 0x90, 0xc5, 0xa6, + 0x9d, 0xde, 0xa8, 0x6b, 0xb4, 0xa8, 0x6a, 0x84, 0xa4, 0xee, 0x2e, 0xd4, 0xb9, 0xcf, 0x63, 0xb4, + 0x2f, 0xd0, 0xe9, 0x3b, 0xf5, 0xae, 0xcf, 0xd1, 0xd9, 0xd5, 0x8a, 0x88, 0xa4, 0x2d, 0x71, 0x93, + 0xbb, 0xb3, 0xdf, 0x7e, 0xe7, 0x5b, 0x71, 0xf6, 0x3b, 0x47, 0x02, 0xbe, 0xf0, 0xa2, 0xc8, 0x0b, + 0x68, 0xdb, 0xa5, 0x2b, 0x11, 0x45, 0x01, 0x6f, 0xcf, 0x82, 0x68, 0xe9, 0xba, 0xf4, 0x62, 0xe9, + 0x79, 0x94, 0xb5, 0x57, 0x9d, 0xb6, 0x4b, 0x04, 0x69, 0xc5, 0x2c, 0x12, 0x11, 0x6a, 0x24, 0xe4, + 0x56, 0x4a, 0x6e, 0x6d, 0x90, 0x5b, 0xab, 0xce, 0xfe, 0x6d, 0x2d, 0x47, 0x62, 0xbf, 0x4d, 0xc2, + 0x30, 0x12, 0x44, 0xf8, 0x51, 0xc8, 0x93, 0xfc, 0xfd, 0xd6, 0x9b, 0x87, 0xf1, 0x68, 0xc9, 0x66, + 0xb4, 0xbd, 0x7a, 0xa0, 0x23, 0x67, 0x16, 0x85, 0x82, 0x5e, 0x0a, 0xcd, 0xbf, 0xa3, 0xf9, 0x6a, + 0x75, 0xb1, 0x9c, 0xb7, 0x85, 0xbf, 0xa0, 0x5c, 0x90, 0x45, 0xac, 0x09, 0x07, 0x6f, 0x12, 0x7e, + 0x61, 0x24, 0x8e, 0x29, 0xd3, 0x07, 0x36, 0x4f, 0xa1, 0x7a, 0x12, 0xb1, 0x05, 0x11, 0xcf, 0x28, + 0xe7, 0xc4, 0xa3, 0xe8, 0x63, 0x28, 0xcd, 0x15, 0x60, 0xe5, 0x1a, 0xb9, 0x43, 0x13, 0xeb, 0x15, + 0x3a, 0x00, 0x88, 0x09, 0x23, 0x0b, 0x2a, 0x28, 0xe3, 0x56, 0xbe, 0x51, 0x38, 0x34, 0x71, 0x06, + 0x69, 0xbe, 0x2a, 0x40, 0x75, 0x22, 0x88, 0x58, 0xf2, 0x54, 0xe9, 0x16, 0x18, 0x3e, 0x77, 0x28, + 0x63, 0x11, 0x53, 0x5a, 0x06, 0x2e, 0xfb, 0xdc, 0x96, 0x4b, 0x34, 0x05, 0x93, 0xd1, 0x39, 0x65, + 0xdc, 0x11, 0x91, 0x95, 0x6f, 0xe4, 0x0e, 0x6b, 0x9d, 0xc7, 0xad, 0x6d, 0xa5, 0x6b, 0x6d, 0xc8, + 0xb7, 0xb0, 0x14, 0xa0, 0xe1, 0x8c, 0x62, 0x23, 0xd1, 0x3a, 0x8b, 0xd0, 0x73, 0xa8, 0xb8, 0x94, + 0xcf, 0x98, 0x1f, 0xcb, 0xa2, 0x5a, 0x85, 0x46, 0xee, 0xb0, 0xd2, 0x69, 0x6f, 0x57, 0xde, 0x28, + 0x01, 0xce, 0x6a, 0x34, 0xff, 0xc8, 0x81, 0xb9, 0x3e, 0x0a, 0xed, 0x41, 0xe5, 0x7c, 0x38, 0x19, + 0xdb, 0xbd, 0xfe, 0x49, 0xdf, 0x3e, 0xae, 0x5f, 0x43, 0x07, 0xb0, 0x7f, 0x84, 0xed, 0xee, 0xd3, + 0xf1, 0xa8, 0x3f, 0x3c, 0x73, 0x26, 0xa3, 0x73, 0xdc, 0xb3, 0x9d, 0xc1, 0xa8, 0xd7, 0x3d, 0xeb, + 0x8f, 0x86, 0xf5, 0x02, 0xb2, 0xe0, 0x46, 0x66, 0xbf, 0x37, 0x1a, 0x1e, 0xf7, 0xd5, 0x4e, 0x11, + 0xdd, 0x82, 0x9b, 0x99, 0x1d, 0xfb, 0xbb, 0x31, 0xb6, 0x27, 0x13, 0xb9, 0x55, 0x46, 0x08, 0x6a, + 0x99, 0xad, 0xee, 0xa9, 0x5d, 0x37, 0xd0, 0x75, 0xa8, 0x4e, 0xbb, 0xb8, 0xdf, 0x3d, 0x1a, 0xd8, + 0xce, 0xb0, 0xfb, 0xcc, 0xae, 0xef, 0x48, 0xda, 0x1a, 0x9a, 0x76, 0x07, 0xe7, 0x76, 0xbd, 0xd4, + 0x7c, 0x04, 0xb5, 0x89, 0x32, 0xca, 0x20, 0x9a, 0x29, 0x67, 0x21, 0x04, 0xc5, 0x98, 0x88, 0x1f, + 0xf5, 0x75, 0xaa, 0x58, 0x62, 0x81, 0x1f, 0x52, 0x55, 0xfa, 0x1d, 0xac, 0xe2, 0xe6, 0xaf, 0x79, + 0x30, 0xa6, 0x84, 0xf9, 0xe4, 0x22, 0xa0, 0x92, 0x10, 0x92, 0x05, 0x4d, 0x93, 0x64, 0x8c, 0x6e, + 0xc0, 0xce, 0x8a, 0x04, 0xcb, 0x24, 0xcb, 0xc4, 0xc9, 0x42, 0x32, 0xc5, 0xcb, 0x98, 0x5a, 0xa5, + 0x84, 0x29, 0x63, 0x74, 0x0c, 0xe5, 0x05, 0x5d, 0x5c, 0x48, 0xa3, 0x14, 0x1a, 0x85, 0xc3, 0x4a, + 0xe7, 0xf3, 0xed, 0x57, 0x90, 0x1e, 0x8d, 0xd3, 0x54, 0xd4, 0x83, 0xbd, 0x15, 0x61, 0x8e, 0x90, + 0xa8, 0xe3, 0x87, 0x2e, 0xbd, 0xb4, 0x8a, 0xea, 0x42, 0x3f, 0x49, 0xd5, 0x52, 0x53, 0xb7, 0xfa, + 0xa1, 0x78, 0xd8, 0x99, 0xca, 0xe7, 0xc1, 0xd5, 0x15, 0x61, 0x67, 0x32, 0xa5, 0x2f, 0x33, 0xd0, + 0x29, 0x94, 0xb8, 0xb2, 0x8d, 0xb5, 0xf3, 0xae, 0x66, 0xd8, 0xb0, 0x19, 0xd6, 0xe9, 0xcd, 0x57, + 0x79, 0x80, 0x89, 0x20, 0xb3, 0x17, 0x27, 0xd2, 0xf2, 0x68, 0x1f, 0x8c, 0xf9, 0x32, 0x9c, 0x29, + 0x9b, 0x25, 0x45, 0x5a, 0xaf, 0xd1, 0x00, 0x8c, 0x40, 0x57, 0x5f, 0xd5, 0xaa, 0xd2, 0xb9, 0xff, + 0x0e, 0xa7, 0x6e, 0xdc, 0x1a, 0x5e, 0x2b, 0xa0, 0x6f, 0xc0, 0x24, 0xcc, 0x5b, 0x2e, 0x68, 0x28, + 0xfe, 0x4f, 0x39, 0x5f, 0x27, 0xa3, 0x23, 0x28, 0x49, 0xd5, 0x80, 0x5b, 0xc5, 0x2b, 0xcb, 0xe8, + 0xcc, 0xe6, 0x9f, 0x06, 0xc0, 0x11, 0xa3, 0xe4, 0x45, 0x1c, 0xf9, 0xa1, 0x40, 0x35, 0xc8, 0xfb, + 0xae, 0x2e, 0x40, 0xde, 0x77, 0xd1, 0x53, 0x28, 0x91, 0xa4, 0x28, 0x55, 0xd5, 0xd5, 0x0f, 0xb7, + 0x1f, 0xf1, 0x5a, 0xad, 0xd5, 0x55, 0xa9, 0x58, 0x4b, 0x7c, 0xe0, 0x3a, 0xde, 0x06, 0x73, 0x16, + 0x85, 0xae, 0xbf, 0x9e, 0x0c, 0x26, 0x7e, 0x0d, 0xa0, 0x06, 0x54, 0xe8, 0x65, 0xcc, 0x28, 0xe7, + 0x72, 0x1a, 0xab, 0x02, 0x99, 0x38, 0x0b, 0xa1, 0x7b, 0x80, 0x82, 0xc8, 0x73, 0x16, 0x89, 0x2f, + 0x1c, 0x3d, 0x24, 0x6b, 0x4a, 0xa8, 0x1e, 0x44, 0x9e, 0x36, 0x4c, 0x32, 0x4a, 0x10, 0x06, 0x53, + 0xb2, 0x03, 0xba, 0xa2, 0x81, 0xb5, 0xa7, 0x6a, 0xf1, 0xe5, 0x95, 0x6a, 0x31, 0x88, 0xbc, 0x81, + 0x4c, 0x96, 0xbf, 0x20, 0x89, 0xd0, 0x5d, 0xa8, 0xf9, 0xdc, 0x99, 0xfb, 0x21, 0x09, 0x1c, 0xe9, + 0x4a, 0xaa, 0x3c, 0x6d, 0xe0, 0x5d, 0x9f, 0x9f, 0x48, 0x50, 0x1a, 0x97, 0xa2, 0x27, 0x50, 0x99, + 0x31, 0x4a, 0x04, 0x75, 0xe4, 0xbb, 0xc0, 0xaa, 0xa8, 0xc2, 0xed, 0xbf, 0xd5, 0x32, 0x67, 0xe9, + 0x8b, 0x02, 0x43, 0x42, 0x97, 0x00, 0x7a, 0x0c, 0x90, 0xe8, 0xab, 0xdc, 0xdd, 0xad, 0xb9, 0xa6, + 0x62, 0xab, 0xd4, 0x4f, 0x01, 0x96, 0x9c, 0x32, 0x87, 0x2e, 0x88, 0x1f, 0x58, 0xf5, 0xa4, 0xc0, + 0x12, 0xb1, 0x25, 0x90, 0x69, 0x44, 0x78, 0xaf, 0x46, 0x44, 0x23, 0xd8, 0xe5, 0xb2, 0x0f, 0x9d, + 0xb9, 0x6c, 0x44, 0x6e, 0x95, 0x95, 0x97, 0xef, 0xbd, 0x93, 0x9c, 0xee, 0x5e, 0x5c, 0xe1, 0xeb, + 0x98, 0x23, 0x07, 0x6e, 0x52, 0x39, 0xcb, 0x88, 0xa0, 0xae, 0x93, 0x35, 0x81, 0x71, 0xe5, 0x2e, + 0xb9, 0xb1, 0x16, 0xb2, 0x33, 0xce, 0x79, 0x0e, 0xb5, 0x95, 0x66, 0x24, 0xd3, 0xcc, 0x32, 0xaf, + 0xac, 0x5c, 0x4d, 0x15, 0xd4, 0x6c, 0x43, 0x63, 0x28, 0x05, 0xe4, 0x82, 0x06, 0xdc, 0xba, 0xae, + 0xa4, 0x1e, 0x5d, 0xcd, 0x5b, 0x2a, 0xd5, 0x0e, 0x05, 0x7b, 0x89, 0xb5, 0xce, 0xfe, 0x63, 0xa8, + 0x64, 0x60, 0x54, 0x87, 0xc2, 0x0b, 0xfa, 0x52, 0x77, 0xb6, 0x0c, 0xff, 0x79, 0xfc, 0x7f, 0x9d, + 0x7f, 0x94, 0x6b, 0x1e, 0x40, 0x29, 0xe9, 0x5c, 0x54, 0x81, 0x72, 0xaf, 0x3b, 0x3e, 0x3b, 0xc7, + 0x76, 0xfd, 0x1a, 0x2a, 0x43, 0x61, 0x30, 0x3a, 0xad, 0xe7, 0x9a, 0xf7, 0xc0, 0x48, 0xdd, 0x8c, + 0x0c, 0x28, 0xf6, 0x87, 0x27, 0xa3, 0xfa, 0x35, 0xc9, 0xfd, 0xb6, 0x8b, 0x87, 0xfd, 0xe1, 0x69, + 0x3d, 0x87, 0x4c, 0xd8, 0xb1, 0x31, 0x1e, 0xe1, 0x7a, 0xbe, 0xf9, 0x57, 0x11, 0x8c, 0xe3, 0xe4, + 0xb9, 0xe9, 0x5b, 0xf3, 0xc5, 0x82, 0x72, 0xcc, 0xa2, 0x9f, 0xe8, 0x4c, 0xe8, 0xc7, 0x48, 0x97, + 0xf2, 0xfb, 0x64, 0x19, 0xfa, 0x3f, 0x2f, 0xfd, 0xb9, 0x4f, 0x99, 0xee, 0xef, 0x0c, 0x22, 0x1b, + 0x3c, 0xfb, 0x69, 0x50, 0x54, 0x84, 0x2c, 0x84, 0xee, 0x40, 0xc5, 0xe7, 0x8e, 0x1f, 0xca, 0xe9, + 0xb3, 0x4a, 0x7b, 0x0b, 0x7c, 0xde, 0xd7, 0x08, 0xfa, 0x0c, 0xaa, 0xc4, 0xa3, 0xa1, 0x70, 0x56, + 0x94, 0xc9, 0x9b, 0xd5, 0xef, 0xbc, 0x5d, 0x05, 0x4e, 0x13, 0x4c, 0xab, 0xb8, 0x3e, 0x97, 0xf7, + 0xe4, 0x5a, 0xe5, 0x54, 0xe5, 0x58, 0x23, 0x99, 0x46, 0x30, 0xde, 0xaf, 0x11, 0x9e, 0xc3, 0xde, + 0xe6, 0x37, 0x21, 0xd7, 0xbe, 0x3a, 0x7c, 0x4b, 0x31, 0xe1, 0xb5, 0x56, 0x0f, 0xf4, 0x78, 0xec, + 0x25, 0x09, 0xb8, 0xc6, 0xb3, 0x4b, 0x8e, 0x7e, 0x80, 0x8f, 0xe8, 0xa5, 0x70, 0xde, 0x94, 0xad, + 0x2a, 0xd9, 0xfb, 0xff, 0x21, 0x6b, 0x5f, 0x0a, 0x1a, 0xba, 0xd4, 0xdd, 0x94, 0xbf, 0x4e, 0x2f, + 0xc5, 0x64, 0xf3, 0x84, 0xe1, 0xda, 0xb8, 0x15, 0x25, 0xfa, 0xd5, 0xf6, 0x5f, 0x9f, 0x9a, 0xe1, + 0x03, 0xdb, 0xf6, 0xe8, 0xb7, 0x1c, 0xdc, 0x9d, 0x45, 0x8b, 0xad, 0x0f, 0x70, 0x64, 0x1e, 0x13, + 0x41, 0xc6, 0x72, 0xf8, 0x8d, 0x73, 0xdf, 0x3f, 0xd3, 0x74, 0x2f, 0x0a, 0x48, 0xe8, 0xb5, 0x22, + 0xe6, 0xb5, 0x3d, 0x1a, 0xaa, 0xd1, 0xd8, 0x4e, 0xb6, 0x48, 0xec, 0xf3, 0x7f, 0xff, 0xb7, 0xf0, + 0x64, 0x03, 0xf8, 0x3d, 0x6f, 0x9d, 0x26, 0x7a, 0x3d, 0x09, 0xa7, 0xbf, 0x95, 0xb5, 0xa6, 0x9d, + 0x8b, 0x92, 0x12, 0x7d, 0xf8, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0x06, 0xfd, 0x4c, 0xc8, 0x81, + 0x0c, 0x00, 0x00, } diff --git a/vendor/google.golang.org/genproto/googleapis/devtools/clouddebugger/v2/debugger.pb.go b/vendor/google.golang.org/genproto/googleapis/devtools/clouddebugger/v2/debugger.pb.go index 35b44e73..7454ee2e 100644 --- a/vendor/google.golang.org/genproto/googleapis/devtools/clouddebugger/v2/debugger.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/devtools/clouddebugger/v2/debugger.pb.go @@ -24,10 +24,10 @@ type SetBreakpointRequest struct { // ID of the debuggee where the breakpoint is to be set. DebuggeeId string `protobuf:"bytes,1,opt,name=debuggee_id,json=debuggeeId" json:"debuggee_id,omitempty"` // Breakpoint specification to set. - // The field 'location' of the breakpoint must be set. + // The field `location` of the breakpoint must be set. Breakpoint *Breakpoint `protobuf:"bytes,2,opt,name=breakpoint" json:"breakpoint,omitempty"` // The client version making the call. - // Following: `domain/type/version` (e.g., `google.com/intellij/v1`). + // Schema: `domain/type/version` (e.g., `google.com/intellij/v1`). ClientVersion string `protobuf:"bytes,4,opt,name=client_version,json=clientVersion" json:"client_version,omitempty"` } @@ -83,7 +83,7 @@ type GetBreakpointRequest struct { // ID of the breakpoint to get. BreakpointId string `protobuf:"bytes,2,opt,name=breakpoint_id,json=breakpointId" json:"breakpoint_id,omitempty"` // The client version making the call. - // Following: `domain/type/version` (e.g., `google.com/intellij/v1`). + // Schema: `domain/type/version` (e.g., `google.com/intellij/v1`). ClientVersion string `protobuf:"bytes,4,opt,name=client_version,json=clientVersion" json:"client_version,omitempty"` } @@ -139,7 +139,7 @@ type DeleteBreakpointRequest struct { // ID of the breakpoint to delete. BreakpointId string `protobuf:"bytes,2,opt,name=breakpoint_id,json=breakpointId" json:"breakpoint_id,omitempty"` // The client version making the call. - // Following: `domain/type/version` (e.g., `google.com/intellij/v1`). + // Schema: `domain/type/version` (e.g., `google.com/intellij/v1`). ClientVersion string `protobuf:"bytes,3,opt,name=client_version,json=clientVersion" json:"client_version,omitempty"` } @@ -191,7 +191,7 @@ type ListBreakpointsRequest struct { // should be called again with the same `wait_token`. WaitToken string `protobuf:"bytes,6,opt,name=wait_token,json=waitToken" json:"wait_token,omitempty"` // The client version making the call. - // Following: `domain/type/version` (e.g., `google.com/intellij/v1`). + // Schema: `domain/type/version` (e.g., `google.com/intellij/v1`). ClientVersion string `protobuf:"bytes,8,opt,name=client_version,json=clientVersion" json:"client_version,omitempty"` } @@ -279,7 +279,7 @@ type ListBreakpointsResponse struct { // List of breakpoints matching the request. // The fields `id` and `location` are guaranteed to be set on each breakpoint. // The fields: `stack_frames`, `evaluated_expressions` and `variable_table` - // are cleared on each breakpoint regardless of it's status. + // are cleared on each breakpoint regardless of its status. Breakpoints []*Breakpoint `protobuf:"bytes,1,rep,name=breakpoints" json:"breakpoints,omitempty"` // A wait token that can be used in the next call to `list` (REST) or // `ListBreakpoints` (RPC) to block until the list of breakpoints has changes. @@ -313,7 +313,7 @@ type ListDebuggeesRequest struct { // result includes only debuggees that are active. IncludeInactive bool `protobuf:"varint,3,opt,name=include_inactive,json=includeInactive" json:"include_inactive,omitempty"` // The client version making the call. - // Following: `domain/type/version` (e.g., `google.com/intellij/v1`). + // Schema: `domain/type/version` (e.g., `google.com/intellij/v1`). ClientVersion string `protobuf:"bytes,4,opt,name=client_version,json=clientVersion" json:"client_version,omitempty"` } @@ -346,10 +346,9 @@ func (m *ListDebuggeesRequest) GetClientVersion() string { // Response for listing debuggees. type ListDebuggeesResponse struct { // List of debuggees accessible to the calling user. - // Note that the `description` field is the only human readable field - // that should be displayed to the user. - // The fields `debuggee.id` and `description` fields are guaranteed to be - // set on each debuggee. + // The fields `debuggee.id` and `description` are guaranteed to be set. + // The `description` field is a human readable field provided by agents and + // can be displayed to users. Debuggees []*Debuggee `protobuf:"bytes,1,rep,name=debuggees" json:"debuggees,omitempty"` } @@ -397,7 +396,7 @@ type Debugger2Client interface { DeleteBreakpoint(ctx context.Context, in *DeleteBreakpointRequest, opts ...grpc.CallOption) (*google_protobuf3.Empty, error) // Lists all breakpoints for the debuggee. ListBreakpoints(ctx context.Context, in *ListBreakpointsRequest, opts ...grpc.CallOption) (*ListBreakpointsResponse, error) - // Lists all the debuggees that the user can set breakpoints to. + // Lists all the debuggees that the user has access to. ListDebuggees(ctx context.Context, in *ListDebuggeesRequest, opts ...grpc.CallOption) (*ListDebuggeesResponse, error) } @@ -465,7 +464,7 @@ type Debugger2Server interface { DeleteBreakpoint(context.Context, *DeleteBreakpointRequest) (*google_protobuf3.Empty, error) // Lists all breakpoints for the debuggee. ListBreakpoints(context.Context, *ListBreakpointsRequest) (*ListBreakpointsResponse, error) - // Lists all the debuggees that the user can set breakpoints to. + // Lists all the debuggees that the user has access to. ListDebuggees(context.Context, *ListDebuggeesRequest) (*ListDebuggeesResponse, error) } @@ -595,53 +594,54 @@ var _Debugger2_serviceDesc = grpc.ServiceDesc{ func init() { proto.RegisterFile("google/devtools/clouddebugger/v2/debugger.proto", fileDescriptor2) } var fileDescriptor2 = []byte{ - // 766 bytes of a gzipped FileDescriptorProto + // 781 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xcb, 0x6e, 0xd3, 0x4c, - 0x18, 0xd5, 0xb4, 0x7f, 0x2f, 0xf9, 0xd2, 0xb4, 0xfd, 0x47, 0xbd, 0x58, 0xe1, 0x16, 0x99, 0x8b, - 0x4a, 0x41, 0x36, 0x72, 0x11, 0xb4, 0xb0, 0xa1, 0x51, 0x51, 0x1a, 0xa9, 0x54, 0x55, 0x80, 0x22, - 0xb1, 0x89, 0x9c, 0x64, 0x6a, 0x99, 0xba, 0x1e, 0xe3, 0x19, 0x07, 0x50, 0xd5, 0x4d, 0x91, 0xba, - 0x47, 0xbc, 0x00, 0x0f, 0x80, 0xc4, 0x13, 0x20, 0xb1, 0x43, 0x62, 0xcb, 0x2b, 0xf0, 0x20, 0xc8, - 0xe3, 0x71, 0xe3, 0x04, 0x43, 0xe2, 0x54, 0xea, 0xce, 0x3e, 0x9e, 0xf3, 0xcd, 0x39, 0x67, 0xbe, - 0x99, 0x31, 0xe8, 0x16, 0xa5, 0x96, 0x43, 0xf4, 0x16, 0x69, 0x73, 0x4a, 0x1d, 0xa6, 0x37, 0x1d, - 0x1a, 0xb4, 0x5a, 0xa4, 0x11, 0x58, 0x16, 0xf1, 0xf5, 0xb6, 0xa1, 0xc7, 0xcf, 0x9a, 0xe7, 0x53, - 0x4e, 0x71, 0x29, 0x22, 0x68, 0x31, 0x41, 0xeb, 0x22, 0x68, 0x6d, 0xa3, 0x78, 0x51, 0x96, 0x34, - 0x3d, 0x5b, 0x37, 0x5d, 0x97, 0x72, 0x93, 0xdb, 0xd4, 0x65, 0x11, 0xbf, 0x78, 0xab, 0xff, 0x84, - 0x26, 0x37, 0xe5, 0xe0, 0x0b, 0x72, 0xb0, 0x78, 0x6b, 0x04, 0x7b, 0x3a, 0x39, 0xf0, 0xf8, 0xbb, - 0xe8, 0xa3, 0xfa, 0x19, 0xc1, 0xdc, 0x53, 0xc2, 0xcb, 0x3e, 0x31, 0xf7, 0x3d, 0x6a, 0xbb, 0xbc, - 0x46, 0x5e, 0x07, 0x84, 0x71, 0x7c, 0x05, 0xf2, 0xb2, 0x1e, 0xa9, 0xdb, 0x2d, 0x05, 0x95, 0xd0, - 0x52, 0xae, 0x06, 0x31, 0x54, 0x6d, 0xe1, 0x2d, 0x80, 0xc6, 0x29, 0x4b, 0x19, 0x29, 0xa1, 0xa5, - 0xbc, 0x71, 0x5b, 0xeb, 0x67, 0x4c, 0x4b, 0xcc, 0x94, 0xe0, 0xe3, 0xeb, 0x30, 0xdd, 0x74, 0x6c, - 0xe2, 0xf2, 0x7a, 0x9b, 0xf8, 0xcc, 0xa6, 0xae, 0xf2, 0x9f, 0x98, 0xb1, 0x10, 0xa1, 0xbb, 0x11, - 0xa8, 0x12, 0x98, 0xef, 0x51, 0xcb, 0x3c, 0xea, 0x32, 0xd2, 0xa3, 0x06, 0x9d, 0x4d, 0x8d, 0xfa, - 0x1e, 0xc1, 0x5c, 0x65, 0xa8, 0x54, 0xae, 0x42, 0xa1, 0x53, 0x27, 0x1c, 0x32, 0x22, 0x86, 0x4c, - 0x75, 0xc0, 0x6a, 0x2b, 0x83, 0xd9, 0xca, 0x39, 0x98, 0x3d, 0x41, 0xb0, 0xb8, 0x41, 0x1c, 0xc2, - 0xc9, 0xf9, 0xf9, 0x1d, 0x4d, 0xf3, 0xfb, 0x7d, 0x14, 0x16, 0xb6, 0x6c, 0x96, 0x70, 0xcc, 0x06, - 0xd6, 0xb1, 0x0c, 0xff, 0xdb, 0x6e, 0xd3, 0x09, 0x5a, 0xa4, 0x6e, 0x3a, 0x4e, 0x3d, 0x60, 0xc4, - 0x67, 0x42, 0xcb, 0x64, 0x6d, 0x46, 0x7e, 0x58, 0x77, 0x9c, 0xe7, 0x21, 0x8c, 0x6f, 0xc2, 0x6c, - 0x3c, 0xd6, 0x76, 0xcd, 0x26, 0xb7, 0xdb, 0x44, 0x08, 0xea, 0x0c, 0xad, 0x4a, 0x18, 0xef, 0xc1, - 0x78, 0xf8, 0x24, 0x57, 0x28, 0x6f, 0x6c, 0xf7, 0x4f, 0x39, 0xdd, 0x41, 0x22, 0xfc, 0x75, 0x51, - 0x70, 0xd7, 0x74, 0x02, 0x52, 0x93, 0xd5, 0xc3, 0x18, 0x19, 0xf7, 0x6d, 0xaf, 0xee, 0x13, 0x16, - 0x38, 0x9c, 0x29, 0x63, 0x42, 0xcf, 0x94, 0x00, 0x6b, 0x11, 0x86, 0x2f, 0x01, 0xbc, 0x31, 0x6d, - 0x5e, 0xe7, 0x74, 0x9f, 0xb8, 0xca, 0xb8, 0xc8, 0x20, 0x17, 0x22, 0xcf, 0x42, 0x20, 0x25, 0xe5, - 0xc9, 0x94, 0x94, 0x8b, 0x0d, 0x98, 0x4f, 0xd5, 0x82, 0xab, 0x30, 0xd6, 0x0e, 0x1f, 0x44, 0xba, - 0xd3, 0xc6, 0x4a, 0x96, 0x86, 0xd2, 0xa2, 0x42, 0xb5, 0xa8, 0x82, 0xfa, 0x01, 0xc1, 0xe2, 0x1f, - 0x39, 0xc8, 0xe6, 0xdd, 0x86, 0x7c, 0xa7, 0x39, 0x98, 0x82, 0x4a, 0xa3, 0x99, 0xbb, 0x37, 0x59, - 0x00, 0xdf, 0x80, 0x19, 0x97, 0xbc, 0xe5, 0xf5, 0x44, 0x34, 0x51, 0x0f, 0x16, 0x42, 0xf8, 0x45, - 0x1c, 0x8f, 0x7a, 0x8c, 0x60, 0x2e, 0xd4, 0xb4, 0x21, 0x9b, 0xe6, 0xb4, 0xb7, 0x14, 0x98, 0xf0, - 0x7c, 0xfa, 0x8a, 0x34, 0xb9, 0x24, 0xc6, 0xaf, 0x59, 0x1a, 0x65, 0xc0, 0x2d, 0x6d, 0xc2, 0x7c, - 0x8f, 0x06, 0x99, 0xca, 0x26, 0xe4, 0xe2, 0x6e, 0x8e, 0x33, 0x59, 0xee, 0x9f, 0x49, 0x5c, 0xa7, - 0xd6, 0x21, 0x1b, 0x5f, 0x27, 0x20, 0x27, 0x71, 0xdf, 0xc0, 0x3f, 0x10, 0x14, 0xba, 0x4e, 0x4c, - 0x7c, 0xaf, 0x7f, 0xd9, 0xb4, 0x0b, 0xa1, 0x78, 0x3f, 0x33, 0x2f, 0xb2, 0xa6, 0x6e, 0x1e, 0xff, - 0xfc, 0xf5, 0x71, 0xa4, 0xac, 0xde, 0x4d, 0x5e, 0x84, 0xfa, 0xa9, 0x60, 0xfd, 0x30, 0xb1, 0xb3, - 0x8f, 0xf4, 0xc4, 0xd2, 0xea, 0x8c, 0xf0, 0x07, 0xc9, 0x4b, 0x22, 0x34, 0x53, 0xc9, 0x6a, 0xa6, - 0x32, 0xa4, 0x99, 0xca, 0xbf, 0xcc, 0xe0, 0x47, 0x99, 0xcd, 0x1c, 0x76, 0x9d, 0x93, 0x47, 0xf8, - 0x0b, 0x82, 0xd9, 0xde, 0x63, 0x17, 0xaf, 0x0d, 0xb2, 0xe6, 0xa9, 0x47, 0x75, 0x71, 0x21, 0xa6, - 0xc6, 0xf7, 0xbc, 0xf6, 0x38, 0xbc, 0xe7, 0x63, 0xc5, 0xcb, 0x67, 0x57, 0xfc, 0x0d, 0xc1, 0x4c, - 0xcf, 0xae, 0xc6, 0xab, 0xc3, 0x1e, 0x88, 0xc5, 0xb5, 0x21, 0x98, 0x72, 0x11, 0x56, 0x85, 0x25, - 0x03, 0xdf, 0xc9, 0x6a, 0x09, 0x7f, 0x42, 0x50, 0xe8, 0xda, 0x80, 0x83, 0x74, 0x50, 0xda, 0xa9, - 0x31, 0x48, 0x07, 0xa5, 0xee, 0x74, 0xf5, 0xb2, 0x10, 0xaf, 0xe0, 0x85, 0x74, 0xf1, 0xe5, 0x13, - 0x04, 0xd7, 0x9a, 0xf4, 0xa0, 0x6f, 0xf9, 0x72, 0x21, 0xde, 0xe5, 0x3b, 0xe1, 0x82, 0xef, 0xa0, - 0x97, 0x4f, 0x24, 0xc5, 0xa2, 0x8e, 0xe9, 0x5a, 0x1a, 0xf5, 0x2d, 0xdd, 0x22, 0xae, 0x68, 0x07, - 0xf9, 0x87, 0x6a, 0x7a, 0x36, 0xfb, 0xfb, 0x4f, 0xe3, 0xc3, 0x2e, 0xa0, 0x31, 0x2e, 0x98, 0x2b, - 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x7f, 0x55, 0x66, 0x54, 0xde, 0x0a, 0x00, 0x00, + 0x18, 0xd5, 0xa4, 0x7f, 0x2f, 0xf9, 0xd2, 0xb4, 0xfd, 0x47, 0xbd, 0x58, 0xe1, 0x16, 0x99, 0x8b, + 0x4a, 0x41, 0x36, 0x72, 0x11, 0xb4, 0xb0, 0xa1, 0xa1, 0x28, 0x8d, 0x54, 0xaa, 0x2a, 0x40, 0x91, + 0xd8, 0x44, 0x4e, 0x3c, 0xb5, 0x4c, 0x5d, 0x8f, 0xf1, 0x8c, 0x03, 0xa8, 0xea, 0xa6, 0x48, 0xec, + 0x11, 0x2f, 0x00, 0x5b, 0x84, 0xc4, 0x13, 0x20, 0xb1, 0x43, 0x62, 0xcb, 0x2b, 0xf0, 0x20, 0xc8, + 0xf6, 0xb8, 0x71, 0x82, 0x21, 0x71, 0x2a, 0x75, 0xe7, 0x9c, 0xcc, 0x77, 0x7c, 0xce, 0x99, 0x6f, + 0xbe, 0x31, 0xa8, 0x26, 0xa5, 0xa6, 0x4d, 0x54, 0x83, 0xb4, 0x39, 0xa5, 0x36, 0x53, 0x5b, 0x36, + 0xf5, 0x0d, 0x83, 0x34, 0x7d, 0xd3, 0x24, 0x9e, 0xda, 0xd6, 0xd4, 0xf8, 0x59, 0x71, 0x3d, 0xca, + 0x29, 0x2e, 0x47, 0x05, 0x4a, 0x5c, 0xa0, 0x74, 0x15, 0x28, 0x6d, 0xad, 0x74, 0x56, 0x50, 0xea, + 0xae, 0xa5, 0xea, 0x8e, 0x43, 0xb9, 0xce, 0x2d, 0xea, 0xb0, 0xa8, 0xbe, 0x74, 0xad, 0xff, 0x0b, + 0x75, 0xae, 0x8b, 0xc5, 0x67, 0xc4, 0xe2, 0xf0, 0x57, 0xd3, 0xdf, 0x55, 0xc9, 0xbe, 0xcb, 0x5f, + 0x47, 0x7f, 0xca, 0x9f, 0x11, 0xcc, 0x3e, 0x22, 0xbc, 0xe2, 0x11, 0x7d, 0xcf, 0xa5, 0x96, 0xc3, + 0xeb, 0xe4, 0x85, 0x4f, 0x18, 0xc7, 0x17, 0xa0, 0x20, 0xf8, 0x48, 0xc3, 0x32, 0x24, 0x54, 0x46, + 0x8b, 0xf9, 0x3a, 0xc4, 0x50, 0xcd, 0xc0, 0x9b, 0x00, 0xcd, 0xe3, 0x2a, 0x29, 0x57, 0x46, 0x8b, + 0x05, 0xed, 0xba, 0xd2, 0xcf, 0x98, 0x92, 0x78, 0x53, 0xa2, 0x1e, 0x5f, 0x86, 0xa9, 0x96, 0x6d, + 0x11, 0x87, 0x37, 0xda, 0xc4, 0x63, 0x16, 0x75, 0xa4, 0xff, 0xc2, 0x37, 0x16, 0x23, 0x74, 0x27, + 0x02, 0x65, 0x02, 0x73, 0x3d, 0x6a, 0x99, 0x4b, 0x1d, 0x46, 0x7a, 0xd4, 0xa0, 0x93, 0xa9, 0x91, + 0xdf, 0x20, 0x98, 0xad, 0x0e, 0x95, 0xca, 0x45, 0x28, 0x76, 0x78, 0x82, 0x25, 0xb9, 0x70, 0xc9, + 0x64, 0x07, 0xac, 0x19, 0x19, 0xcc, 0x56, 0x4f, 0xc1, 0xec, 0x5b, 0x04, 0x0b, 0xeb, 0xc4, 0x26, + 0x9c, 0x9c, 0x9e, 0xdf, 0x91, 0x34, 0xbf, 0xdf, 0x47, 0x60, 0x7e, 0xd3, 0x62, 0x09, 0xc7, 0x6c, + 0x60, 0x1d, 0x4b, 0xf0, 0xbf, 0xe5, 0xb4, 0x6c, 0xdf, 0x20, 0x0d, 0xdd, 0xb6, 0x1b, 0x3e, 0x23, + 0x1e, 0x0b, 0xb5, 0x4c, 0xd4, 0xa7, 0xc5, 0x1f, 0x6b, 0xb6, 0xfd, 0x24, 0x80, 0xf1, 0x55, 0x98, + 0x89, 0xd7, 0x5a, 0x8e, 0xde, 0xe2, 0x56, 0x9b, 0x84, 0x82, 0x3a, 0x4b, 0x6b, 0x02, 0xc6, 0xbb, + 0x30, 0x16, 0x3c, 0x89, 0x1d, 0x2a, 0x68, 0x5b, 0xfd, 0x53, 0x4e, 0x77, 0x90, 0x08, 0x7f, 0x2d, + 0x24, 0xdc, 0xd1, 0x6d, 0x9f, 0xd4, 0x05, 0x7b, 0x10, 0x23, 0xe3, 0x9e, 0xe5, 0x36, 0x3c, 0xc2, + 0x7c, 0x9b, 0x33, 0x69, 0x34, 0xd4, 0x33, 0x19, 0x82, 0xf5, 0x08, 0xc3, 0xe7, 0x00, 0x5e, 0xea, + 0x16, 0x6f, 0x70, 0xba, 0x47, 0x1c, 0x69, 0x2c, 0xcc, 0x20, 0x1f, 0x20, 0x8f, 0x03, 0x20, 0x25, + 0xe5, 0x89, 0x94, 0x94, 0x4b, 0x4d, 0x98, 0x4b, 0xd5, 0x82, 0x6b, 0x30, 0xda, 0x0e, 0x1e, 0xc2, + 0x74, 0xa7, 0xb4, 0xe5, 0x2c, 0x0d, 0xa5, 0x44, 0x44, 0xf5, 0x88, 0x41, 0x7e, 0x87, 0x60, 0xe1, + 0x8f, 0x1c, 0x44, 0xf3, 0x6e, 0x41, 0xa1, 0xd3, 0x1c, 0x4c, 0x42, 0xe5, 0x91, 0xcc, 0xdd, 0x9b, + 0x24, 0xc0, 0x57, 0x60, 0xda, 0x21, 0xaf, 0x78, 0x23, 0x11, 0x4d, 0xd4, 0x83, 0xc5, 0x00, 0x7e, + 0x1a, 0xc7, 0x23, 0x1f, 0x21, 0x98, 0x0d, 0x34, 0xad, 0x8b, 0xa6, 0x39, 0xee, 0x2d, 0x09, 0xc6, + 0x5d, 0x8f, 0x3e, 0x27, 0x2d, 0x2e, 0x0a, 0xe3, 0x9f, 0x59, 0x1a, 0x65, 0xc0, 0x23, 0xad, 0xc3, + 0x5c, 0x8f, 0x06, 0x91, 0xca, 0x06, 0xe4, 0xe3, 0x6e, 0x8e, 0x33, 0x59, 0xea, 0x9f, 0x49, 0xcc, + 0x53, 0xef, 0x14, 0x6b, 0x5f, 0xc7, 0x21, 0x2f, 0x70, 0x4f, 0xc3, 0x3f, 0x10, 0x14, 0xbb, 0x26, + 0x26, 0xbe, 0xd5, 0x9f, 0x36, 0xed, 0x42, 0x28, 0xdd, 0xce, 0x5c, 0x17, 0x59, 0x93, 0x37, 0x8e, + 0x7e, 0xfe, 0x7a, 0x9f, 0xab, 0xc8, 0x37, 0x93, 0x17, 0xa1, 0x7a, 0x2c, 0x58, 0x3d, 0x48, 0x9c, + 0xec, 0x43, 0x35, 0xb1, 0xb5, 0x2a, 0x23, 0xfc, 0x4e, 0xf2, 0x92, 0x08, 0xcc, 0x54, 0xb3, 0x9a, + 0xa9, 0x0e, 0x69, 0xa6, 0xfa, 0x2f, 0x33, 0xf8, 0x5e, 0x66, 0x33, 0x07, 0x5d, 0x73, 0xf2, 0x10, + 0x7f, 0x41, 0x30, 0xd3, 0x3b, 0x76, 0xf1, 0xea, 0x20, 0x7b, 0x9e, 0x3a, 0xaa, 0x4b, 0xf3, 0x71, + 0x69, 0x7c, 0xcf, 0x2b, 0x0f, 0x82, 0x7b, 0x3e, 0x56, 0xbc, 0x74, 0x72, 0xc5, 0xdf, 0x10, 0x4c, + 0xf7, 0x9c, 0x6a, 0xbc, 0x32, 0xec, 0x40, 0x2c, 0xad, 0x0e, 0x51, 0x29, 0x36, 0x61, 0x25, 0xb4, + 0xa4, 0xe1, 0x1b, 0x59, 0x2d, 0xe1, 0x0f, 0x08, 0x8a, 0x5d, 0x07, 0x70, 0x90, 0x0e, 0x4a, 0x9b, + 0x1a, 0x83, 0x74, 0x50, 0xea, 0x49, 0x97, 0xcf, 0x87, 0xe2, 0x25, 0x3c, 0x9f, 0x2e, 0xbe, 0xf2, + 0x11, 0xc1, 0xa5, 0x16, 0xdd, 0xef, 0x4b, 0x5f, 0x29, 0xc6, 0xa7, 0x7c, 0x3b, 0xd8, 0xf0, 0x6d, + 0xf4, 0xec, 0xa1, 0x28, 0x31, 0xa9, 0xad, 0x3b, 0xa6, 0x42, 0x3d, 0x53, 0x35, 0x89, 0x13, 0xb6, + 0x83, 0xf8, 0x42, 0xd5, 0x5d, 0x8b, 0xfd, 0xfd, 0xa3, 0xf1, 0x6e, 0x17, 0xf0, 0x29, 0x27, 0x55, + 0x23, 0xbe, 0xfb, 0x01, 0x1c, 0xcf, 0x1a, 0x4f, 0xd9, 0xd1, 0x9a, 0x63, 0x21, 0xe9, 0xf2, 0xef, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x66, 0xf8, 0x5d, 0x68, 0xf9, 0x0a, 0x00, 0x00, } diff --git a/vendor/google.golang.org/genproto/googleapis/devtools/cloudprofiler/v2/profiler.pb.go b/vendor/google.golang.org/genproto/googleapis/devtools/cloudprofiler/v2/profiler.pb.go index 313c884f..205d1a1d 100644 --- a/vendor/google.golang.org/genproto/googleapis/devtools/cloudprofiler/v2/profiler.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/devtools/cloudprofiler/v2/profiler.pb.go @@ -20,6 +20,7 @@ import fmt "fmt" import math "math" import _ "google.golang.org/genproto/googleapis/api/annotations" import google_protobuf1 "github.com/golang/protobuf/ptypes/duration" +import _ "github.com/golang/protobuf/ptypes/timestamp" import ( context "golang.org/x/net/context" @@ -417,41 +418,47 @@ var _ProfilerService_serviceDesc = grpc.ServiceDesc{ func init() { proto.RegisterFile("google/devtools/cloudprofiler/v2/profiler.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ - // 576 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0x51, 0x8f, 0xd2, 0x40, - 0x10, 0xb6, 0x57, 0x0e, 0x8e, 0xe9, 0xdd, 0xd9, 0x6c, 0x88, 0xa9, 0xe4, 0x34, 0x04, 0x5f, 0xd0, - 0x68, 0x9b, 0xd4, 0x9c, 0x39, 0xf5, 0x89, 0x83, 0x5e, 0x8e, 0x84, 0x83, 0x66, 0x81, 0x18, 0xf5, - 0x81, 0x14, 0xba, 0xd7, 0x54, 0x7b, 0xdd, 0xba, 0x5d, 0x48, 0xfa, 0x7b, 0xfc, 0x43, 0xfe, 0x1d, - 0xe3, 0x8b, 0xa1, 0xdd, 0x72, 0x10, 0x31, 0x70, 0x9e, 0x6f, 0x33, 0xb3, 0xf3, 0x7d, 0xb3, 0xf3, - 0xed, 0xce, 0x80, 0xe1, 0x51, 0xea, 0x05, 0xc4, 0x70, 0xc9, 0x9c, 0x53, 0x1a, 0xc4, 0xc6, 0x34, - 0xa0, 0x33, 0x37, 0x62, 0xf4, 0xda, 0x0f, 0x08, 0x33, 0xe6, 0xa6, 0x91, 0xdb, 0x7a, 0xc4, 0x28, - 0xa7, 0xa8, 0x96, 0x01, 0xf4, 0x1c, 0xa0, 0xaf, 0x01, 0xf4, 0xb9, 0x59, 0x3d, 0x11, 0x94, 0x4e, - 0xe4, 0x1b, 0x4e, 0x18, 0x52, 0xee, 0x70, 0x9f, 0x86, 0x71, 0x86, 0xaf, 0x3e, 0x15, 0xa7, 0xa9, - 0x37, 0x99, 0x5d, 0x1b, 0xee, 0x8c, 0xa5, 0x09, 0xd9, 0x79, 0xfd, 0x97, 0x04, 0x95, 0x16, 0x23, - 0x0e, 0x27, 0x76, 0xc6, 0x89, 0xc9, 0xb7, 0x19, 0x89, 0x39, 0xea, 0x02, 0xb8, 0x24, 0x0a, 0x68, - 0x72, 0x43, 0x42, 0xae, 0x49, 0x35, 0xa9, 0xa1, 0x98, 0x2f, 0xf5, 0x6d, 0xb7, 0xd1, 0xdb, 0x4b, - 0x0c, 0x5e, 0xc1, 0x23, 0x1b, 0x0e, 0x45, 0xd6, 0x98, 0x27, 0x11, 0xd1, 0xf6, 0x6a, 0x72, 0xe3, - 0xd8, 0x7c, 0xb5, 0x9d, 0x4f, 0xdc, 0x6a, 0x98, 0x44, 0x04, 0x2b, 0xd1, 0xad, 0x83, 0x5a, 0x50, - 0x12, 0xae, 0x26, 0xa7, 0x97, 0x7b, 0xbe, 0x33, 0x19, 0xce, 0x91, 0xf5, 0xcf, 0x50, 0x19, 0x45, - 0xee, 0x9f, 0xcd, 0xaf, 0x90, 0x4b, 0xff, 0x4c, 0xfe, 0x5d, 0x86, 0x92, 0x08, 0x22, 0x04, 0x85, - 0xd0, 0xb9, 0xc9, 0xd8, 0xca, 0x38, 0xb5, 0x37, 0x68, 0x22, 0xdd, 0x53, 0x93, 0xf5, 0x37, 0x93, - 0xef, 0xf9, 0x66, 0xa7, 0x70, 0x90, 0x7f, 0x16, 0xad, 0x90, 0x72, 0x3d, 0xce, 0xb9, 0xf2, 0xdf, - 0xa4, 0xb7, 0x45, 0x02, 0x5e, 0xa6, 0xa2, 0x67, 0x70, 0x94, 0xb7, 0x35, 0x49, 0x38, 0x89, 0xb5, - 0xfd, 0x9a, 0xd4, 0x38, 0xc4, 0x79, 0xaf, 0xe7, 0x8b, 0x18, 0xba, 0x82, 0x62, 0xe0, 0x4c, 0x48, - 0x10, 0x6b, 0xc5, 0x9a, 0xdc, 0x50, 0xcc, 0xd3, 0x9d, 0xbb, 0xd6, 0xbb, 0x29, 0xce, 0x0a, 0x39, - 0x4b, 0xb0, 0x20, 0xa9, 0xbe, 0x05, 0x65, 0x25, 0x8c, 0x54, 0x90, 0xbf, 0x92, 0x44, 0x88, 0xbd, - 0x30, 0x51, 0x05, 0xf6, 0xe7, 0x4e, 0x30, 0xcb, 0x44, 0x2e, 0xe3, 0xcc, 0x79, 0xb7, 0x77, 0x26, - 0xd5, 0x7f, 0x48, 0x00, 0xb7, 0x02, 0xa0, 0x27, 0x00, 0x11, 0xa3, 0x5f, 0xc8, 0x94, 0x8f, 0x7d, - 0x57, 0x30, 0x94, 0x45, 0xa4, 0xe3, 0xa2, 0x47, 0x50, 0xe4, 0x0e, 0xf3, 0x08, 0x17, 0x44, 0xc2, - 0x43, 0xf6, 0xb2, 0x1f, 0x39, 0xed, 0xe7, 0xec, 0x2e, 0xaa, 0xff, 0xe7, 0x96, 0x5e, 0x10, 0x50, - 0x56, 0xbe, 0x08, 0x3a, 0x01, 0xcd, 0xc6, 0xfd, 0x8b, 0x4e, 0xd7, 0x1a, 0x0f, 0x3f, 0xda, 0xd6, - 0x78, 0xd4, 0x1b, 0xd8, 0x56, 0xab, 0x73, 0xd1, 0xb1, 0xda, 0xea, 0x03, 0x54, 0x02, 0xb9, 0x65, - 0x8f, 0x54, 0x09, 0x1d, 0x40, 0xe1, 0x43, 0xb3, 0xdb, 0x55, 0xf7, 0x16, 0xd6, 0xa5, 0xd5, 0xb4, - 0x55, 0x19, 0x29, 0x50, 0x1a, 0x5e, 0x62, 0xab, 0xd9, 0x1e, 0xa8, 0x05, 0x74, 0x0c, 0xd0, 0xea, - 0xf7, 0x86, 0x56, 0x6f, 0xd8, 0xe9, 0xf7, 0xd4, 0x7d, 0xf3, 0xa7, 0x04, 0x0f, 0x45, 0x1d, 0x36, - 0x20, 0x6c, 0xee, 0x4f, 0x09, 0x62, 0x70, 0xb4, 0xb6, 0x4d, 0xd0, 0x9b, 0xed, 0x42, 0x6c, 0x5a, - 0x3f, 0xd5, 0xdd, 0x07, 0x6e, 0x51, 0x73, 0x6d, 0x88, 0x77, 0xa9, 0xb9, 0x69, 0xea, 0xef, 0x50, - 0xf3, 0xbc, 0xff, 0xe9, 0x4a, 0xe4, 0x7a, 0x34, 0x70, 0x42, 0x4f, 0xa7, 0xcc, 0x33, 0x3c, 0x12, - 0xa6, 0x83, 0x21, 0x96, 0xbc, 0x13, 0xf9, 0xf1, 0xdf, 0x17, 0xfd, 0xfb, 0xb5, 0xc0, 0xa4, 0x98, - 0x22, 0x5f, 0xff, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x6c, 0x53, 0xd3, 0x90, 0x21, 0x06, 0x00, 0x00, + // 661 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xcd, 0x6e, 0xd3, 0x40, + 0x10, 0x66, 0xe3, 0x34, 0x69, 0x27, 0x6d, 0xb1, 0x56, 0x15, 0x32, 0x51, 0x81, 0x28, 0x5c, 0x42, + 0x44, 0x6d, 0xc9, 0x55, 0x51, 0x5b, 0xc4, 0xa1, 0x4d, 0x5c, 0x35, 0x52, 0x9a, 0x58, 0x6e, 0x2a, + 0x04, 0x1c, 0x22, 0xa7, 0xde, 0x5a, 0x06, 0xc7, 0x6b, 0xec, 0x4d, 0xa4, 0xa8, 0xea, 0x85, 0x57, + 0xe0, 0x11, 0xb8, 0xc2, 0xbb, 0x20, 0xf1, 0x0a, 0x3c, 0x00, 0x77, 0x2e, 0xc8, 0xf6, 0x3a, 0x3f, + 0x50, 0x94, 0x94, 0x72, 0xdb, 0x99, 0x9d, 0xef, 0xdb, 0x6f, 0x66, 0xd7, 0x9f, 0x41, 0xb1, 0x29, + 0xb5, 0x5d, 0xa2, 0x58, 0x64, 0xc8, 0x28, 0x75, 0x43, 0xe5, 0xdc, 0xa5, 0x03, 0xcb, 0x0f, 0xe8, + 0x85, 0xe3, 0x92, 0x40, 0x19, 0xaa, 0x4a, 0xba, 0x96, 0xfd, 0x80, 0x32, 0x8a, 0x4b, 0x09, 0x40, + 0x4e, 0x01, 0xf2, 0x0c, 0x40, 0x1e, 0xaa, 0xc5, 0x4d, 0x4e, 0x69, 0xfa, 0x8e, 0x62, 0x7a, 0x1e, + 0x65, 0x26, 0x73, 0xa8, 0x17, 0x26, 0xf8, 0xe2, 0x43, 0xbe, 0x1b, 0x47, 0xbd, 0xc1, 0x85, 0x62, + 0x0d, 0x82, 0xb8, 0x80, 0xef, 0x3f, 0xfa, 0x7d, 0x9f, 0x39, 0x7d, 0x12, 0x32, 0xb3, 0xef, 0x27, + 0x05, 0xe5, 0x9f, 0x08, 0x36, 0x6a, 0x01, 0x31, 0x19, 0xd1, 0x93, 0x43, 0x0d, 0xf2, 0x7e, 0x40, + 0x42, 0x86, 0x9b, 0x00, 0x16, 0xf1, 0x5d, 0x3a, 0xea, 0x13, 0x8f, 0x49, 0xa8, 0x84, 0x2a, 0x05, + 0xf5, 0xa9, 0x3c, 0x4f, 0xae, 0x5c, 0x1f, 0x63, 0x8c, 0x29, 0x3c, 0xd6, 0x61, 0x95, 0x57, 0x75, + 0xd9, 0xc8, 0x27, 0x52, 0xa6, 0x24, 0x54, 0xd6, 0xd5, 0xad, 0xf9, 0x7c, 0x5c, 0x55, 0x67, 0xe4, + 0x13, 0xa3, 0xe0, 0x4f, 0x02, 0x5c, 0x83, 0x3c, 0x0f, 0x25, 0x21, 0x16, 0xf7, 0x64, 0x61, 0x32, + 0x23, 0x45, 0x96, 0xdf, 0xc0, 0xc6, 0x99, 0x6f, 0xfd, 0xd9, 0xfc, 0x14, 0x39, 0xfa, 0x67, 0xf2, + 0x4f, 0x02, 0xe4, 0x79, 0x12, 0x63, 0xc8, 0x7a, 0x66, 0x3f, 0x61, 0x5b, 0x31, 0xe2, 0xf5, 0x35, + 0x33, 0x41, 0xb7, 0x9c, 0xc9, 0xec, 0x9d, 0x09, 0xb7, 0xbc, 0xb3, 0x1d, 0x58, 0x4e, 0x5f, 0x93, + 0x94, 0x8d, 0xb9, 0xee, 0xa7, 0x5c, 0xe9, 0x73, 0x92, 0xeb, 0xbc, 0xc0, 0x18, 0x97, 0xe2, 0xc7, + 0xb0, 0x96, 0xb6, 0xd5, 0x1b, 0x31, 0x12, 0x4a, 0x4b, 0x25, 0x54, 0x59, 0x35, 0xd2, 0x5e, 0x0f, + 0xa3, 0x1c, 0x3e, 0x81, 0x9c, 0x6b, 0xf6, 0x88, 0x1b, 0x4a, 0xb9, 0x92, 0x50, 0x29, 0xa8, 0x3b, + 0x0b, 0x77, 0x2d, 0x37, 0x63, 0x9c, 0xe6, 0xb1, 0x60, 0x64, 0x70, 0x92, 0xe2, 0x1e, 0x14, 0xa6, + 0xd2, 0x58, 0x04, 0xe1, 0x1d, 0x19, 0xf1, 0x61, 0x47, 0x4b, 0xbc, 0x01, 0x4b, 0x43, 0xd3, 0x1d, + 0x24, 0x43, 0x5e, 0x31, 0x92, 0x60, 0x3f, 0xb3, 0x8b, 0xca, 0x5f, 0x11, 0xc0, 0x64, 0x00, 0xf8, + 0x01, 0x80, 0x1f, 0xd0, 0xb7, 0xe4, 0x9c, 0x75, 0x1d, 0x8b, 0x33, 0xac, 0xf0, 0x4c, 0xc3, 0xc2, + 0xf7, 0x20, 0xc7, 0xcc, 0xc0, 0x26, 0x8c, 0x13, 0xf1, 0x08, 0xeb, 0xe3, 0x7e, 0x84, 0xb8, 0x9f, + 0xdd, 0x9b, 0x4c, 0xfd, 0x3f, 0xb7, 0x54, 0x25, 0x50, 0x98, 0x7a, 0x22, 0x78, 0x13, 0x24, 0xdd, + 0x68, 0x1f, 0x35, 0x9a, 0x5a, 0xb7, 0xf3, 0x4a, 0xd7, 0xba, 0x67, 0xad, 0x53, 0x5d, 0xab, 0x35, + 0x8e, 0x1a, 0x5a, 0x5d, 0xbc, 0x83, 0xf3, 0x20, 0xd4, 0xf4, 0x33, 0x11, 0xe1, 0x65, 0xc8, 0xbe, + 0x3c, 0x68, 0x36, 0xc5, 0x4c, 0xb4, 0x3a, 0xd6, 0x0e, 0x74, 0x51, 0xc0, 0x05, 0xc8, 0x77, 0x8e, + 0x0d, 0xed, 0xa0, 0x7e, 0x2a, 0x66, 0xf1, 0x3a, 0x40, 0xad, 0xdd, 0xea, 0x68, 0xad, 0x4e, 0xa3, + 0xdd, 0x12, 0x97, 0xd4, 0x1f, 0x19, 0xb8, 0xcb, 0xcf, 0x09, 0x4e, 0x49, 0x30, 0x74, 0xce, 0x09, + 0xfe, 0x8c, 0x60, 0x6d, 0xc6, 0x4e, 0xf0, 0xb3, 0xf9, 0x93, 0xb8, 0xce, 0x7f, 0x8a, 0x8b, 0x7f, + 0x71, 0xe5, 0xdd, 0x0f, 0xdf, 0xbe, 0x7f, 0xcc, 0xa8, 0xe5, 0x2d, 0x6e, 0xb0, 0xd1, 0x5d, 0x85, + 0xca, 0xe5, 0xe4, 0x29, 0xcb, 0x93, 0x2b, 0xbd, 0x4a, 0x1d, 0x38, 0xdc, 0x47, 0x55, 0xfc, 0x05, + 0xc1, 0xda, 0x8c, 0x01, 0x2c, 0x22, 0xf7, 0x3a, 0xc7, 0xb8, 0x89, 0xdc, 0xbd, 0x58, 0xee, 0xb6, + 0x5a, 0x89, 0xe4, 0x5e, 0xf2, 0x0a, 0x39, 0xb2, 0x84, 0x17, 0x63, 0xf1, 0xd5, 0xb1, 0x4c, 0xa5, + 0x7a, 0xb5, 0x9f, 0x5a, 0xca, 0x61, 0xfb, 0xf5, 0x09, 0x3f, 0xc6, 0xa6, 0xae, 0xe9, 0xd9, 0x32, + 0x0d, 0x6c, 0xc5, 0x26, 0x5e, 0xfc, 0x3d, 0xf2, 0x9f, 0x8f, 0xe9, 0x3b, 0xe1, 0xdf, 0x7f, 0x40, + 0xcf, 0x67, 0x12, 0xbd, 0x5c, 0x8c, 0xdc, 0xfe, 0x15, 0x00, 0x00, 0xff, 0xff, 0x83, 0x3f, 0xa6, + 0xd9, 0xb9, 0x06, 0x00, 0x00, } diff --git a/vendor/google.golang.org/genproto/googleapis/devtools/remoteexecution/v1test/remote_execution.pb.go b/vendor/google.golang.org/genproto/googleapis/devtools/remoteexecution/v1test/remote_execution.pb.go index 17f11ece..904fa82a 100644 --- a/vendor/google.golang.org/genproto/googleapis/devtools/remoteexecution/v1test/remote_execution.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/devtools/remoteexecution/v1test/remote_execution.pb.go @@ -30,6 +30,8 @@ It has these top-level messages: BatchUpdateBlobsResponse GetTreeRequest GetTreeResponse + ToolDetails + RequestMetadata */ package remoteexecution @@ -1260,6 +1262,85 @@ func (m *GetTreeResponse) GetNextPageToken() string { return "" } +// Details for the tool used to call the API. +type ToolDetails struct { + // Name of the tool, e.g. bazel. + ToolName string `protobuf:"bytes,1,opt,name=tool_name,json=toolName" json:"tool_name,omitempty"` + // Version of the tool used for the request, e.g. 5.0.3. + ToolVersion string `protobuf:"bytes,2,opt,name=tool_version,json=toolVersion" json:"tool_version,omitempty"` +} + +func (m *ToolDetails) Reset() { *m = ToolDetails{} } +func (m *ToolDetails) String() string { return proto.CompactTextString(m) } +func (*ToolDetails) ProtoMessage() {} +func (*ToolDetails) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} } + +func (m *ToolDetails) GetToolName() string { + if m != nil { + return m.ToolName + } + return "" +} + +func (m *ToolDetails) GetToolVersion() string { + if m != nil { + return m.ToolVersion + } + return "" +} + +// An optional Metadata to attach to a RPC request to tell the server about an +// external context of the request. +// If used, the header name should be remote-request-metadata-bin and the +// contents the base64 encoded binary RequestMetadata message. +type RequestMetadata struct { + // The details for the tool invoking the requests. + ToolDetails *ToolDetails `protobuf:"bytes,1,opt,name=tool_details,json=toolDetails" json:"tool_details,omitempty"` + // An identifier that ties multiple requests to the same action. + // For example, multiple requests to the CAS, Action Cache, and Execution + // API are used in order to compile foo.cc. + ActionId string `protobuf:"bytes,2,opt,name=action_id,json=actionId" json:"action_id,omitempty"` + // An identifier that ties multiple actions together to a final result. + // For example, multiple actions are required to build and run foo_test. + ToolInvocationId string `protobuf:"bytes,3,opt,name=tool_invocation_id,json=toolInvocationId" json:"tool_invocation_id,omitempty"` + // An identifier to tie multiple tool invocations together. For example, + // runs of foo_test, bar_test and baz_test on a post-submit of a given patch. + CorrelatedInvocationsId string `protobuf:"bytes,4,opt,name=correlated_invocations_id,json=correlatedInvocationsId" json:"correlated_invocations_id,omitempty"` +} + +func (m *RequestMetadata) Reset() { *m = RequestMetadata{} } +func (m *RequestMetadata) String() string { return proto.CompactTextString(m) } +func (*RequestMetadata) ProtoMessage() {} +func (*RequestMetadata) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} } + +func (m *RequestMetadata) GetToolDetails() *ToolDetails { + if m != nil { + return m.ToolDetails + } + return nil +} + +func (m *RequestMetadata) GetActionId() string { + if m != nil { + return m.ActionId + } + return "" +} + +func (m *RequestMetadata) GetToolInvocationId() string { + if m != nil { + return m.ToolInvocationId + } + return "" +} + +func (m *RequestMetadata) GetCorrelatedInvocationsId() string { + if m != nil { + return m.CorrelatedInvocationsId + } + return "" +} + func init() { proto.RegisterType((*Action)(nil), "google.devtools.remoteexecution.v1test.Action") proto.RegisterType((*Command)(nil), "google.devtools.remoteexecution.v1test.Command") @@ -1286,6 +1367,8 @@ func init() { proto.RegisterType((*BatchUpdateBlobsResponse_Response)(nil), "google.devtools.remoteexecution.v1test.BatchUpdateBlobsResponse.Response") proto.RegisterType((*GetTreeRequest)(nil), "google.devtools.remoteexecution.v1test.GetTreeRequest") proto.RegisterType((*GetTreeResponse)(nil), "google.devtools.remoteexecution.v1test.GetTreeResponse") + proto.RegisterType((*ToolDetails)(nil), "google.devtools.remoteexecution.v1test.ToolDetails") + proto.RegisterType((*RequestMetadata)(nil), "google.devtools.remoteexecution.v1test.RequestMetadata") proto.RegisterEnum("google.devtools.remoteexecution.v1test.ExecuteOperationMetadata_Stage", ExecuteOperationMetadata_Stage_name, ExecuteOperationMetadata_Stage_value) } @@ -1809,115 +1892,122 @@ func init() { } var fileDescriptor0 = []byte{ - // 1747 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcb, 0x6f, 0x1c, 0x49, - 0x19, 0xa7, 0x67, 0x3c, 0xaf, 0x6f, 0xc6, 0xaf, 0x5a, 0xb3, 0x99, 0xcc, 0x6e, 0x90, 0xe9, 0x95, - 0x56, 0xd6, 0x68, 0xb7, 0x07, 0x3b, 0xbb, 0x44, 0x78, 0x15, 0x82, 0x3d, 0x1e, 0x3b, 0x51, 0x1c, - 0xdb, 0x69, 0x7b, 0xf2, 0x22, 0x52, 0xd3, 0x33, 0x5d, 0x1e, 0x37, 0x9e, 0xe9, 0x6a, 0xaa, 0x6a, - 0x1c, 0x27, 0x21, 0x1c, 0x10, 0x12, 0x07, 0x04, 0x12, 0x44, 0x08, 0x24, 0x6e, 0x48, 0x08, 0x09, - 0x71, 0xe2, 0x3f, 0x80, 0x3f, 0x80, 0x03, 0x5c, 0x38, 0x23, 0x4e, 0x9c, 0x38, 0x23, 0x24, 0x50, - 0x3d, 0x7a, 0x5e, 0xb6, 0x49, 0x8f, 0x1d, 0x4b, 0x7b, 0xeb, 0xfa, 0xaa, 0xbe, 0xdf, 0xf7, 0xfe, - 0xbe, 0xaa, 0x86, 0x9b, 0x2d, 0x42, 0x5a, 0x6d, 0x5c, 0xf1, 0xf0, 0x11, 0x27, 0xa4, 0xcd, 0x2a, - 0x14, 0x77, 0x08, 0xc7, 0xf8, 0x18, 0x37, 0xbb, 0xdc, 0x27, 0x41, 0xe5, 0x68, 0x91, 0x63, 0xc6, - 0x35, 0xd9, 0xe9, 0xd1, 0xad, 0x90, 0x12, 0x4e, 0xd0, 0x87, 0x8a, 0xdd, 0x8a, 0xd8, 0xad, 0x11, - 0x76, 0x4b, 0xb1, 0x97, 0xde, 0xd7, 0x62, 0xdc, 0xd0, 0xaf, 0xb8, 0x41, 0x40, 0xb8, 0x2b, 0x76, - 0x99, 0x42, 0x29, 0x7d, 0xa0, 0x77, 0xdb, 0x24, 0x68, 0xd1, 0x6e, 0x10, 0xf8, 0x41, 0xab, 0x42, - 0x42, 0x4c, 0x87, 0x0e, 0x7d, 0x49, 0x1f, 0x92, 0xab, 0x46, 0x77, 0xbf, 0xe2, 0x75, 0xd5, 0x01, - 0xbd, 0x7f, 0x45, 0xef, 0xd3, 0xb0, 0x59, 0x61, 0xdc, 0xe5, 0x5d, 0xcd, 0x68, 0xfe, 0x21, 0x09, - 0xe9, 0x95, 0xa6, 0x38, 0x89, 0xea, 0x30, 0xd5, 0x24, 0x9d, 0x8e, 0x1b, 0x78, 0x8e, 0xe7, 0xb7, - 0x30, 0xe3, 0x45, 0x63, 0xde, 0x58, 0xc8, 0x2f, 0x59, 0x56, 0x3c, 0x3b, 0xac, 0x35, 0xc9, 0x65, - 0x4f, 0x6a, 0x14, 0xb5, 0x44, 0x4f, 0x60, 0xd6, 0x0f, 0xc2, 0x2e, 0x77, 0x28, 0x21, 0x3c, 0x42, - 0x4e, 0x9c, 0x0b, 0x79, 0x5a, 0x02, 0xd9, 0x84, 0x70, 0x8d, 0xfd, 0x65, 0x28, 0x90, 0x2e, 0x17, - 0xe0, 0xfb, 0x7e, 0x1b, 0xb3, 0x62, 0x72, 0x3e, 0xb9, 0x90, 0xb3, 0xf3, 0x8a, 0xb6, 0x2e, 0x48, - 0xe8, 0x63, 0x40, 0xfa, 0x88, 0xe7, 0x53, 0xdc, 0xe4, 0x84, 0xfa, 0x98, 0x15, 0x27, 0xe4, 0xc1, - 0x59, 0xb5, 0xb3, 0xd6, 0xdf, 0x40, 0x9b, 0x90, 0x0d, 0xdb, 0x2e, 0xdf, 0x27, 0xb4, 0x53, 0x4c, - 0x49, 0x25, 0xbf, 0x12, 0x57, 0xc9, 0x1d, 0xcd, 0x67, 0xf7, 0x10, 0xd0, 0x75, 0xc8, 0x70, 0xbf, - 0x83, 0x49, 0x97, 0x17, 0xd3, 0x12, 0xec, 0x6a, 0x04, 0x16, 0x05, 0xca, 0x5a, 0xd3, 0x81, 0xb2, - 0xa3, 0x93, 0x68, 0x1e, 0x0a, 0x1e, 0x71, 0x02, 0xc2, 0x9d, 0xa6, 0xdb, 0x3c, 0xc0, 0xc5, 0xcc, - 0xbc, 0xb1, 0x90, 0xb5, 0xc1, 0x23, 0x5b, 0x84, 0x57, 0x05, 0xc5, 0xfc, 0xbb, 0x01, 0x99, 0xaa, - 0x72, 0x32, 0x7a, 0x1f, 0x72, 0x2e, 0x6d, 0x75, 0x3b, 0x38, 0xe0, 0xac, 0x68, 0x48, 0xb3, 0xfa, - 0x04, 0x74, 0x0c, 0x5f, 0xc4, 0xc1, 0x91, 0x4f, 0x49, 0x20, 0xd6, 0xce, 0x91, 0x4b, 0x7d, 0xb7, - 0x21, 0x3c, 0x95, 0x98, 0x4f, 0x2e, 0xe4, 0x97, 0xaa, 0x71, 0x6d, 0xd3, 0xd2, 0xac, 0x5a, 0x1f, - 0xec, 0x81, 0xc6, 0xb2, 0xe7, 0xf0, 0x49, 0x22, 0x2b, 0xdd, 0x82, 0x77, 0x4e, 0x39, 0x8c, 0x10, - 0x4c, 0x04, 0x6e, 0x07, 0xcb, 0xd4, 0xca, 0xd9, 0xf2, 0x1b, 0xcd, 0x41, 0xea, 0xc8, 0x6d, 0x77, - 0xb1, 0xcc, 0x8a, 0x9c, 0xad, 0x16, 0xe6, 0xaf, 0x0c, 0xc8, 0x46, 0x2e, 0x45, 0x8f, 0x01, 0x42, - 0x2a, 0xb2, 0x9e, 0x8b, 0xe8, 0x19, 0x52, 0xf9, 0xaf, 0x8d, 0x1b, 0x18, 0x6b, 0x47, 0x41, 0x3c, - 0xb7, 0x07, 0xc0, 0x4a, 0x9f, 0x40, 0x36, 0xa2, 0x8f, 0xa1, 0xdd, 0xef, 0x0d, 0xc8, 0x45, 0x79, - 0xf3, 0x1c, 0xad, 0x43, 0x4a, 0x25, 0xa0, 0xd2, 0x2c, 0x76, 0xca, 0x88, 0x14, 0xdd, 0x22, 0x1e, - 0xb6, 0x15, 0x3b, 0x7a, 0x08, 0xf9, 0xc1, 0x2c, 0x55, 0x41, 0xfa, 0x34, 0x7e, 0x95, 0x68, 0x7d, - 0x24, 0xe4, 0x20, 0x92, 0xf9, 0x23, 0x03, 0xb2, 0x91, 0xb0, 0x53, 0xad, 0x5c, 0x87, 0xf4, 0x85, - 0x4a, 0x53, 0x73, 0xa3, 0x0f, 0x60, 0xd2, 0x67, 0xba, 0x13, 0x8a, 0x80, 0x17, 0x27, 0x64, 0xf6, - 0x16, 0x7c, 0x56, 0xeb, 0xd1, 0xcc, 0x43, 0x98, 0x1c, 0xd2, 0xf5, 0x32, 0x35, 0x32, 0x3f, 0x83, - 0xb4, 0xee, 0x16, 0x08, 0x26, 0x0e, 0x5c, 0x76, 0x10, 0x49, 0x11, 0xdf, 0xe8, 0x1a, 0x00, 0xf3, - 0x5f, 0x60, 0xa7, 0xf1, 0x9c, 0x4b, 0x87, 0x1b, 0x0b, 0x49, 0x3b, 0x27, 0x28, 0xab, 0x82, 0x60, - 0xfe, 0x25, 0x09, 0x05, 0xd5, 0x1e, 0x6d, 0xcc, 0xba, 0x6d, 0x8e, 0xea, 0x23, 0x1d, 0x47, 0x85, - 0x68, 0x29, 0xae, 0x6e, 0xdb, 0xbd, 0xce, 0x34, 0xdc, 0xa5, 0xf6, 0x4f, 0xed, 0x52, 0x49, 0x09, - 0x7e, 0x63, 0x3c, 0xf0, 0x9e, 0x67, 0x4f, 0x6b, 0x6f, 0xef, 0x41, 0x0e, 0x1f, 0xfb, 0xdc, 0x69, - 0x12, 0x4f, 0x85, 0x26, 0x65, 0x67, 0x05, 0xa1, 0x2a, 0xa2, 0x20, 0x7c, 0xc1, 0x3d, 0x22, 0x5a, - 0xb5, 0xfb, 0x4c, 0x76, 0xbf, 0x82, 0x9d, 0x53, 0x14, 0xdb, 0x7d, 0x86, 0x76, 0x61, 0x52, 0x6f, - 0xeb, 0xb8, 0xa4, 0xcf, 0x15, 0x97, 0x82, 0x02, 0xd1, 0x31, 0x51, 0x32, 0x31, 0xa5, 0x52, 0x66, - 0xa6, 0x27, 0x13, 0x53, 0xda, 0x97, 0x29, 0xb6, 0xb5, 0xcc, 0xec, 0xb9, 0x65, 0x62, 0x4a, 0xd5, - 0xca, 0xfc, 0xad, 0x01, 0xd0, 0x0f, 0x84, 0x48, 0x8b, 0xd0, 0xe5, 0xbd, 0xb4, 0x10, 0xdf, 0x6f, - 0xad, 0x1c, 0x8a, 0x90, 0x69, 0x92, 0x80, 0xe3, 0x80, 0x17, 0x93, 0xd2, 0xb6, 0x68, 0x19, 0xaf, - 0x50, 0x3a, 0x30, 0x3d, 0x12, 0xd4, 0xcb, 0xd4, 0xd6, 0x7c, 0x9d, 0x80, 0x29, 0x25, 0x1d, 0xdb, - 0xf8, 0x3b, 0xdd, 0xa8, 0x9e, 0x03, 0xc6, 0xdd, 0xa0, 0x89, 0x9d, 0x81, 0x12, 0x2d, 0x44, 0xc4, - 0x2d, 0x5d, 0xaa, 0xae, 0x2c, 0x92, 0x71, 0xe5, 0xeb, 0xd2, 0xd2, 0xdc, 0xa8, 0x0c, 0xb3, 0xec, - 0xd0, 0x0f, 0xd5, 0xdc, 0x73, 0xda, 0x84, 0x1c, 0x76, 0x43, 0xe9, 0xb7, 0xac, 0x3d, 0x2d, 0x36, - 0xe4, 0xf4, 0xdb, 0x94, 0x64, 0x74, 0x1d, 0xde, 0xe5, 0x84, 0xbb, 0x6d, 0x47, 0x5d, 0x2e, 0x44, - 0x35, 0x3a, 0x4d, 0xd2, 0x0d, 0xb8, 0x4e, 0xeb, 0x77, 0xe4, 0xee, 0x9d, 0x40, 0x47, 0xb9, 0x2a, - 0xb6, 0x4e, 0x65, 0x52, 0x95, 0x9f, 0x92, 0x95, 0x3f, 0xc2, 0xa4, 0x7a, 0xc0, 0x0f, 0x0c, 0x98, - 0xee, 0x79, 0x85, 0x85, 0x24, 0x60, 0x18, 0x6d, 0x42, 0x9a, 0xca, 0x86, 0xa0, 0xef, 0x48, 0x9f, - 0x8c, 0x69, 0xb1, 0xe4, 0xb5, 0x35, 0x86, 0x70, 0xb2, 0x34, 0xd9, 0x73, 0x34, 0x68, 0x42, 0xe5, - 0x82, 0x22, 0xaa, 0xc3, 0xe6, 0xbf, 0x13, 0x50, 0xd4, 0x6a, 0x6c, 0x47, 0xd7, 0xbf, 0x7b, 0x98, - 0xbb, 0x9e, 0xcb, 0x5d, 0xf4, 0x14, 0x52, 0x8c, 0xbb, 0x2d, 0x15, 0x9e, 0xa9, 0xa5, 0xf5, 0xb8, - 0xea, 0x9c, 0x05, 0x68, 0xed, 0x0a, 0x34, 0x5b, 0x81, 0x8a, 0x2a, 0x54, 0x11, 0xba, 0xd8, 0xf5, - 0xad, 0xa0, 0x40, 0x74, 0xe5, 0x7f, 0x04, 0x48, 0xb7, 0x13, 0xc6, 0x29, 0x76, 0x3b, 0x2a, 0xbd, - 0x92, 0x32, 0xbd, 0x66, 0xd4, 0xce, 0xae, 0xdc, 0x90, 0x29, 0xa6, 0x4e, 0x8b, 0x46, 0x30, 0x78, - 0x7a, 0xa2, 0x77, 0x1a, 0x53, 0xda, 0x3f, 0x6d, 0x6e, 0x43, 0x4a, 0x1a, 0x80, 0xf2, 0x90, 0xa9, - 0x6f, 0xdd, 0xdd, 0xda, 0x7e, 0xb8, 0x35, 0xf3, 0x05, 0x34, 0x0d, 0xf9, 0xea, 0x4a, 0xf5, 0x76, - 0xcd, 0xa9, 0xde, 0xae, 0x55, 0xef, 0xce, 0x18, 0x08, 0x20, 0x7d, 0xbf, 0x5e, 0xab, 0xd7, 0xd6, - 0x66, 0x12, 0x68, 0x12, 0x72, 0xb5, 0x47, 0xb5, 0x6a, 0x7d, 0xef, 0xce, 0xd6, 0xc6, 0x4c, 0x52, - 0x2c, 0xab, 0xdb, 0xf7, 0x76, 0x36, 0x6b, 0x7b, 0xb5, 0xb5, 0x99, 0x09, 0xf3, 0x67, 0x06, 0xbc, - 0xbb, 0x81, 0xf9, 0x50, 0xf4, 0xc6, 0xa9, 0x90, 0xcb, 0xf0, 0xa0, 0xf9, 0x2f, 0x03, 0xae, 0xd6, - 0x43, 0xcf, 0xe5, 0xf8, 0x73, 0xa5, 0x17, 0x7a, 0xdc, 0x03, 0xd5, 0xe9, 0x9c, 0xbc, 0x40, 0x8d, - 0x68, 0x68, 0x5d, 0x04, 0x3f, 0x35, 0xe0, 0xca, 0xba, 0x1f, 0x78, 0xf7, 0x7c, 0xc6, 0xfc, 0xa0, - 0xb5, 0xda, 0x26, 0x0d, 0x36, 0x96, 0xc1, 0xf7, 0xa1, 0xd0, 0x68, 0x93, 0x86, 0x36, 0x37, 0x9a, - 0xdf, 0xe3, 0xda, 0x9b, 0x17, 0x18, 0xea, 0x9b, 0x99, 0xdf, 0x85, 0xe2, 0x49, 0x95, 0x74, 0x9f, - 0xf8, 0x16, 0xcc, 0x75, 0x14, 0xdd, 0x79, 0x0b, 0x62, 0x51, 0xa7, 0x2f, 0x23, 0x92, 0xfe, 0x3d, - 0x98, 0x55, 0x39, 0x20, 0x88, 0x91, 0x2b, 0xe4, 0x53, 0x4e, 0xce, 0x99, 0x0b, 0x3f, 0xe5, 0x24, - 0x4a, 0xff, 0x02, 0x25, 0x9a, 0x83, 0x4c, 0x92, 0x82, 0x2d, 0xbf, 0xcd, 0x9f, 0x1b, 0x70, 0x65, - 0xd5, 0xe5, 0xcd, 0x83, 0xbe, 0x16, 0xe3, 0x45, 0xa4, 0x0e, 0x59, 0xaa, 0xce, 0x47, 0x6e, 0x89, - 0x7d, 0xb1, 0x3f, 0x61, 0xb8, 0xdd, 0x83, 0x32, 0x7f, 0x9c, 0x80, 0xe2, 0x49, 0xbd, 0x74, 0x58, - 0x5a, 0x90, 0xa3, 0xfa, 0x3b, 0xba, 0xb3, 0xdf, 0x89, 0x2b, 0xf4, 0x2c, 0x50, 0x2b, 0xfa, 0xb0, - 0xfb, 0xd8, 0xa5, 0x1f, 0x1a, 0x90, 0xed, 0x49, 0xdd, 0x86, 0xfc, 0x40, 0x12, 0x9c, 0x33, 0x24, - 0xd0, 0x4f, 0x3d, 0x54, 0x86, 0xb4, 0x7a, 0xcc, 0xeb, 0xb2, 0x45, 0x11, 0x16, 0x0d, 0x9b, 0xa2, - 0x83, 0xf3, 0x2e, 0xb3, 0xf5, 0x09, 0xf3, 0x4f, 0x06, 0x4c, 0x6d, 0x60, 0xbe, 0x47, 0xf1, 0x78, - 0xb3, 0x7d, 0x1b, 0xf2, 0x17, 0x7f, 0xb8, 0x03, 0xed, 0xbf, 0xd9, 0xdf, 0x83, 0x5c, 0xe8, 0xb6, - 0xb0, 0x23, 0x2e, 0xd9, 0xb2, 0x33, 0xa4, 0xec, 0xac, 0x20, 0xec, 0xfa, 0x2f, 0xe4, 0x15, 0x54, - 0x6e, 0x72, 0x72, 0x88, 0x03, 0xdd, 0xde, 0xe5, 0xf1, 0x3d, 0x41, 0x30, 0x7f, 0x62, 0xc0, 0x74, - 0xcf, 0x08, 0xed, 0xd5, 0xdd, 0xe1, 0x37, 0x93, 0x8a, 0xe6, 0xe2, 0xd8, 0x6f, 0xa6, 0xa1, 0xf7, - 0x12, 0xfa, 0x10, 0xa6, 0x03, 0x7c, 0xcc, 0x9d, 0x01, 0x65, 0xd4, 0xf3, 0x6f, 0x52, 0x90, 0x77, - 0x22, 0x85, 0x96, 0x7e, 0x63, 0x40, 0xae, 0x16, 0x61, 0xa2, 0x5f, 0x18, 0x90, 0xd1, 0x13, 0x15, - 0x7d, 0x75, 0xcc, 0x11, 0xac, 0x83, 0x52, 0xba, 0x16, 0xf1, 0x0d, 0xfc, 0xef, 0xb1, 0x7a, 0xf3, - 0xd9, 0xfc, 0xf4, 0xfb, 0x7f, 0xfd, 0xc7, 0xeb, 0x44, 0xc5, 0x2c, 0x47, 0xff, 0x9e, 0x5e, 0x0e, - 0x85, 0xf0, 0x66, 0xb9, 0xfc, 0xaa, 0xa2, 0x3a, 0x26, 0x5b, 0x56, 0xa2, 0xf0, 0xb2, 0x51, 0x5e, - 0xfa, 0x4f, 0x12, 0xf2, 0xaa, 0xad, 0xca, 0x3b, 0x14, 0xfa, 0xa7, 0x72, 0xe4, 0xd0, 0xd3, 0xe6, - 0xeb, 0x71, 0x35, 0x3e, 0x7d, 0x10, 0x96, 0xce, 0xd5, 0xdf, 0x4d, 0x57, 0x1a, 0xf4, 0x4d, 0xf4, - 0xf8, 0x8d, 0x06, 0x7d, 0xac, 0xa6, 0x09, 0xab, 0xbc, 0x1c, 0x1a, 0x59, 0x96, 0x78, 0xc7, 0xbd, - 0x1a, 0x25, 0xf6, 0x1f, 0x75, 0xaf, 0xd0, 0x7f, 0x0d, 0x40, 0x27, 0xe7, 0x24, 0x5a, 0x19, 0xaf, - 0xcd, 0xbc, 0x3d, 0x93, 0x43, 0x69, 0xf2, 0xb7, 0x4b, 0x97, 0x67, 0xf2, 0xf2, 0xf0, 0x00, 0x5e, - 0xfa, 0x65, 0x0a, 0xae, 0x56, 0x55, 0x2b, 0x5f, 0xf1, 0x3c, 0x8a, 0x19, 0x13, 0xcf, 0x8b, 0x5d, - 0x4e, 0xa8, 0xb8, 0x24, 0xfd, 0xd9, 0x80, 0x99, 0xd1, 0x09, 0x86, 0x6e, 0xc5, 0xff, 0x87, 0x71, - 0xea, 0x38, 0x2e, 0x7d, 0xe3, 0xfc, 0x00, 0xaa, 0xb2, 0xcd, 0x1b, 0xd2, 0x4f, 0x8b, 0xe6, 0x47, - 0xff, 0xc7, 0x4f, 0xa2, 0x1b, 0xb2, 0xe5, 0xfd, 0x3e, 0xc4, 0xb2, 0x51, 0x96, 0x06, 0x8d, 0xb6, - 0xe9, 0xf8, 0x06, 0x9d, 0x31, 0xcd, 0xe2, 0x1b, 0x74, 0xd6, 0x84, 0x18, 0xc3, 0xa0, 0x46, 0x1f, - 0x42, 0x18, 0xf4, 0x37, 0x03, 0x32, 0xba, 0xef, 0xc5, 0x6f, 0x2c, 0xc3, 0xdd, 0xbe, 0x74, 0x63, - 0x6c, 0x3e, 0xad, 0xf5, 0x53, 0xa9, 0xf5, 0x03, 0xb4, 0xf7, 0x26, 0xad, 0x2b, 0x2f, 0x07, 0x26, - 0x45, 0x94, 0xa3, 0x83, 0xa4, 0xc1, 0x0c, 0x6d, 0x29, 0x29, 0xab, 0x7f, 0x34, 0xa0, 0xdc, 0x24, - 0x9d, 0x98, 0xca, 0xad, 0xce, 0xd9, 0x92, 0xde, 0xeb, 0xb9, 0x3b, 0x94, 0x70, 0xb2, 0x63, 0x3c, - 0xa9, 0x6b, 0xfe, 0x16, 0x69, 0xbb, 0x41, 0xcb, 0x22, 0xb4, 0x55, 0x69, 0xe1, 0x40, 0xfe, 0x65, - 0xad, 0xa8, 0x2d, 0x37, 0xf4, 0xd9, 0x9b, 0xfe, 0xe4, 0x7f, 0x36, 0x42, 0xfe, 0x75, 0x22, 0x69, - 0xd7, 0x1e, 0xfd, 0x2e, 0x71, 0x6d, 0x43, 0xa1, 0x8f, 0x08, 0xb7, 0x1e, 0x2c, 0xee, 0x61, 0xc6, - 0x1b, 0x69, 0x29, 0xe7, 0xfa, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0xde, 0xd9, 0x80, 0xd0, 0x30, - 0x18, 0x00, 0x00, + // 1868 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0xcf, 0x6f, 0x1c, 0x57, + 0x1d, 0x67, 0x76, 0xbd, 0xeb, 0xdd, 0xef, 0xae, 0x63, 0xe7, 0x35, 0x34, 0x9b, 0x6d, 0x83, 0xdc, + 0xa9, 0x54, 0x59, 0x56, 0x3b, 0x4b, 0x9c, 0x96, 0x08, 0x57, 0xa5, 0xc4, 0xeb, 0x75, 0x6a, 0x35, + 0xb1, 0xdd, 0xb1, 0xd7, 0x6d, 0x4a, 0xa5, 0xe1, 0xed, 0xcc, 0xf3, 0x66, 0xc8, 0xee, 0xbc, 0xe1, + 0xbd, 0xb7, 0x6e, 0xd2, 0x10, 0x0e, 0x08, 0x89, 0x03, 0x02, 0x09, 0x2a, 0x04, 0x12, 0x37, 0x24, + 0x84, 0x84, 0x38, 0xf1, 0x1f, 0xc0, 0x1f, 0xc0, 0x01, 0x2e, 0x9c, 0x11, 0x27, 0x4e, 0x9c, 0x11, + 0x12, 0xe8, 0xfd, 0x98, 0x99, 0xdd, 0xb5, 0x43, 0x66, 0xed, 0x44, 0xe2, 0xb6, 0xf3, 0x7d, 0xef, + 0xfb, 0xf9, 0xfe, 0xfe, 0xf1, 0x6c, 0x78, 0xa7, 0x4f, 0x69, 0x7f, 0x40, 0x5a, 0x01, 0x39, 0x16, + 0x94, 0x0e, 0x78, 0x8b, 0x91, 0x21, 0x15, 0x84, 0x3c, 0x20, 0xfe, 0x48, 0x84, 0x34, 0x6a, 0x1d, + 0x5f, 0x13, 0x84, 0x0b, 0x43, 0xf6, 0x52, 0xba, 0x13, 0x33, 0x2a, 0x28, 0x7a, 0x4d, 0xb3, 0x3b, + 0x09, 0xbb, 0x33, 0xc5, 0xee, 0x68, 0xf6, 0xe6, 0xcb, 0x46, 0x0c, 0x8e, 0xc3, 0x16, 0x8e, 0x22, + 0x2a, 0xb0, 0x3c, 0xe5, 0x1a, 0xa5, 0xf9, 0xaa, 0x39, 0x1d, 0xd0, 0xa8, 0xcf, 0x46, 0x51, 0x14, + 0x46, 0xfd, 0x16, 0x8d, 0x09, 0x9b, 0xb8, 0xf4, 0x25, 0x73, 0x49, 0x7d, 0xf5, 0x46, 0x47, 0xad, + 0x60, 0xa4, 0x2f, 0x98, 0xf3, 0xcb, 0xe6, 0x9c, 0xc5, 0x7e, 0x8b, 0x0b, 0x2c, 0x46, 0x86, 0xd1, + 0xfe, 0x7d, 0x11, 0xca, 0x37, 0x7d, 0x79, 0x13, 0x75, 0xe1, 0x82, 0x4f, 0x87, 0x43, 0x1c, 0x05, + 0x5e, 0x10, 0xf6, 0x09, 0x17, 0x0d, 0x6b, 0xd9, 0x5a, 0xa9, 0xad, 0x39, 0x4e, 0x3e, 0x3b, 0x9c, + 0x4d, 0xc5, 0xe5, 0x2e, 0x18, 0x14, 0xfd, 0x89, 0x3e, 0x86, 0x8b, 0x61, 0x14, 0x8f, 0x84, 0xc7, + 0x28, 0x15, 0x09, 0x72, 0xe1, 0x4c, 0xc8, 0x8b, 0x0a, 0xc8, 0xa5, 0x54, 0x18, 0xec, 0x57, 0xa0, + 0x4e, 0x47, 0x42, 0x82, 0x1f, 0x85, 0x03, 0xc2, 0x1b, 0xc5, 0xe5, 0xe2, 0x4a, 0xd5, 0xad, 0x69, + 0xda, 0x96, 0x24, 0xa1, 0x37, 0x00, 0x99, 0x2b, 0x41, 0xc8, 0x88, 0x2f, 0x28, 0x0b, 0x09, 0x6f, + 0xcc, 0xa9, 0x8b, 0x17, 0xf5, 0xc9, 0x66, 0x76, 0x80, 0x6e, 0x43, 0x25, 0x1e, 0x60, 0x71, 0x44, + 0xd9, 0xb0, 0x51, 0x52, 0x4a, 0x7e, 0x39, 0xaf, 0x92, 0x7b, 0x86, 0xcf, 0x4d, 0x11, 0xd0, 0x75, + 0x98, 0x17, 0xe1, 0x90, 0xd0, 0x91, 0x68, 0x94, 0x15, 0xd8, 0x95, 0x04, 0x2c, 0x09, 0x94, 0xb3, + 0x69, 0x02, 0xe5, 0x26, 0x37, 0xd1, 0x32, 0xd4, 0x03, 0xea, 0x45, 0x54, 0x78, 0x3e, 0xf6, 0xef, + 0x91, 0xc6, 0xfc, 0xb2, 0xb5, 0x52, 0x71, 0x21, 0xa0, 0x3b, 0x54, 0xb4, 0x25, 0xc5, 0xfe, 0x9b, + 0x05, 0xf3, 0x6d, 0xed, 0x64, 0xf4, 0x32, 0x54, 0x31, 0xeb, 0x8f, 0x86, 0x24, 0x12, 0xbc, 0x61, + 0x29, 0xb3, 0x32, 0x02, 0x7a, 0x00, 0x5f, 0x24, 0xd1, 0x71, 0xc8, 0x68, 0x24, 0xbf, 0xbd, 0x63, + 0xcc, 0x42, 0xdc, 0x93, 0x9e, 0x2a, 0x2c, 0x17, 0x57, 0x6a, 0x6b, 0xed, 0xbc, 0xb6, 0x19, 0x69, + 0x4e, 0x27, 0x03, 0x3b, 0x34, 0x58, 0xee, 0x25, 0x72, 0x92, 0xc8, 0x9b, 0xef, 0xc2, 0x0b, 0xa7, + 0x5c, 0x46, 0x08, 0xe6, 0x22, 0x3c, 0x24, 0x2a, 0xb5, 0xaa, 0xae, 0xfa, 0x8d, 0x2e, 0x41, 0xe9, + 0x18, 0x0f, 0x46, 0x44, 0x65, 0x45, 0xd5, 0xd5, 0x1f, 0xf6, 0x2f, 0x2d, 0xa8, 0x24, 0x2e, 0x45, + 0x77, 0x01, 0x62, 0x26, 0xb3, 0x5e, 0xc8, 0xe8, 0x59, 0x4a, 0xf9, 0xaf, 0xce, 0x1a, 0x18, 0x67, + 0x4f, 0x43, 0x3c, 0x74, 0xc7, 0xc0, 0x9a, 0x6f, 0x42, 0x25, 0xa1, 0xcf, 0xa0, 0xdd, 0xef, 0x2c, + 0xa8, 0x26, 0x79, 0xf3, 0x10, 0x6d, 0x41, 0x49, 0x27, 0xa0, 0xd6, 0x2c, 0x77, 0xca, 0xc8, 0x14, + 0xdd, 0xa1, 0x01, 0x71, 0x35, 0x3b, 0xfa, 0x10, 0x6a, 0xe3, 0x59, 0xaa, 0x83, 0xf4, 0x56, 0xfe, + 0x2a, 0x31, 0xfa, 0x28, 0xc8, 0x71, 0x24, 0xfb, 0x87, 0x16, 0x54, 0x12, 0x61, 0xa7, 0x5a, 0xb9, + 0x05, 0xe5, 0x73, 0x95, 0xa6, 0xe1, 0x46, 0xaf, 0xc2, 0x42, 0xc8, 0x4d, 0x27, 0x94, 0x01, 0x6f, + 0xcc, 0xa9, 0xec, 0xad, 0x87, 0xbc, 0x93, 0xd2, 0xec, 0xfb, 0xb0, 0x30, 0xa1, 0xeb, 0xf3, 0xd4, + 0xc8, 0x7e, 0x1b, 0xca, 0xa6, 0x5b, 0x20, 0x98, 0xbb, 0x87, 0xf9, 0xbd, 0x44, 0x8a, 0xfc, 0x8d, + 0xae, 0x02, 0xf0, 0xf0, 0x33, 0xe2, 0xf5, 0x1e, 0x0a, 0xe5, 0x70, 0x6b, 0xa5, 0xe8, 0x56, 0x25, + 0x65, 0x43, 0x12, 0xec, 0x3f, 0x17, 0xa1, 0xae, 0xdb, 0xa3, 0x4b, 0xf8, 0x68, 0x20, 0x50, 0x77, + 0xaa, 0xe3, 0xe8, 0x10, 0xad, 0xe5, 0xd5, 0x6d, 0x37, 0xed, 0x4c, 0x93, 0x5d, 0xea, 0xe8, 0xd4, + 0x2e, 0x55, 0x54, 0xe0, 0x37, 0x66, 0x03, 0x4f, 0x3d, 0x7b, 0x5a, 0x7b, 0x7b, 0x09, 0xaa, 0xe4, + 0x41, 0x28, 0x3c, 0x9f, 0x06, 0x3a, 0x34, 0x25, 0xb7, 0x22, 0x09, 0x6d, 0x19, 0x05, 0xe9, 0x0b, + 0x11, 0x50, 0xd9, 0xaa, 0xf1, 0xa7, 0xaa, 0xfb, 0xd5, 0xdd, 0xaa, 0xa6, 0xb8, 0xf8, 0x53, 0xb4, + 0x0f, 0x0b, 0xe6, 0xd8, 0xc4, 0xa5, 0x7c, 0xa6, 0xb8, 0xd4, 0x35, 0x88, 0x89, 0x89, 0x96, 0x49, + 0x18, 0x53, 0x32, 0xe7, 0x53, 0x99, 0x84, 0xb1, 0x4c, 0xa6, 0x3c, 0x36, 0x32, 0x2b, 0x67, 0x96, + 0x49, 0x18, 0xd3, 0x5f, 0xf6, 0x6f, 0x2c, 0x80, 0x2c, 0x10, 0x32, 0x2d, 0x62, 0x2c, 0xd2, 0xb4, + 0x90, 0xbf, 0x9f, 0x59, 0x39, 0x34, 0x60, 0xde, 0xa7, 0x91, 0x20, 0x91, 0x68, 0x14, 0x95, 0x6d, + 0xc9, 0x67, 0xbe, 0x42, 0x19, 0xc2, 0xe2, 0x54, 0x50, 0x9f, 0xa7, 0xb6, 0xf6, 0xe7, 0x05, 0xb8, + 0xa0, 0xa5, 0x13, 0x97, 0x7c, 0x7b, 0x94, 0xd4, 0x73, 0xc4, 0x05, 0x8e, 0x7c, 0xe2, 0x8d, 0x95, + 0x68, 0x3d, 0x21, 0xee, 0x98, 0x52, 0xc5, 0xaa, 0x48, 0x66, 0x95, 0x6f, 0x4a, 0xcb, 0x70, 0xa3, + 0x55, 0xb8, 0xc8, 0xef, 0x87, 0xb1, 0x9e, 0x7b, 0xde, 0x80, 0xd2, 0xfb, 0xa3, 0x58, 0xf9, 0xad, + 0xe2, 0x2e, 0xca, 0x03, 0x35, 0xfd, 0x6e, 0x2b, 0x32, 0xba, 0x0e, 0x2f, 0x0a, 0x2a, 0xf0, 0xc0, + 0xd3, 0xcb, 0x85, 0xac, 0x46, 0xcf, 0xa7, 0xa3, 0x48, 0x98, 0xb4, 0x7e, 0x41, 0x9d, 0x6e, 0x47, + 0x26, 0xca, 0x6d, 0x79, 0x74, 0x2a, 0x93, 0xae, 0xfc, 0x92, 0xaa, 0xfc, 0x29, 0x26, 0xdd, 0x03, + 0xbe, 0x6f, 0xc1, 0x62, 0xea, 0x15, 0x1e, 0xd3, 0x88, 0x13, 0x74, 0x1b, 0xca, 0x4c, 0x35, 0x04, + 0xb3, 0x23, 0xbd, 0x39, 0xa3, 0xc5, 0x8a, 0xd7, 0x35, 0x18, 0xd2, 0xc9, 0xca, 0xe4, 0xc0, 0x33, + 0xa0, 0x05, 0x9d, 0x0b, 0x9a, 0xa8, 0x2f, 0xdb, 0xff, 0x2a, 0x40, 0xc3, 0xa8, 0xb1, 0x9b, 0xac, + 0x7f, 0x77, 0x88, 0xc0, 0x01, 0x16, 0x18, 0x7d, 0x02, 0x25, 0x2e, 0x70, 0x5f, 0x87, 0xe7, 0xc2, + 0xda, 0x56, 0x5e, 0x75, 0x9e, 0x04, 0xe8, 0xec, 0x4b, 0x34, 0x57, 0x83, 0xca, 0x2a, 0xd4, 0x11, + 0x3a, 0xdf, 0xfa, 0x56, 0xd7, 0x20, 0xa6, 0xf2, 0x5f, 0x07, 0x64, 0xda, 0x09, 0x17, 0x8c, 0xe0, + 0xa1, 0x4e, 0xaf, 0xa2, 0x4a, 0xaf, 0x25, 0x7d, 0xb2, 0xaf, 0x0e, 0x54, 0x8a, 0xe9, 0xdb, 0xb2, + 0x11, 0x8c, 0xdf, 0x9e, 0x4b, 0x6f, 0x13, 0xc6, 0xb2, 0xdb, 0xf6, 0x2e, 0x94, 0x94, 0x01, 0xa8, + 0x06, 0xf3, 0xdd, 0x9d, 0xf7, 0x77, 0x76, 0x3f, 0xdc, 0x59, 0xfa, 0x02, 0x5a, 0x84, 0x5a, 0xfb, + 0x66, 0xfb, 0xbd, 0x8e, 0xd7, 0x7e, 0xaf, 0xd3, 0x7e, 0x7f, 0xc9, 0x42, 0x00, 0xe5, 0x0f, 0xba, + 0x9d, 0x6e, 0x67, 0x73, 0xa9, 0x80, 0x16, 0xa0, 0xda, 0xf9, 0xa8, 0xd3, 0xee, 0x1e, 0x6c, 0xef, + 0xdc, 0x5a, 0x2a, 0xca, 0xcf, 0xf6, 0xee, 0x9d, 0xbd, 0xdb, 0x9d, 0x83, 0xce, 0xe6, 0xd2, 0x9c, + 0xfd, 0x53, 0x0b, 0x5e, 0xbc, 0x45, 0xc4, 0x44, 0xf4, 0x66, 0xa9, 0x90, 0xe7, 0xe1, 0x41, 0xfb, + 0x9f, 0x16, 0x5c, 0xe9, 0xc6, 0x01, 0x16, 0xe4, 0xff, 0x4a, 0x2f, 0x74, 0x37, 0x05, 0x35, 0xe9, + 0x5c, 0x3c, 0x47, 0x8d, 0x18, 0x68, 0x53, 0x04, 0x3f, 0xb1, 0xe0, 0xf2, 0x56, 0x18, 0x05, 0x77, + 0x42, 0xce, 0xc3, 0xa8, 0xbf, 0x31, 0xa0, 0x3d, 0x3e, 0x93, 0xc1, 0x1f, 0x40, 0xbd, 0x37, 0xa0, + 0x3d, 0x63, 0x6e, 0x32, 0xbf, 0x67, 0xb5, 0xb7, 0x26, 0x31, 0xf4, 0x6f, 0x6e, 0x7f, 0x07, 0x1a, + 0x27, 0x55, 0x32, 0x7d, 0xe2, 0x9b, 0x70, 0x69, 0xa8, 0xe9, 0xde, 0x33, 0x10, 0x8b, 0x86, 0x99, + 0x8c, 0x44, 0xfa, 0x77, 0xe1, 0xa2, 0xce, 0x01, 0x49, 0x4c, 0x5c, 0xa1, 0x9e, 0x72, 0x6a, 0xce, + 0x9c, 0xfb, 0x29, 0xa7, 0x50, 0xb2, 0x05, 0x4a, 0x36, 0x07, 0x95, 0x24, 0x75, 0x57, 0xfd, 0xb6, + 0x7f, 0x66, 0xc1, 0xe5, 0x0d, 0x2c, 0xfc, 0x7b, 0x99, 0x16, 0xb3, 0x45, 0xa4, 0x0b, 0x15, 0xa6, + 0xef, 0x27, 0x6e, 0xc9, 0xbd, 0xd8, 0x9f, 0x30, 0xdc, 0x4d, 0xa1, 0xec, 0x1f, 0x15, 0xa0, 0x71, + 0x52, 0x2f, 0x13, 0x96, 0x3e, 0x54, 0x99, 0xf9, 0x9d, 0xec, 0xec, 0xdb, 0x79, 0x85, 0x3e, 0x09, + 0xd4, 0x49, 0x7e, 0xb8, 0x19, 0x76, 0xf3, 0x07, 0x16, 0x54, 0x52, 0xa9, 0xbb, 0x50, 0x1b, 0x4b, + 0x82, 0x33, 0x86, 0x04, 0xb2, 0xd4, 0x43, 0xab, 0x50, 0xd6, 0x8f, 0x79, 0x53, 0xb6, 0x28, 0xc1, + 0x62, 0xb1, 0x2f, 0x3b, 0xb8, 0x18, 0x71, 0xd7, 0xdc, 0xb0, 0xff, 0x68, 0xc1, 0x85, 0x5b, 0x44, + 0x1c, 0x30, 0x32, 0xdb, 0x6c, 0xdf, 0x85, 0xda, 0xf9, 0x1f, 0xee, 0xc0, 0xb2, 0x37, 0xfb, 0x4b, + 0x50, 0x8d, 0x71, 0x9f, 0x78, 0x72, 0xc9, 0x56, 0x9d, 0xa1, 0xe4, 0x56, 0x24, 0x61, 0x3f, 0xfc, + 0x4c, 0xad, 0xa0, 0xea, 0x50, 0xd0, 0xfb, 0x24, 0x32, 0xed, 0x5d, 0x5d, 0x3f, 0x90, 0x04, 0xfb, + 0xc7, 0x16, 0x2c, 0xa6, 0x46, 0x18, 0xaf, 0xee, 0x4f, 0xbe, 0x99, 0x74, 0x34, 0xaf, 0xcd, 0xfc, + 0x66, 0x9a, 0x78, 0x2f, 0xa1, 0xd7, 0x60, 0x31, 0x22, 0x0f, 0x84, 0x37, 0xa6, 0x8c, 0x7e, 0xfe, + 0x2d, 0x48, 0xf2, 0x5e, 0xaa, 0xd0, 0x1d, 0xa8, 0x1d, 0x50, 0x3a, 0xd8, 0x24, 0x02, 0x87, 0x03, + 0xb5, 0x5e, 0x4b, 0x69, 0xe3, 0xde, 0xac, 0x48, 0x82, 0xf2, 0xe4, 0x2b, 0x50, 0x57, 0x87, 0xc7, + 0x84, 0xf1, 0x64, 0x57, 0xaa, 0xba, 0x35, 0x49, 0x3b, 0xd4, 0x24, 0xd9, 0xd1, 0x17, 0x4d, 0x74, + 0xd2, 0xd1, 0x7e, 0x68, 0xd8, 0x02, 0x2d, 0xc3, 0xa4, 0xcd, 0xf5, 0xbc, 0x06, 0x8e, 0xa9, 0xa7, + 0x65, 0x8d, 0xe9, 0x6a, 0xba, 0x74, 0x18, 0x18, 0x5d, 0x2a, 0x9a, 0xb0, 0x1d, 0xc8, 0x71, 0xab, + 0x84, 0x86, 0xd1, 0x31, 0xf5, 0x71, 0x72, 0xcb, 0x0c, 0x67, 0x79, 0xb2, 0x9d, 0x1e, 0x6c, 0x07, + 0x68, 0x1d, 0xae, 0xf8, 0x94, 0x31, 0x32, 0xc0, 0x82, 0x04, 0x63, 0x3c, 0x5c, 0x32, 0xe9, 0x20, + 0x5e, 0xce, 0x2e, 0x64, 0xac, 0x7c, 0x3b, 0x58, 0xfb, 0xb5, 0x05, 0xd5, 0x4e, 0xa2, 0x34, 0xfa, + 0xb9, 0x05, 0xf3, 0x66, 0x27, 0x41, 0x5f, 0x99, 0x71, 0x89, 0x31, 0x8e, 0x6b, 0x5e, 0x4d, 0xf8, + 0xc6, 0xfe, 0x62, 0xe6, 0xa4, 0x1b, 0x8e, 0xfd, 0xd6, 0xf7, 0xfe, 0xf2, 0xf7, 0xcf, 0x0b, 0x2d, + 0x7b, 0x35, 0xf9, 0xeb, 0xdd, 0xa3, 0x89, 0x22, 0x78, 0x67, 0x75, 0xf5, 0x71, 0x4b, 0xfb, 0x81, + 0xaf, 0x6b, 0x51, 0x64, 0xdd, 0x5a, 0x5d, 0xfb, 0x77, 0x11, 0x6a, 0x7a, 0x30, 0xa9, 0x2d, 0x14, + 0xfd, 0x43, 0xa7, 0xe2, 0xc4, 0xe3, 0xf0, 0x6b, 0x79, 0x35, 0x3e, 0x7d, 0x95, 0x68, 0x9e, 0x69, + 0x42, 0xda, 0x58, 0x19, 0xf4, 0x0d, 0x74, 0xf7, 0xa9, 0x06, 0xbd, 0xa1, 0xe7, 0x31, 0x6f, 0x3d, + 0x9a, 0x18, 0xfa, 0x8e, 0x7c, 0x09, 0x3f, 0x9e, 0x26, 0x66, 0xcf, 0xe2, 0xc7, 0xe8, 0x3f, 0x16, + 0xa0, 0x93, 0x9b, 0x06, 0xba, 0x39, 0x5b, 0xa3, 0x7e, 0x76, 0x26, 0xc7, 0xca, 0xe4, 0x6f, 0x35, + 0x9f, 0x9f, 0xc9, 0xeb, 0x93, 0x2b, 0xcc, 0xda, 0x2f, 0x4a, 0x70, 0xa5, 0xad, 0x87, 0xe1, 0xcd, + 0x20, 0x60, 0x84, 0x73, 0xf9, 0x40, 0xdb, 0x17, 0x94, 0xc9, 0x35, 0xf3, 0x4f, 0x16, 0x2c, 0x4d, + 0xef, 0x00, 0xe8, 0xdd, 0xfc, 0x7f, 0x05, 0x3a, 0x75, 0xa1, 0x69, 0x7e, 0xfd, 0xec, 0x00, 0xba, + 0x37, 0xda, 0x37, 0x94, 0x9f, 0xae, 0xd9, 0xaf, 0xff, 0x0f, 0x3f, 0xc9, 0x79, 0xc2, 0xd7, 0x8f, + 0x32, 0x88, 0x75, 0x6b, 0x55, 0x19, 0x34, 0x3d, 0xe8, 0xf2, 0x1b, 0xf4, 0x84, 0x7d, 0x20, 0xbf, + 0x41, 0x4f, 0x9a, 0xb1, 0x33, 0x18, 0xd4, 0xcb, 0x20, 0xa4, 0x41, 0x7f, 0xb5, 0x60, 0xde, 0x4c, + 0x8e, 0xfc, 0x8d, 0x65, 0x72, 0x5e, 0x36, 0x6f, 0xcc, 0xcc, 0x67, 0xb4, 0xfe, 0x44, 0x69, 0x7d, + 0x88, 0x0e, 0x9e, 0xa6, 0x75, 0xeb, 0xd1, 0xd8, 0xac, 0x4d, 0x72, 0x74, 0x9c, 0x34, 0x9e, 0xa1, + 0x7d, 0x2d, 0x65, 0xe3, 0x0f, 0x16, 0xac, 0xfa, 0x74, 0x98, 0x53, 0xb9, 0x8d, 0x4b, 0xae, 0xa2, + 0xa7, 0x3d, 0x77, 0x8f, 0x51, 0x41, 0xf7, 0xac, 0x8f, 0xbb, 0x86, 0xbf, 0x4f, 0x07, 0x38, 0xea, + 0x3b, 0x94, 0xf5, 0x5b, 0x7d, 0x12, 0xa9, 0xbf, 0x53, 0xb7, 0xf4, 0x11, 0x8e, 0x43, 0xfe, 0xb4, + 0xff, 0x85, 0xbc, 0x3d, 0x45, 0xfe, 0x55, 0xa1, 0xe8, 0x76, 0x3e, 0xfa, 0x6d, 0xe1, 0xea, 0x2d, + 0x8d, 0x3e, 0x25, 0xdc, 0x39, 0xbc, 0x76, 0x40, 0xb8, 0xe8, 0x95, 0x95, 0x9c, 0xeb, 0xff, 0x0d, + 0x00, 0x00, 0xff, 0xff, 0xe9, 0x9c, 0x6f, 0xd3, 0x72, 0x19, 0x00, 0x00, } diff --git a/vendor/google.golang.org/genproto/googleapis/privacy/dlp/v2beta1/dlp.pb.go b/vendor/google.golang.org/genproto/googleapis/privacy/dlp/v2beta1/dlp.pb.go index 9cd8673b..479913d2 100644 --- a/vendor/google.golang.org/genproto/googleapis/privacy/dlp/v2beta1/dlp.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/privacy/dlp/v2beta1/dlp.pb.go @@ -10,10 +10,13 @@ It is generated from these files: It has these top-level messages: InspectConfig + OperationConfig ContentItem + Table InspectResult Finding Location + TableLocation Range ImageLocation RedactContentRequest @@ -34,6 +37,7 @@ It has these top-level messages: CategoryDescription ListRootCategoriesRequest ListRootCategoriesResponse + Value InfoType FieldId PartitionId @@ -43,11 +47,13 @@ It has these top-level messages: DatastoreOptions CloudStorageOptions CloudStoragePath + BigQueryOptions StorageConfig CloudStorageKey DatastoreKey Key RecordKey + BigQueryTable */ package dlp @@ -58,8 +64,8 @@ import _ "google.golang.org/genproto/googleapis/api/annotations" import google_longrunning "google.golang.org/genproto/googleapis/longrunning" import _ "github.com/golang/protobuf/ptypes/empty" import google_protobuf3 "github.com/golang/protobuf/ptypes/timestamp" -import _ "google.golang.org/genproto/googleapis/type/date" -import _ "google.golang.org/genproto/googleapis/type/timeofday" +import google_type "google.golang.org/genproto/googleapis/type/date" +import google_type1 "google.golang.org/genproto/googleapis/type/timeofday" import ( context "golang.org/x/net/context" @@ -126,13 +132,15 @@ type InspectConfig struct { InfoTypes []*InfoType `protobuf:"bytes,1,rep,name=info_types,json=infoTypes" json:"info_types,omitempty"` // Only returns findings equal or above this threshold. MinLikelihood Likelihood `protobuf:"varint,2,opt,name=min_likelihood,json=minLikelihood,enum=google.privacy.dlp.v2beta1.Likelihood" json:"min_likelihood,omitempty"` - // Limits the number of findings per content item. + // Limits the number of findings per content item or long running operation. MaxFindings int32 `protobuf:"varint,3,opt,name=max_findings,json=maxFindings" json:"max_findings,omitempty"` // When true, a contextual quote from the data that triggered a finding is // included in the response; see Finding.quote. IncludeQuote bool `protobuf:"varint,4,opt,name=include_quote,json=includeQuote" json:"include_quote,omitempty"` // When true, excludes type information of the findings. ExcludeTypes bool `protobuf:"varint,6,opt,name=exclude_types,json=excludeTypes" json:"exclude_types,omitempty"` + // Configuration of findings limit given for specified info types. + InfoTypeLimits []*InspectConfig_InfoTypeLimit `protobuf:"bytes,7,rep,name=info_type_limits,json=infoTypeLimits" json:"info_type_limits,omitempty"` } func (m *InspectConfig) Reset() { *m = InspectConfig{} } @@ -175,6 +183,62 @@ func (m *InspectConfig) GetExcludeTypes() bool { return false } +func (m *InspectConfig) GetInfoTypeLimits() []*InspectConfig_InfoTypeLimit { + if m != nil { + return m.InfoTypeLimits + } + return nil +} + +// Max findings configuration per info type, per content item or long running +// operation. +type InspectConfig_InfoTypeLimit struct { + // Type of information the findings limit applies to. Only one limit per + // info_type should be provided. If InfoTypeLimit does not have an + // info_type, the DLP API applies the limit against all info_types that are + // found but not specified in another InfoTypeLimit. + InfoType *InfoType `protobuf:"bytes,1,opt,name=info_type,json=infoType" json:"info_type,omitempty"` + // Max findings limit for the given infoType. + MaxFindings int32 `protobuf:"varint,2,opt,name=max_findings,json=maxFindings" json:"max_findings,omitempty"` +} + +func (m *InspectConfig_InfoTypeLimit) Reset() { *m = InspectConfig_InfoTypeLimit{} } +func (m *InspectConfig_InfoTypeLimit) String() string { return proto.CompactTextString(m) } +func (*InspectConfig_InfoTypeLimit) ProtoMessage() {} +func (*InspectConfig_InfoTypeLimit) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 0} } + +func (m *InspectConfig_InfoTypeLimit) GetInfoType() *InfoType { + if m != nil { + return m.InfoType + } + return nil +} + +func (m *InspectConfig_InfoTypeLimit) GetMaxFindings() int32 { + if m != nil { + return m.MaxFindings + } + return 0 +} + +// Additional configuration for inspect long running operations. +type OperationConfig struct { + // Max number of findings per file, Datastore entity, or database row. + MaxItemFindings int64 `protobuf:"varint,1,opt,name=max_item_findings,json=maxItemFindings" json:"max_item_findings,omitempty"` +} + +func (m *OperationConfig) Reset() { *m = OperationConfig{} } +func (m *OperationConfig) String() string { return proto.CompactTextString(m) } +func (*OperationConfig) ProtoMessage() {} +func (*OperationConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } + +func (m *OperationConfig) GetMaxItemFindings() int64 { + if m != nil { + return m.MaxItemFindings + } + return 0 +} + // Container structure for the content to inspect. type ContentItem struct { // Type of the content, as defined in Content-Type HTTP header. @@ -186,13 +250,14 @@ type ContentItem struct { // Types that are valid to be assigned to DataItem: // *ContentItem_Data // *ContentItem_Value + // *ContentItem_Table DataItem isContentItem_DataItem `protobuf_oneof:"data_item"` } func (m *ContentItem) Reset() { *m = ContentItem{} } func (m *ContentItem) String() string { return proto.CompactTextString(m) } func (*ContentItem) ProtoMessage() {} -func (*ContentItem) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } +func (*ContentItem) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } type isContentItem_DataItem interface { isContentItem_DataItem() @@ -204,9 +269,13 @@ type ContentItem_Data struct { type ContentItem_Value struct { Value string `protobuf:"bytes,3,opt,name=value,oneof"` } +type ContentItem_Table struct { + Table *Table `protobuf:"bytes,4,opt,name=table,oneof"` +} func (*ContentItem_Data) isContentItem_DataItem() {} func (*ContentItem_Value) isContentItem_DataItem() {} +func (*ContentItem_Table) isContentItem_DataItem() {} func (m *ContentItem) GetDataItem() isContentItem_DataItem { if m != nil { @@ -236,11 +305,19 @@ func (m *ContentItem) GetValue() string { return "" } +func (m *ContentItem) GetTable() *Table { + if x, ok := m.GetDataItem().(*ContentItem_Table); ok { + return x.Table + } + return nil +} + // XXX_OneofFuncs is for the internal use of the proto package. func (*ContentItem) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _ContentItem_OneofMarshaler, _ContentItem_OneofUnmarshaler, _ContentItem_OneofSizer, []interface{}{ (*ContentItem_Data)(nil), (*ContentItem_Value)(nil), + (*ContentItem_Table)(nil), } } @@ -254,6 +331,11 @@ func _ContentItem_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { case *ContentItem_Value: b.EncodeVarint(3<<3 | proto.WireBytes) b.EncodeStringBytes(x.Value) + case *ContentItem_Table: + b.EncodeVarint(4<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.Table); err != nil { + return err + } case nil: default: return fmt.Errorf("ContentItem.DataItem has unexpected type %T", x) @@ -278,6 +360,14 @@ func _ContentItem_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Bu x, err := b.DecodeStringBytes() m.DataItem = &ContentItem_Value{x} return true, err + case 4: // data_item.table + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(Table) + err := b.DecodeMessage(msg) + m.DataItem = &ContentItem_Table{msg} + return true, err default: return false, nil } @@ -295,6 +385,11 @@ func _ContentItem_OneofSizer(msg proto.Message) (n int) { n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(len(x.Value))) n += len(x.Value) + case *ContentItem_Table: + s := proto.Size(x.Table) + n += proto.SizeVarint(4<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) @@ -302,6 +397,47 @@ func _ContentItem_OneofSizer(msg proto.Message) (n int) { return n } +// Structured content to inspect. Up to 50,000 `Value`s per request allowed. +type Table struct { + Headers []*FieldId `protobuf:"bytes,1,rep,name=headers" json:"headers,omitempty"` + Rows []*Table_Row `protobuf:"bytes,2,rep,name=rows" json:"rows,omitempty"` +} + +func (m *Table) Reset() { *m = Table{} } +func (m *Table) String() string { return proto.CompactTextString(m) } +func (*Table) ProtoMessage() {} +func (*Table) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } + +func (m *Table) GetHeaders() []*FieldId { + if m != nil { + return m.Headers + } + return nil +} + +func (m *Table) GetRows() []*Table_Row { + if m != nil { + return m.Rows + } + return nil +} + +type Table_Row struct { + Values []*Value `protobuf:"bytes,1,rep,name=values" json:"values,omitempty"` +} + +func (m *Table_Row) Reset() { *m = Table_Row{} } +func (m *Table_Row) String() string { return proto.CompactTextString(m) } +func (*Table_Row) ProtoMessage() {} +func (*Table_Row) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3, 0} } + +func (m *Table_Row) GetValues() []*Value { + if m != nil { + return m.Values + } + return nil +} + // All the findings for a single scanned item. type InspectResult struct { // List of findings for an item. @@ -318,7 +454,7 @@ type InspectResult struct { func (m *InspectResult) Reset() { *m = InspectResult{} } func (m *InspectResult) String() string { return proto.CompactTextString(m) } func (*InspectResult) ProtoMessage() {} -func (*InspectResult) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } +func (*InspectResult) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } func (m *InspectResult) GetFindings() []*Finding { if m != nil { @@ -351,7 +487,7 @@ type Finding struct { func (m *Finding) Reset() { *m = Finding{} } func (m *Finding) String() string { return proto.CompactTextString(m) } func (*Finding) ProtoMessage() {} -func (*Finding) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } +func (*Finding) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } func (m *Finding) GetQuote() string { if m != nil { @@ -401,12 +537,14 @@ type Location struct { RecordKey *RecordKey `protobuf:"bytes,4,opt,name=record_key,json=recordKey" json:"record_key,omitempty"` // Field id of the field containing the finding. FieldId *FieldId `protobuf:"bytes,5,opt,name=field_id,json=fieldId" json:"field_id,omitempty"` + // Location within a `ContentItem.Table`. + TableLocation *TableLocation `protobuf:"bytes,6,opt,name=table_location,json=tableLocation" json:"table_location,omitempty"` } func (m *Location) Reset() { *m = Location{} } func (m *Location) String() string { return proto.CompactTextString(m) } func (*Location) ProtoMessage() {} -func (*Location) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } +func (*Location) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } func (m *Location) GetByteRange() *Range { if m != nil { @@ -443,6 +581,31 @@ func (m *Location) GetFieldId() *FieldId { return nil } +func (m *Location) GetTableLocation() *TableLocation { + if m != nil { + return m.TableLocation + } + return nil +} + +// Location of a finding within a `ContentItem.Table`. +type TableLocation struct { + // The zero-based index of the row where the finding is located. + RowIndex int64 `protobuf:"varint,1,opt,name=row_index,json=rowIndex" json:"row_index,omitempty"` +} + +func (m *TableLocation) Reset() { *m = TableLocation{} } +func (m *TableLocation) String() string { return proto.CompactTextString(m) } +func (*TableLocation) ProtoMessage() {} +func (*TableLocation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } + +func (m *TableLocation) GetRowIndex() int64 { + if m != nil { + return m.RowIndex + } + return 0 +} + // Generic half-open interval [start, end) type Range struct { // Index of the first character of the range (inclusive). @@ -454,7 +617,7 @@ type Range struct { func (m *Range) Reset() { *m = Range{} } func (m *Range) String() string { return proto.CompactTextString(m) } func (*Range) ProtoMessage() {} -func (*Range) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } +func (*Range) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } func (m *Range) GetStart() int64 { if m != nil { @@ -485,7 +648,7 @@ type ImageLocation struct { func (m *ImageLocation) Reset() { *m = ImageLocation{} } func (m *ImageLocation) String() string { return proto.CompactTextString(m) } func (*ImageLocation) ProtoMessage() {} -func (*ImageLocation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } +func (*ImageLocation) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } func (m *ImageLocation) GetTop() int32 { if m != nil { @@ -532,7 +695,7 @@ type RedactContentRequest struct { func (m *RedactContentRequest) Reset() { *m = RedactContentRequest{} } func (m *RedactContentRequest) String() string { return proto.CompactTextString(m) } func (*RedactContentRequest) ProtoMessage() {} -func (*RedactContentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } +func (*RedactContentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } func (m *RedactContentRequest) GetInspectConfig() *InspectConfig { if m != nil { @@ -576,7 +739,7 @@ func (m *RedactContentRequest_ReplaceConfig) Reset() { *m = RedactConten func (m *RedactContentRequest_ReplaceConfig) String() string { return proto.CompactTextString(m) } func (*RedactContentRequest_ReplaceConfig) ProtoMessage() {} func (*RedactContentRequest_ReplaceConfig) Descriptor() ([]byte, []int) { - return fileDescriptor0, []int{7, 0} + return fileDescriptor0, []int{10, 0} } func (m *RedactContentRequest_ReplaceConfig) GetInfoType() *InfoType { @@ -612,7 +775,7 @@ func (m *RedactContentRequest_ImageRedactionConfig) Reset() { func (m *RedactContentRequest_ImageRedactionConfig) String() string { return proto.CompactTextString(m) } func (*RedactContentRequest_ImageRedactionConfig) ProtoMessage() {} func (*RedactContentRequest_ImageRedactionConfig) Descriptor() ([]byte, []int) { - return fileDescriptor0, []int{7, 1} + return fileDescriptor0, []int{10, 1} } type isRedactContentRequest_ImageRedactionConfig_Target interface { @@ -745,7 +908,7 @@ type Color struct { func (m *Color) Reset() { *m = Color{} } func (m *Color) String() string { return proto.CompactTextString(m) } func (*Color) ProtoMessage() {} -func (*Color) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } +func (*Color) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } func (m *Color) GetRed() float32 { if m != nil { @@ -777,7 +940,7 @@ type RedactContentResponse struct { func (m *RedactContentResponse) Reset() { *m = RedactContentResponse{} } func (m *RedactContentResponse) String() string { return proto.CompactTextString(m) } func (*RedactContentResponse) ProtoMessage() {} -func (*RedactContentResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } +func (*RedactContentResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } func (m *RedactContentResponse) GetItems() []*ContentItem { if m != nil { @@ -799,7 +962,7 @@ type InspectContentRequest struct { func (m *InspectContentRequest) Reset() { *m = InspectContentRequest{} } func (m *InspectContentRequest) String() string { return proto.CompactTextString(m) } func (*InspectContentRequest) ProtoMessage() {} -func (*InspectContentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } +func (*InspectContentRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } func (m *InspectContentRequest) GetInspectConfig() *InspectConfig { if m != nil { @@ -825,7 +988,7 @@ type InspectContentResponse struct { func (m *InspectContentResponse) Reset() { *m = InspectContentResponse{} } func (m *InspectContentResponse) String() string { return proto.CompactTextString(m) } func (*InspectContentResponse) ProtoMessage() {} -func (*InspectContentResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } +func (*InspectContentResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} } func (m *InspectContentResponse) GetResults() []*InspectResult { if m != nil { @@ -850,18 +1013,22 @@ type CreateInspectOperationRequest struct { // identifier for the Operation, and the `count` is a counter used for // tracking the number of files written.

The CSV file(s) contain the // following columns regardless of storage type scanned:

  • id
  • info_type - //
  • likelihood
  • byte size of finding
  • quote
  • time_stamp
    + //
  • likelihood
  • byte size of finding
  • quote
  • timestamp
    //

    For Cloud Storage the next columns are:

  • file_path //
  • start_offset
    //

    For Cloud Datastore the next columns are:

  • project_id - //
  • namespace_id
  • path
  • column_name
  • offset + //
  • namespace_id
  • path
  • column_name
  • offset
    + //

    For BigQuery the next columns are:

  • row_number
  • project_id + //
  • dataset_id
  • table_id OutputConfig *OutputStorageConfig `protobuf:"bytes,3,opt,name=output_config,json=outputConfig" json:"output_config,omitempty"` + // Additional configuration settings for long running operations. + OperationConfig *OperationConfig `protobuf:"bytes,5,opt,name=operation_config,json=operationConfig" json:"operation_config,omitempty"` } func (m *CreateInspectOperationRequest) Reset() { *m = CreateInspectOperationRequest{} } func (m *CreateInspectOperationRequest) String() string { return proto.CompactTextString(m) } func (*CreateInspectOperationRequest) ProtoMessage() {} -func (*CreateInspectOperationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } +func (*CreateInspectOperationRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } func (m *CreateInspectOperationRequest) GetInspectConfig() *InspectConfig { if m != nil { @@ -884,9 +1051,17 @@ func (m *CreateInspectOperationRequest) GetOutputConfig() *OutputStorageConfig { return nil } +func (m *CreateInspectOperationRequest) GetOperationConfig() *OperationConfig { + if m != nil { + return m.OperationConfig + } + return nil +} + // Cloud repository for storing output. type OutputStorageConfig struct { // Types that are valid to be assigned to Type: + // *OutputStorageConfig_Table // *OutputStorageConfig_StoragePath Type isOutputStorageConfig_Type `protobuf_oneof:"type"` } @@ -894,16 +1069,20 @@ type OutputStorageConfig struct { func (m *OutputStorageConfig) Reset() { *m = OutputStorageConfig{} } func (m *OutputStorageConfig) String() string { return proto.CompactTextString(m) } func (*OutputStorageConfig) ProtoMessage() {} -func (*OutputStorageConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } +func (*OutputStorageConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } type isOutputStorageConfig_Type interface { isOutputStorageConfig_Type() } +type OutputStorageConfig_Table struct { + Table *BigQueryTable `protobuf:"bytes,1,opt,name=table,oneof"` +} type OutputStorageConfig_StoragePath struct { StoragePath *CloudStoragePath `protobuf:"bytes,2,opt,name=storage_path,json=storagePath,oneof"` } +func (*OutputStorageConfig_Table) isOutputStorageConfig_Type() {} func (*OutputStorageConfig_StoragePath) isOutputStorageConfig_Type() {} func (m *OutputStorageConfig) GetType() isOutputStorageConfig_Type { @@ -913,6 +1092,13 @@ func (m *OutputStorageConfig) GetType() isOutputStorageConfig_Type { return nil } +func (m *OutputStorageConfig) GetTable() *BigQueryTable { + if x, ok := m.GetType().(*OutputStorageConfig_Table); ok { + return x.Table + } + return nil +} + func (m *OutputStorageConfig) GetStoragePath() *CloudStoragePath { if x, ok := m.GetType().(*OutputStorageConfig_StoragePath); ok { return x.StoragePath @@ -923,6 +1109,7 @@ func (m *OutputStorageConfig) GetStoragePath() *CloudStoragePath { // XXX_OneofFuncs is for the internal use of the proto package. func (*OutputStorageConfig) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _OutputStorageConfig_OneofMarshaler, _OutputStorageConfig_OneofUnmarshaler, _OutputStorageConfig_OneofSizer, []interface{}{ + (*OutputStorageConfig_Table)(nil), (*OutputStorageConfig_StoragePath)(nil), } } @@ -931,6 +1118,11 @@ func _OutputStorageConfig_OneofMarshaler(msg proto.Message, b *proto.Buffer) err m := msg.(*OutputStorageConfig) // type switch x := m.Type.(type) { + case *OutputStorageConfig_Table: + b.EncodeVarint(1<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.Table); err != nil { + return err + } case *OutputStorageConfig_StoragePath: b.EncodeVarint(2<<3 | proto.WireBytes) if err := b.EncodeMessage(x.StoragePath); err != nil { @@ -946,6 +1138,14 @@ func _OutputStorageConfig_OneofMarshaler(msg proto.Message, b *proto.Buffer) err func _OutputStorageConfig_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { m := msg.(*OutputStorageConfig) switch tag { + case 1: // type.table + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(BigQueryTable) + err := b.DecodeMessage(msg) + m.Type = &OutputStorageConfig_Table{msg} + return true, err case 2: // type.storage_path if wire != proto.WireBytes { return true, proto.ErrInternalBadWireType @@ -963,6 +1163,11 @@ func _OutputStorageConfig_OneofSizer(msg proto.Message) (n int) { m := msg.(*OutputStorageConfig) // type switch x := m.Type.(type) { + case *OutputStorageConfig_Table: + s := proto.Size(x.Table) + n += proto.SizeVarint(1<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s case *OutputStorageConfig_StoragePath: s := proto.Size(x.StoragePath) n += proto.SizeVarint(2<<3 | proto.WireBytes) @@ -986,7 +1191,7 @@ type InfoTypeStatistics struct { func (m *InfoTypeStatistics) Reset() { *m = InfoTypeStatistics{} } func (m *InfoTypeStatistics) String() string { return proto.CompactTextString(m) } func (*InfoTypeStatistics) ProtoMessage() {} -func (*InfoTypeStatistics) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} } +func (*InfoTypeStatistics) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } func (m *InfoTypeStatistics) GetInfoType() *InfoType { if m != nil { @@ -1022,7 +1227,7 @@ type InspectOperationMetadata struct { func (m *InspectOperationMetadata) Reset() { *m = InspectOperationMetadata{} } func (m *InspectOperationMetadata) String() string { return proto.CompactTextString(m) } func (*InspectOperationMetadata) ProtoMessage() {} -func (*InspectOperationMetadata) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } +func (*InspectOperationMetadata) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } func (m *InspectOperationMetadata) GetProcessedBytes() int64 { if m != nil { @@ -1084,7 +1289,7 @@ type InspectOperationResult struct { func (m *InspectOperationResult) Reset() { *m = InspectOperationResult{} } func (m *InspectOperationResult) String() string { return proto.CompactTextString(m) } func (*InspectOperationResult) ProtoMessage() {} -func (*InspectOperationResult) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } +func (*InspectOperationResult) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } func (m *InspectOperationResult) GetName() string { if m != nil { @@ -1097,7 +1302,7 @@ func (m *InspectOperationResult) GetName() string { type ListInspectFindingsRequest struct { // Identifier of the results set returned as metadata of // the longrunning operation created by a call to CreateInspectOperation. - // Should be in the format of `inspect/results/{id}. + // Should be in the format of `inspect/results/{id}`. Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` // Maximum number of results to return. // If 0, the implementation selects a reasonable value. @@ -1119,7 +1324,7 @@ type ListInspectFindingsRequest struct { func (m *ListInspectFindingsRequest) Reset() { *m = ListInspectFindingsRequest{} } func (m *ListInspectFindingsRequest) String() string { return proto.CompactTextString(m) } func (*ListInspectFindingsRequest) ProtoMessage() {} -func (*ListInspectFindingsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } +func (*ListInspectFindingsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} } func (m *ListInspectFindingsRequest) GetName() string { if m != nil { @@ -1161,7 +1366,7 @@ type ListInspectFindingsResponse struct { func (m *ListInspectFindingsResponse) Reset() { *m = ListInspectFindingsResponse{} } func (m *ListInspectFindingsResponse) String() string { return proto.CompactTextString(m) } func (*ListInspectFindingsResponse) ProtoMessage() {} -func (*ListInspectFindingsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } +func (*ListInspectFindingsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} } func (m *ListInspectFindingsResponse) GetResult() *InspectResult { if m != nil { @@ -1190,7 +1395,7 @@ type InfoTypeDescription struct { func (m *InfoTypeDescription) Reset() { *m = InfoTypeDescription{} } func (m *InfoTypeDescription) String() string { return proto.CompactTextString(m) } func (*InfoTypeDescription) ProtoMessage() {} -func (*InfoTypeDescription) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } +func (*InfoTypeDescription) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} } func (m *InfoTypeDescription) GetName() string { if m != nil { @@ -1227,7 +1432,7 @@ type ListInfoTypesRequest struct { func (m *ListInfoTypesRequest) Reset() { *m = ListInfoTypesRequest{} } func (m *ListInfoTypesRequest) String() string { return proto.CompactTextString(m) } func (*ListInfoTypesRequest) ProtoMessage() {} -func (*ListInfoTypesRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} } +func (*ListInfoTypesRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} } func (m *ListInfoTypesRequest) GetCategory() string { if m != nil { @@ -1252,7 +1457,7 @@ type ListInfoTypesResponse struct { func (m *ListInfoTypesResponse) Reset() { *m = ListInfoTypesResponse{} } func (m *ListInfoTypesResponse) String() string { return proto.CompactTextString(m) } func (*ListInfoTypesResponse) ProtoMessage() {} -func (*ListInfoTypesResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} } +func (*ListInfoTypesResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} } func (m *ListInfoTypesResponse) GetInfoTypes() []*InfoTypeDescription { if m != nil { @@ -1272,7 +1477,7 @@ type CategoryDescription struct { func (m *CategoryDescription) Reset() { *m = CategoryDescription{} } func (m *CategoryDescription) String() string { return proto.CompactTextString(m) } func (*CategoryDescription) ProtoMessage() {} -func (*CategoryDescription) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} } +func (*CategoryDescription) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} } func (m *CategoryDescription) GetName() string { if m != nil { @@ -1300,7 +1505,7 @@ type ListRootCategoriesRequest struct { func (m *ListRootCategoriesRequest) Reset() { *m = ListRootCategoriesRequest{} } func (m *ListRootCategoriesRequest) String() string { return proto.CompactTextString(m) } func (*ListRootCategoriesRequest) ProtoMessage() {} -func (*ListRootCategoriesRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} } +func (*ListRootCategoriesRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} } func (m *ListRootCategoriesRequest) GetLanguageCode() string { if m != nil { @@ -1318,7 +1523,7 @@ type ListRootCategoriesResponse struct { func (m *ListRootCategoriesResponse) Reset() { *m = ListRootCategoriesResponse{} } func (m *ListRootCategoriesResponse) String() string { return proto.CompactTextString(m) } func (*ListRootCategoriesResponse) ProtoMessage() {} -func (*ListRootCategoriesResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} } +func (*ListRootCategoriesResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} } func (m *ListRootCategoriesResponse) GetCategories() []*CategoryDescription { if m != nil { @@ -1327,12 +1532,279 @@ func (m *ListRootCategoriesResponse) GetCategories() []*CategoryDescription { return nil } +// Set of primitive values supported by the system. +type Value struct { + // Types that are valid to be assigned to Type: + // *Value_IntegerValue + // *Value_FloatValue + // *Value_StringValue + // *Value_BooleanValue + // *Value_TimestampValue + // *Value_TimeValue + // *Value_DateValue + Type isValue_Type `protobuf_oneof:"type"` +} + +func (m *Value) Reset() { *m = Value{} } +func (m *Value) String() string { return proto.CompactTextString(m) } +func (*Value) ProtoMessage() {} +func (*Value) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} } + +type isValue_Type interface { + isValue_Type() +} + +type Value_IntegerValue struct { + IntegerValue int64 `protobuf:"varint,1,opt,name=integer_value,json=integerValue,oneof"` +} +type Value_FloatValue struct { + FloatValue float64 `protobuf:"fixed64,2,opt,name=float_value,json=floatValue,oneof"` +} +type Value_StringValue struct { + StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,oneof"` +} +type Value_BooleanValue struct { + BooleanValue bool `protobuf:"varint,4,opt,name=boolean_value,json=booleanValue,oneof"` +} +type Value_TimestampValue struct { + TimestampValue *google_protobuf3.Timestamp `protobuf:"bytes,5,opt,name=timestamp_value,json=timestampValue,oneof"` +} +type Value_TimeValue struct { + TimeValue *google_type1.TimeOfDay `protobuf:"bytes,6,opt,name=time_value,json=timeValue,oneof"` +} +type Value_DateValue struct { + DateValue *google_type.Date `protobuf:"bytes,7,opt,name=date_value,json=dateValue,oneof"` +} + +func (*Value_IntegerValue) isValue_Type() {} +func (*Value_FloatValue) isValue_Type() {} +func (*Value_StringValue) isValue_Type() {} +func (*Value_BooleanValue) isValue_Type() {} +func (*Value_TimestampValue) isValue_Type() {} +func (*Value_TimeValue) isValue_Type() {} +func (*Value_DateValue) isValue_Type() {} + +func (m *Value) GetType() isValue_Type { + if m != nil { + return m.Type + } + return nil +} + +func (m *Value) GetIntegerValue() int64 { + if x, ok := m.GetType().(*Value_IntegerValue); ok { + return x.IntegerValue + } + return 0 +} + +func (m *Value) GetFloatValue() float64 { + if x, ok := m.GetType().(*Value_FloatValue); ok { + return x.FloatValue + } + return 0 +} + +func (m *Value) GetStringValue() string { + if x, ok := m.GetType().(*Value_StringValue); ok { + return x.StringValue + } + return "" +} + +func (m *Value) GetBooleanValue() bool { + if x, ok := m.GetType().(*Value_BooleanValue); ok { + return x.BooleanValue + } + return false +} + +func (m *Value) GetTimestampValue() *google_protobuf3.Timestamp { + if x, ok := m.GetType().(*Value_TimestampValue); ok { + return x.TimestampValue + } + return nil +} + +func (m *Value) GetTimeValue() *google_type1.TimeOfDay { + if x, ok := m.GetType().(*Value_TimeValue); ok { + return x.TimeValue + } + return nil +} + +func (m *Value) GetDateValue() *google_type.Date { + if x, ok := m.GetType().(*Value_DateValue); ok { + return x.DateValue + } + return nil +} + +// XXX_OneofFuncs is for the internal use of the proto package. +func (*Value) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { + return _Value_OneofMarshaler, _Value_OneofUnmarshaler, _Value_OneofSizer, []interface{}{ + (*Value_IntegerValue)(nil), + (*Value_FloatValue)(nil), + (*Value_StringValue)(nil), + (*Value_BooleanValue)(nil), + (*Value_TimestampValue)(nil), + (*Value_TimeValue)(nil), + (*Value_DateValue)(nil), + } +} + +func _Value_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { + m := msg.(*Value) + // type + switch x := m.Type.(type) { + case *Value_IntegerValue: + b.EncodeVarint(1<<3 | proto.WireVarint) + b.EncodeVarint(uint64(x.IntegerValue)) + case *Value_FloatValue: + b.EncodeVarint(2<<3 | proto.WireFixed64) + b.EncodeFixed64(math.Float64bits(x.FloatValue)) + case *Value_StringValue: + b.EncodeVarint(3<<3 | proto.WireBytes) + b.EncodeStringBytes(x.StringValue) + case *Value_BooleanValue: + t := uint64(0) + if x.BooleanValue { + t = 1 + } + b.EncodeVarint(4<<3 | proto.WireVarint) + b.EncodeVarint(t) + case *Value_TimestampValue: + b.EncodeVarint(5<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.TimestampValue); err != nil { + return err + } + case *Value_TimeValue: + b.EncodeVarint(6<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.TimeValue); err != nil { + return err + } + case *Value_DateValue: + b.EncodeVarint(7<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.DateValue); err != nil { + return err + } + case nil: + default: + return fmt.Errorf("Value.Type has unexpected type %T", x) + } + return nil +} + +func _Value_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) { + m := msg.(*Value) + switch tag { + case 1: // type.integer_value + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Type = &Value_IntegerValue{int64(x)} + return true, err + case 2: // type.float_value + if wire != proto.WireFixed64 { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeFixed64() + m.Type = &Value_FloatValue{math.Float64frombits(x)} + return true, err + case 3: // type.string_value + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeStringBytes() + m.Type = &Value_StringValue{x} + return true, err + case 4: // type.boolean_value + if wire != proto.WireVarint { + return true, proto.ErrInternalBadWireType + } + x, err := b.DecodeVarint() + m.Type = &Value_BooleanValue{x != 0} + return true, err + case 5: // type.timestamp_value + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(google_protobuf3.Timestamp) + err := b.DecodeMessage(msg) + m.Type = &Value_TimestampValue{msg} + return true, err + case 6: // type.time_value + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(google_type1.TimeOfDay) + err := b.DecodeMessage(msg) + m.Type = &Value_TimeValue{msg} + return true, err + case 7: // type.date_value + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(google_type.Date) + err := b.DecodeMessage(msg) + m.Type = &Value_DateValue{msg} + return true, err + default: + return false, nil + } +} + +func _Value_OneofSizer(msg proto.Message) (n int) { + m := msg.(*Value) + // type + switch x := m.Type.(type) { + case *Value_IntegerValue: + n += proto.SizeVarint(1<<3 | proto.WireVarint) + n += proto.SizeVarint(uint64(x.IntegerValue)) + case *Value_FloatValue: + n += proto.SizeVarint(2<<3 | proto.WireFixed64) + n += 8 + case *Value_StringValue: + n += proto.SizeVarint(3<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(len(x.StringValue))) + n += len(x.StringValue) + case *Value_BooleanValue: + n += proto.SizeVarint(4<<3 | proto.WireVarint) + n += 1 + case *Value_TimestampValue: + s := proto.Size(x.TimestampValue) + n += proto.SizeVarint(5<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case *Value_TimeValue: + s := proto.Size(x.TimeValue) + n += proto.SizeVarint(6<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case *Value_DateValue: + s := proto.Size(x.DateValue) + n += proto.SizeVarint(7<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s + case nil: + default: + panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) + } + return n +} + func init() { proto.RegisterType((*InspectConfig)(nil), "google.privacy.dlp.v2beta1.InspectConfig") + proto.RegisterType((*InspectConfig_InfoTypeLimit)(nil), "google.privacy.dlp.v2beta1.InspectConfig.InfoTypeLimit") + proto.RegisterType((*OperationConfig)(nil), "google.privacy.dlp.v2beta1.OperationConfig") proto.RegisterType((*ContentItem)(nil), "google.privacy.dlp.v2beta1.ContentItem") + proto.RegisterType((*Table)(nil), "google.privacy.dlp.v2beta1.Table") + proto.RegisterType((*Table_Row)(nil), "google.privacy.dlp.v2beta1.Table.Row") proto.RegisterType((*InspectResult)(nil), "google.privacy.dlp.v2beta1.InspectResult") proto.RegisterType((*Finding)(nil), "google.privacy.dlp.v2beta1.Finding") proto.RegisterType((*Location)(nil), "google.privacy.dlp.v2beta1.Location") + proto.RegisterType((*TableLocation)(nil), "google.privacy.dlp.v2beta1.TableLocation") proto.RegisterType((*Range)(nil), "google.privacy.dlp.v2beta1.Range") proto.RegisterType((*ImageLocation)(nil), "google.privacy.dlp.v2beta1.ImageLocation") proto.RegisterType((*RedactContentRequest)(nil), "google.privacy.dlp.v2beta1.RedactContentRequest") @@ -1355,6 +1827,7 @@ func init() { proto.RegisterType((*CategoryDescription)(nil), "google.privacy.dlp.v2beta1.CategoryDescription") proto.RegisterType((*ListRootCategoriesRequest)(nil), "google.privacy.dlp.v2beta1.ListRootCategoriesRequest") proto.RegisterType((*ListRootCategoriesResponse)(nil), "google.privacy.dlp.v2beta1.ListRootCategoriesResponse") + proto.RegisterType((*Value)(nil), "google.privacy.dlp.v2beta1.Value") proto.RegisterEnum("google.privacy.dlp.v2beta1.Likelihood", Likelihood_name, Likelihood_value) } @@ -1616,128 +2089,150 @@ var _DlpService_serviceDesc = grpc.ServiceDesc{ func init() { proto.RegisterFile("google/privacy/dlp/v2beta1/dlp.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ - // 1953 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x6f, 0x23, 0x49, - 0x15, 0x4f, 0x3b, 0x71, 0x62, 0x3f, 0xc7, 0xc9, 0x6c, 0xe5, 0x63, 0xbc, 0x9e, 0x1d, 0x36, 0xd3, - 0xb3, 0xcc, 0x86, 0x68, 0xb0, 0x77, 0x8c, 0x18, 0xc4, 0xae, 0x66, 0x99, 0xb1, 0x93, 0x21, 0x66, - 0xb3, 0x93, 0x6c, 0x25, 0x3b, 0xab, 0x45, 0xa0, 0x56, 0xa7, 0xbb, 0xdc, 0x29, 0x4d, 0xbb, 0xab, - 0xb7, 0xbb, 0x3c, 0x1b, 0xef, 0x6a, 0x84, 0x84, 0x10, 0xe2, 0x88, 0xc4, 0x05, 0x10, 0xdc, 0x38, - 0x00, 0xe2, 0xc6, 0x8d, 0x7f, 0x83, 0x23, 0xd7, 0x3d, 0xf1, 0x07, 0x70, 0x46, 0xf5, 0xd1, 0xed, - 0xb6, 0xc7, 0xd3, 0x89, 0x03, 0x48, 0xdc, 0xaa, 0x5e, 0xbd, 0xf7, 0xfa, 0xf7, 0x3e, 0xfb, 0x55, - 0xc1, 0x5b, 0x1e, 0x63, 0x9e, 0x4f, 0x9a, 0x61, 0x44, 0x9f, 0xdb, 0xce, 0xb0, 0xe9, 0xfa, 0x61, - 0xf3, 0x79, 0xeb, 0x94, 0x70, 0xfb, 0x9e, 0x58, 0x37, 0xc2, 0x88, 0x71, 0x86, 0xea, 0x8a, 0xab, - 0xa1, 0xb9, 0x1a, 0xe2, 0x44, 0x73, 0xd5, 0xdf, 0xd0, 0x1a, 0xec, 0x90, 0x36, 0xed, 0x20, 0x60, - 0xdc, 0xe6, 0x94, 0x05, 0xb1, 0x92, 0xac, 0xdf, 0xd6, 0xa7, 0x3e, 0x0b, 0xbc, 0x68, 0x10, 0x04, - 0x34, 0xf0, 0x9a, 0x2c, 0x24, 0xd1, 0x18, 0xd3, 0x76, 0x0e, 0x88, 0x98, 0xb3, 0xc8, 0xf6, 0x88, - 0xe6, 0xbc, 0x91, 0x72, 0x32, 0xce, 0x4e, 0x07, 0xbd, 0x26, 0xe9, 0x87, 0x7c, 0xa8, 0x0f, 0xdf, - 0x9c, 0x3c, 0xe4, 0xb4, 0x4f, 0x62, 0x6e, 0xf7, 0xb5, 0x19, 0xf5, 0x4d, 0xcd, 0xc0, 0x87, 0x21, - 0x69, 0xba, 0x36, 0x9f, 0xd4, 0x2a, 0xe9, 0x42, 0x88, 0xf5, 0x5c, 0x5b, 0x6b, 0x35, 0x7f, 0x59, - 0x80, 0x6a, 0x37, 0x88, 0x43, 0xe2, 0xf0, 0x0e, 0x0b, 0x7a, 0xd4, 0x43, 0x1d, 0x00, 0x1a, 0xf4, - 0x98, 0x25, 0xd8, 0xe3, 0x9a, 0xb1, 0x35, 0xbf, 0x5d, 0x69, 0xbd, 0xd5, 0x78, 0xb5, 0x8b, 0x1a, - 0xdd, 0xa0, 0xc7, 0x4e, 0x86, 0x21, 0xc1, 0x65, 0xaa, 0x57, 0x31, 0xfa, 0x10, 0x56, 0xfa, 0x34, - 0xb0, 0x7c, 0xfa, 0x8c, 0xf8, 0xf4, 0x8c, 0x31, 0xb7, 0x56, 0xd8, 0x32, 0xb6, 0x57, 0x5a, 0x77, - 0xf2, 0x14, 0x1d, 0xa4, 0xdc, 0xb8, 0xda, 0xa7, 0xc1, 0x68, 0x8b, 0x6e, 0xc1, 0x72, 0xdf, 0x3e, - 0xb7, 0x7a, 0x34, 0x70, 0x69, 0xe0, 0xc5, 0xb5, 0xf9, 0x2d, 0x63, 0xbb, 0x88, 0x2b, 0x7d, 0xfb, - 0xfc, 0xb1, 0x26, 0xa1, 0xdb, 0x50, 0xa5, 0x81, 0xe3, 0x0f, 0x5c, 0x62, 0x7d, 0x36, 0x60, 0x9c, - 0xd4, 0x16, 0xb6, 0x8c, 0xed, 0x12, 0x5e, 0xd6, 0xc4, 0x8f, 0x04, 0x4d, 0x30, 0x91, 0x73, 0xc5, - 0xa4, 0xcc, 0x5b, 0x54, 0x4c, 0x9a, 0x28, 0xb1, 0x9b, 0x3f, 0x82, 0x4a, 0x87, 0x05, 0x9c, 0x04, - 0xbc, 0xcb, 0x49, 0x1f, 0x21, 0x58, 0x10, 0xbc, 0x35, 0x63, 0xcb, 0xd8, 0x2e, 0x63, 0xb9, 0x46, - 0xeb, 0xb0, 0xe0, 0xda, 0xdc, 0x96, 0x46, 0x2d, 0xef, 0xcf, 0x61, 0xb9, 0x43, 0x9b, 0x50, 0x7c, - 0x6e, 0xfb, 0x03, 0x22, 0xe1, 0x95, 0xf7, 0xe7, 0xb0, 0xda, 0xb6, 0x2b, 0x50, 0x16, 0xe7, 0x16, - 0xe5, 0xa4, 0x6f, 0xfe, 0x24, 0xf5, 0x37, 0x26, 0xf1, 0xc0, 0xe7, 0xe8, 0x7b, 0x50, 0x4a, 0xed, - 0x52, 0xde, 0xbe, 0x9d, 0xe7, 0x24, 0x6d, 0x30, 0x4e, 0x85, 0xd0, 0x37, 0x01, 0x25, 0x6b, 0x8b, - 0x47, 0x83, 0xc0, 0xb1, 0x39, 0x51, 0xfe, 0x2e, 0xe1, 0xd7, 0x92, 0x93, 0x93, 0xe4, 0xc0, 0xfc, - 0x53, 0x01, 0x96, 0xb4, 0x12, 0xb4, 0x0e, 0x45, 0xe5, 0x2c, 0x65, 0x9c, 0xda, 0xa0, 0x47, 0x50, - 0x4e, 0x33, 0x40, 0xea, 0xb9, 0x6c, 0x02, 0x94, 0x92, 0x04, 0x40, 0x8f, 0x01, 0x32, 0xb1, 0x9f, - 0x9f, 0x29, 0xf6, 0x19, 0x49, 0xf4, 0x10, 0x4a, 0x3e, 0x73, 0x64, 0x39, 0xc9, 0x80, 0x5e, 0x80, - 0xe4, 0x40, 0xf3, 0xe2, 0x54, 0x0a, 0xbd, 0x07, 0x15, 0x27, 0x22, 0x36, 0x27, 0x96, 0x48, 0x7d, - 0x19, 0xf0, 0x4a, 0xab, 0x3e, 0x52, 0xa2, 0x8a, 0xa9, 0x71, 0x92, 0x14, 0x13, 0x06, 0xc5, 0x2e, - 0x08, 0xe6, 0x3f, 0x0b, 0x50, 0x4a, 0x74, 0xa2, 0x87, 0x00, 0xa7, 0x43, 0x4e, 0xac, 0xc8, 0x0e, - 0x3c, 0xe5, 0xb1, 0x4a, 0xeb, 0x56, 0x1e, 0x1a, 0x2c, 0x18, 0x71, 0x59, 0x08, 0xc9, 0x25, 0xfa, - 0x01, 0xac, 0x3a, 0xcc, 0x25, 0x21, 0xa3, 0x01, 0xd7, 0x6a, 0x0a, 0x97, 0x55, 0xb3, 0x92, 0x4a, - 0x26, 0xba, 0x2a, 0xb4, 0x6f, 0x7b, 0xc4, 0x3a, 0x65, 0xe7, 0x44, 0x54, 0x84, 0xc8, 0x9c, 0x6f, - 0xe4, 0x86, 0x49, 0xb0, 0xa7, 0x1e, 0x02, 0x29, 0xdd, 0x16, 0xc2, 0x68, 0x17, 0x20, 0x22, 0x0e, - 0x8b, 0x5c, 0xeb, 0x19, 0x19, 0x6a, 0x3f, 0x7f, 0x3d, 0x17, 0x92, 0xe4, 0xfe, 0x80, 0x0c, 0x71, - 0x39, 0x4a, 0x96, 0xe8, 0x7d, 0x91, 0xc8, 0xc4, 0x77, 0x2d, 0xea, 0xd6, 0x8a, 0x52, 0xc7, 0x05, - 0x89, 0x4c, 0x7c, 0xb7, 0xeb, 0xe2, 0xa5, 0x9e, 0x5a, 0x98, 0x4d, 0x28, 0x2a, 0xd3, 0xd6, 0xa1, - 0x18, 0x73, 0x3b, 0xe2, 0xd2, 0xc7, 0xf3, 0x58, 0x6d, 0xd0, 0x35, 0x98, 0x27, 0x81, 0xca, 0xeb, - 0x79, 0x2c, 0x96, 0xa6, 0x03, 0xd5, 0x31, 0x9b, 0x04, 0x0b, 0x67, 0xa1, 0x14, 0x2b, 0x62, 0xb1, - 0x14, 0xc5, 0xeb, 0x93, 0x1e, 0x97, 0x52, 0x45, 0x2c, 0xd7, 0x42, 0xfd, 0xe7, 0xd4, 0xe5, 0x67, - 0xba, 0x8b, 0xa8, 0x0d, 0xda, 0x84, 0xc5, 0x33, 0x42, 0xbd, 0x33, 0x2e, 0xed, 0x2f, 0x62, 0xbd, - 0x33, 0xbf, 0x2a, 0xc2, 0x3a, 0x26, 0xae, 0x2d, 0xfb, 0xa3, 0x68, 0x0a, 0x98, 0x7c, 0x36, 0x20, - 0x31, 0x47, 0x47, 0xb0, 0x42, 0x55, 0x21, 0x5b, 0x8e, 0xec, 0x9c, 0x3a, 0x25, 0xf2, 0x63, 0x90, - 0x6d, 0xb5, 0xb8, 0x4a, 0xc7, 0x3a, 0xef, 0x03, 0x28, 0x8a, 0x16, 0x11, 0xd7, 0x0a, 0x32, 0x98, - 0x6f, 0xe7, 0x29, 0xca, 0x74, 0x28, 0xac, 0xa4, 0x90, 0x07, 0xab, 0x11, 0x09, 0x7d, 0xdb, 0x21, - 0x1a, 0x50, 0x92, 0x15, 0xef, 0xe7, 0x87, 0xf2, 0x65, 0xdb, 0x1a, 0x58, 0xe9, 0xd1, 0x30, 0x57, - 0xa2, 0xec, 0x36, 0x46, 0x2f, 0xe0, 0xba, 0x4a, 0xbd, 0x48, 0xca, 0x52, 0x16, 0xa4, 0x1f, 0x5c, - 0x90, 0x1f, 0xdc, 0x9b, 0xf9, 0x83, 0x32, 0x8e, 0x38, 0x51, 0xa7, 0xbf, 0xbb, 0x41, 0xa7, 0x50, - 0xe3, 0xfa, 0x00, 0xaa, 0x63, 0xf8, 0xc6, 0xfb, 0x95, 0x71, 0xa5, 0x7e, 0x75, 0x0b, 0x96, 0x13, - 0xdf, 0x7d, 0x4e, 0xf9, 0x99, 0xcc, 0x97, 0x32, 0xae, 0x68, 0xda, 0x27, 0x94, 0x9f, 0xd5, 0xff, - 0x61, 0xc0, 0xfa, 0x34, 0x98, 0xa8, 0x73, 0xc5, 0xcf, 0xef, 0xcf, 0x65, 0x00, 0x6c, 0x8b, 0xe0, - 0x09, 0xbd, 0x96, 0xed, 0xfb, 0x16, 0x27, 0xe7, 0x2a, 0x67, 0x4b, 0xfb, 0x73, 0xb8, 0xaa, 0x0e, - 0x1e, 0xf9, 0xfe, 0x09, 0x39, 0xe7, 0xa2, 0x89, 0x64, 0xfd, 0xee, 0xb3, 0x48, 0x26, 0xf2, 0x05, - 0x4d, 0xa4, 0x23, 0x18, 0x45, 0x24, 0x53, 0xec, 0x3e, 0x8b, 0xda, 0x25, 0x58, 0xe4, 0x76, 0xe4, - 0x11, 0x6e, 0x76, 0xa0, 0x28, 0x49, 0xa2, 0x86, 0x22, 0xe2, 0x4a, 0x3b, 0x0a, 0x58, 0x2c, 0x45, - 0xbd, 0x78, 0x11, 0x21, 0x81, 0x04, 0x54, 0xc0, 0x6a, 0x23, 0x2a, 0xeb, 0x34, 0xf9, 0xd7, 0x15, - 0xb0, 0x5c, 0x9b, 0x4f, 0x61, 0x63, 0x22, 0xba, 0x71, 0xc8, 0x82, 0x98, 0x8c, 0x32, 0xdb, 0xb8, - 0x4a, 0x66, 0x9b, 0x7f, 0x34, 0x60, 0x63, 0x54, 0x39, 0xff, 0xcf, 0x45, 0x68, 0xfe, 0x18, 0x36, - 0x27, 0x91, 0x6a, 0x1f, 0x74, 0x60, 0x29, 0x92, 0x7f, 0xfc, 0xc4, 0x0b, 0x97, 0xc1, 0xa8, 0x66, - 0x04, 0x9c, 0x48, 0x9a, 0xbf, 0x29, 0xc0, 0xcd, 0x8e, 0xfc, 0x3f, 0x69, 0x86, 0xc3, 0x64, 0xda, - 0xfc, 0xdf, 0x79, 0xe4, 0x08, 0x56, 0xf4, 0x98, 0x9a, 0x68, 0x2c, 0x5c, 0xac, 0xf1, 0x58, 0x49, - 0x24, 0x1a, 0xe3, 0xec, 0x16, 0x9d, 0x40, 0x95, 0x0d, 0x78, 0x38, 0x48, 0x21, 0xaa, 0x04, 0x6e, - 0xe6, 0x29, 0x3c, 0x94, 0x02, 0xe3, 0x6a, 0x97, 0x95, 0x16, 0xb5, 0x33, 0x43, 0x58, 0x9b, 0xc2, - 0x84, 0x3e, 0x82, 0xe5, 0x04, 0x7e, 0x68, 0xeb, 0xd2, 0xae, 0xb4, 0xee, 0xe6, 0xc6, 0xd5, 0x67, - 0x03, 0x57, 0x6b, 0x39, 0xb2, 0xf9, 0xd9, 0xfe, 0x1c, 0xae, 0xc4, 0xa3, 0x6d, 0x7b, 0x51, 0x8d, - 0x84, 0x66, 0x1f, 0x50, 0x52, 0xcc, 0xc7, 0xe2, 0x62, 0x10, 0x73, 0xea, 0xc4, 0xff, 0x8d, 0x76, - 0xb4, 0x0e, 0x45, 0x87, 0x0d, 0x02, 0xae, 0xff, 0x76, 0x6a, 0x63, 0xfe, 0x75, 0x01, 0x6a, 0x93, - 0x61, 0xff, 0x90, 0x70, 0x5b, 0x0e, 0x9f, 0x6f, 0xc3, 0x6a, 0x18, 0x31, 0x87, 0xc4, 0x31, 0x71, - 0x2d, 0x31, 0x72, 0xc4, 0xfa, 0xf7, 0xb9, 0x92, 0x92, 0xdb, 0x82, 0x8a, 0x5a, 0xb0, 0xc1, 0x19, - 0xb7, 0x7d, 0x8b, 0xc4, 0x9c, 0xf6, 0xc5, 0x48, 0xa8, 0xd9, 0x17, 0x24, 0xfb, 0x9a, 0x3c, 0xdc, - 0x4b, 0xce, 0x94, 0xcc, 0x53, 0x58, 0x4d, 0x4d, 0xb2, 0x62, 0x6e, 0xf3, 0xa4, 0x3c, 0x1a, 0x97, - 0x31, 0x6c, 0xe4, 0x1b, 0x91, 0x5a, 0x23, 0x5a, 0x3c, 0x39, 0x9c, 0xcd, 0xcf, 0x32, 0x9c, 0x21, - 0x0b, 0x36, 0x23, 0x95, 0xf4, 0xd6, 0x44, 0xc6, 0x17, 0x67, 0xcd, 0xf8, 0x75, 0xad, 0x68, 0xfc, - 0x26, 0x94, 0xf9, 0xc0, 0x44, 0x01, 0x2c, 0xce, 0x5a, 0x00, 0xc9, 0x07, 0xc6, 0x53, 0xd3, 0x81, - 0x8d, 0xe4, 0x03, 0xe3, 0xf5, 0xb0, 0x74, 0xb5, 0x7a, 0x58, 0xd3, 0xda, 0x0e, 0xb3, 0x65, 0x71, - 0x37, 0xed, 0x48, 0x99, 0x5e, 0x21, 0x6f, 0x1e, 0x08, 0x16, 0x02, 0xbb, 0x9f, 0xde, 0x6c, 0xc4, - 0xda, 0xfc, 0x99, 0x01, 0xf5, 0x03, 0x9a, 0x7a, 0x22, 0xb9, 0x5e, 0x25, 0xdd, 0x65, 0x8a, 0x08, - 0xba, 0x01, 0xe5, 0x50, 0xf8, 0x26, 0xa6, 0x5f, 0x10, 0x3d, 0x68, 0x95, 0x04, 0xe1, 0x98, 0x7e, - 0x41, 0xd0, 0x4d, 0x00, 0x79, 0xc8, 0xd9, 0x33, 0x12, 0xa8, 0x8b, 0x11, 0x96, 0xec, 0x27, 0x82, - 0x20, 0xa6, 0xae, 0x1e, 0xf5, 0x39, 0x89, 0x64, 0xf6, 0x95, 0xb1, 0xde, 0x99, 0xbf, 0x30, 0xe0, - 0xc6, 0x54, 0x18, 0xba, 0x99, 0x3e, 0x82, 0x45, 0xd5, 0x12, 0x67, 0xe8, 0x6e, 0xba, 0x97, 0x6a, - 0x41, 0x74, 0x07, 0x56, 0x03, 0x72, 0xce, 0xad, 0x0c, 0x3c, 0xf5, 0xd7, 0xaf, 0x0a, 0xf2, 0x51, - 0x02, 0xd1, 0xfc, 0xbd, 0x01, 0x6b, 0x49, 0x26, 0xef, 0x92, 0xd8, 0x89, 0x68, 0x28, 0x87, 0xcd, - 0x69, 0xae, 0xb8, 0x05, 0xcb, 0x2e, 0x8d, 0x43, 0xdf, 0x1e, 0x5a, 0xf2, 0x4c, 0x8f, 0x11, 0x9a, - 0xf6, 0x44, 0xb0, 0x1c, 0x02, 0x88, 0x7b, 0x98, 0xc7, 0x22, 0x9a, 0x8e, 0xed, 0xb9, 0x81, 0xee, - 0x28, 0xee, 0x61, 0xe6, 0xdb, 0x38, 0xa3, 0xc2, 0xfc, 0x04, 0xd6, 0x95, 0xa7, 0xf4, 0xdd, 0x3b, - 0x09, 0x55, 0x1d, 0x4a, 0x9a, 0x6b, 0xa8, 0x31, 0xa6, 0x7b, 0x71, 0x0f, 0xf6, 0xed, 0xc0, 0x1b, - 0xa8, 0x94, 0x76, 0x13, 0xa0, 0xcb, 0x09, 0xb1, 0xc3, 0x5c, 0x62, 0x7a, 0xb0, 0x31, 0xa1, 0x58, - 0x3b, 0xff, 0xc9, 0x94, 0x17, 0x82, 0xe6, 0x65, 0x1a, 0x41, 0xd6, 0x84, 0xd1, 0x63, 0x81, 0x79, - 0x00, 0x6b, 0x53, 0x8c, 0xbc, 0xa2, 0x83, 0xcd, 0x87, 0xf0, 0xba, 0x80, 0x8d, 0x19, 0xe3, 0x9d, - 0xd4, 0x4b, 0x89, 0x53, 0x5e, 0x32, 0xdc, 0x98, 0x62, 0x78, 0x5f, 0x95, 0xc0, 0xa4, 0x06, 0x6d, - 0xfd, 0x78, 0x00, 0x8d, 0xff, 0x38, 0x80, 0x3b, 0x1c, 0x20, 0xf3, 0xd4, 0x51, 0x87, 0xcd, 0x83, - 0xee, 0x07, 0x7b, 0x07, 0xdd, 0xfd, 0xc3, 0xc3, 0x5d, 0xeb, 0xe3, 0x27, 0xc7, 0x47, 0x7b, 0x9d, - 0xee, 0xe3, 0xee, 0xde, 0xee, 0xb5, 0x39, 0xf4, 0x1a, 0x54, 0x9f, 0xee, 0xe1, 0x4f, 0xad, 0x8f, - 0x9f, 0x48, 0x96, 0x4f, 0xaf, 0x19, 0x68, 0x19, 0x4a, 0xe9, 0xae, 0x20, 0x76, 0x47, 0x87, 0xc7, - 0xc7, 0xdd, 0xf6, 0xc1, 0xde, 0xb5, 0x79, 0x04, 0xb0, 0xa8, 0x4f, 0x16, 0xd0, 0x2a, 0x54, 0xa4, - 0xa8, 0x26, 0x14, 0x5b, 0xff, 0x5a, 0x02, 0xd8, 0xf5, 0xc3, 0x63, 0x12, 0x3d, 0xa7, 0x0e, 0x41, - 0xbf, 0x33, 0x60, 0x65, 0x7c, 0x70, 0x41, 0xf7, 0x2e, 0xd7, 0x3f, 0x33, 0xe3, 0x58, 0xbd, 0x35, - 0x8b, 0x88, 0xf2, 0xa7, 0x79, 0xfb, 0xa7, 0x7f, 0xff, 0xea, 0x57, 0x85, 0x9b, 0x66, 0x2d, 0x7d, - 0x14, 0x73, 0x14, 0xc7, 0xbb, 0xba, 0xab, 0xbf, 0x6b, 0xec, 0xa0, 0x5f, 0x1b, 0x62, 0xe8, 0xcf, - 0x8c, 0x96, 0xe8, 0x9d, 0x59, 0xef, 0x18, 0xf5, 0x7b, 0x33, 0x48, 0x68, 0x6c, 0xa6, 0xc4, 0xf6, - 0x86, 0x79, 0xfd, 0x25, 0x6c, 0x6a, 0x90, 0x16, 0xd0, 0x7e, 0x6b, 0xc0, 0xe6, 0xf4, 0x91, 0x0c, - 0x7d, 0x37, 0x37, 0x2d, 0xf2, 0xc6, 0xb8, 0xfa, 0xcd, 0x44, 0x34, 0xf3, 0xb4, 0xd8, 0x48, 0xb9, - 0xcc, 0x3b, 0x12, 0xd8, 0x96, 0x79, 0x23, 0x05, 0xa6, 0x9d, 0x95, 0x79, 0x7e, 0x14, 0xe0, 0xfe, - 0x66, 0xc0, 0xda, 0x94, 0x3e, 0x8a, 0xee, 0xe7, 0xbf, 0xc5, 0xbc, 0xaa, 0xff, 0xd7, 0xbf, 0x33, - 0xb3, 0x9c, 0xf6, 0x64, 0x4b, 0x02, 0xbe, 0x8b, 0x76, 0x52, 0xc0, 0x5f, 0x8a, 0x02, 0x7e, 0x90, - 0xc0, 0xd6, 0x03, 0x6e, 0x73, 0xe7, 0x45, 0x33, 0x7d, 0xd8, 0xfa, 0x8b, 0x01, 0xd5, 0xb1, 0x0e, - 0x94, 0x1f, 0xf4, 0x69, 0x5d, 0x30, 0x3f, 0xe8, 0x53, 0xdb, 0x9b, 0x79, 0x5f, 0x42, 0x7d, 0x07, - 0x35, 0x52, 0xa8, 0xd1, 0x58, 0x27, 0x68, 0x7e, 0x99, 0xf4, 0xd1, 0x07, 0x3b, 0x2f, 0x9a, 0xa3, - 0x37, 0xcf, 0x3f, 0x18, 0x80, 0x5e, 0xee, 0x1b, 0xe8, 0xdb, 0x17, 0x21, 0x98, 0xda, 0xa9, 0xea, - 0xf7, 0x67, 0x15, 0xd3, 0xe8, 0xdf, 0x94, 0xe8, 0x5f, 0x47, 0xd7, 0x5f, 0x81, 0xbe, 0xfd, 0x73, - 0x03, 0xbe, 0xe6, 0xb0, 0x7e, 0x8e, 0xfa, 0x76, 0x69, 0xd7, 0x0f, 0x8f, 0xc4, 0xf0, 0x75, 0x64, - 0xfc, 0xf0, 0x81, 0xe6, 0xf3, 0x98, 0xe8, 0x91, 0x0d, 0x16, 0x79, 0x4d, 0x8f, 0x04, 0x72, 0x34, - 0x6b, 0xaa, 0x23, 0x3b, 0xa4, 0xf1, 0xb4, 0xc7, 0xed, 0xf7, 0x5c, 0x3f, 0xfc, 0x73, 0xa1, 0xf6, - 0x7d, 0x25, 0x2f, 0x67, 0xea, 0xc6, 0xae, 0x1f, 0x36, 0x9e, 0xb6, 0xda, 0xe2, 0xf8, 0x74, 0x51, - 0x2a, 0xf9, 0xd6, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0xb8, 0xdc, 0x04, 0x55, 0xa5, 0x17, 0x00, - 0x00, + // 2313 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0xcf, 0x6f, 0x1b, 0xc7, + 0xf5, 0xd7, 0x52, 0xa2, 0x44, 0x3e, 0x8a, 0x92, 0x3c, 0xfa, 0x61, 0x85, 0x8e, 0xbf, 0x91, 0x57, + 0x89, 0x23, 0xeb, 0xeb, 0x92, 0x31, 0x8b, 0xda, 0x70, 0x02, 0xa5, 0xb6, 0x28, 0xb9, 0x52, 0xa3, + 0x58, 0xf2, 0x48, 0x51, 0x90, 0x02, 0xc5, 0x62, 0xc5, 0x1d, 0x51, 0x03, 0x2f, 0x77, 0x36, 0xbb, + 0x43, 0x4b, 0x4c, 0x60, 0x14, 0x28, 0x8a, 0xa2, 0xf7, 0x1e, 0x5a, 0x14, 0xed, 0xad, 0x87, 0xb6, + 0xe8, 0x2d, 0xb7, 0xa2, 0xb7, 0xfe, 0x09, 0x3d, 0x15, 0xbd, 0xe6, 0xd4, 0x5b, 0x2f, 0x3d, 0x17, + 0xf3, 0x6b, 0xb9, 0x94, 0xe8, 0x95, 0xe8, 0xa6, 0x40, 0x6f, 0x33, 0x6f, 0xde, 0xe7, 0xcd, 0x9b, + 0x37, 0xef, 0xd7, 0xec, 0xc2, 0xdb, 0x2d, 0xc6, 0x5a, 0x3e, 0xa9, 0x85, 0x11, 0x7d, 0xe1, 0x36, + 0xbb, 0x35, 0xcf, 0x0f, 0x6b, 0x2f, 0xea, 0x47, 0x84, 0xbb, 0xf7, 0xc4, 0xb8, 0x1a, 0x46, 0x8c, + 0x33, 0x54, 0x51, 0x5c, 0x55, 0xcd, 0x55, 0x15, 0x2b, 0x9a, 0xab, 0xf2, 0xa6, 0x96, 0xe0, 0x86, + 0xb4, 0xe6, 0x06, 0x01, 0xe3, 0x2e, 0xa7, 0x2c, 0x88, 0x15, 0xb2, 0xb2, 0xac, 0x57, 0x7d, 0x16, + 0xb4, 0xa2, 0x4e, 0x10, 0xd0, 0xa0, 0x55, 0x63, 0x21, 0x89, 0xfa, 0x98, 0x56, 0x32, 0x94, 0x88, + 0x39, 0x8b, 0xdc, 0x16, 0xd1, 0x9c, 0x37, 0x12, 0x4e, 0xc6, 0xd9, 0x51, 0xe7, 0xb8, 0x46, 0xda, + 0x21, 0xef, 0xea, 0xc5, 0xb7, 0xce, 0x2f, 0x72, 0xda, 0x26, 0x31, 0x77, 0xdb, 0xfa, 0x18, 0x95, + 0x05, 0xcd, 0xc0, 0xbb, 0x21, 0xa9, 0x79, 0x2e, 0x3f, 0x2f, 0x55, 0xd2, 0x05, 0x88, 0x1d, 0x7b, + 0xae, 0x96, 0x6a, 0xff, 0x63, 0x14, 0xca, 0xdb, 0x41, 0x1c, 0x92, 0x26, 0x6f, 0xb0, 0xe0, 0x98, + 0xb6, 0x50, 0x03, 0x80, 0x06, 0xc7, 0xcc, 0x11, 0xec, 0xf1, 0xa2, 0xb5, 0x34, 0xba, 0x52, 0xaa, + 0xbf, 0x5d, 0x7d, 0xb5, 0x89, 0xaa, 0xdb, 0xc1, 0x31, 0x3b, 0xe8, 0x86, 0x04, 0x17, 0xa9, 0x1e, + 0xc5, 0xe8, 0x63, 0x98, 0x6a, 0xd3, 0xc0, 0xf1, 0xe9, 0x73, 0xe2, 0xd3, 0x13, 0xc6, 0xbc, 0xc5, + 0xdc, 0x92, 0xb5, 0x32, 0x55, 0xbf, 0x9d, 0x25, 0x68, 0x27, 0xe1, 0xc6, 0xe5, 0x36, 0x0d, 0x7a, + 0x53, 0x74, 0x0b, 0x26, 0xdb, 0xee, 0x99, 0x73, 0x4c, 0x03, 0x8f, 0x06, 0xad, 0x78, 0x71, 0x74, + 0xc9, 0x5a, 0xc9, 0xe3, 0x52, 0xdb, 0x3d, 0x7b, 0xa2, 0x49, 0x68, 0x19, 0xca, 0x34, 0x68, 0xfa, + 0x1d, 0x8f, 0x38, 0x9f, 0x77, 0x18, 0x27, 0x8b, 0x63, 0x4b, 0xd6, 0x4a, 0x01, 0x4f, 0x6a, 0xe2, + 0x33, 0x41, 0x13, 0x4c, 0xe4, 0x4c, 0x31, 0xa9, 0xe3, 0x8d, 0x2b, 0x26, 0x4d, 0x54, 0xba, 0xbb, + 0x30, 0x93, 0x18, 0xc0, 0xf1, 0x69, 0x9b, 0xf2, 0x78, 0x71, 0x42, 0x9a, 0xe1, 0x41, 0xb6, 0x19, + 0x52, 0x56, 0x4c, 0x8c, 0xb2, 0x23, 0xf0, 0x78, 0x8a, 0xa6, 0xa7, 0x71, 0xa5, 0x23, 0x8c, 0x9e, + 0xa2, 0xa0, 0xc7, 0x50, 0x4c, 0xf6, 0x5c, 0xb4, 0x96, 0xac, 0x2b, 0xdb, 0xbc, 0x60, 0x24, 0x5f, + 0xb0, 0x51, 0xee, 0x82, 0x8d, 0xec, 0x35, 0x98, 0xde, 0x35, 0xde, 0xa9, 0x6f, 0x7b, 0x15, 0xae, + 0x09, 0x14, 0xe5, 0xa4, 0xdd, 0x83, 0x0a, 0x05, 0x46, 0xf1, 0x74, 0xdb, 0x3d, 0xdb, 0xe6, 0xa4, + 0x9d, 0xc0, 0x7f, 0x61, 0x41, 0xa9, 0xc1, 0x02, 0x4e, 0x02, 0x2e, 0xe8, 0x08, 0xc1, 0x58, 0xa2, + 0x6f, 0x11, 0xcb, 0x31, 0x9a, 0x83, 0x31, 0xcf, 0xe5, 0xae, 0xdc, 0x7d, 0x72, 0x6b, 0x04, 0xcb, + 0x19, 0x5a, 0x80, 0xfc, 0x0b, 0xd7, 0xef, 0x10, 0x79, 0x71, 0xc5, 0xad, 0x11, 0xac, 0xa6, 0xe8, + 0x21, 0xe4, 0xb9, 0x7b, 0xe4, 0xab, 0xcb, 0x2a, 0xd5, 0x6f, 0x65, 0x1d, 0xf9, 0x40, 0x30, 0x0a, + 0xa8, 0x44, 0xac, 0x97, 0xa0, 0x28, 0x44, 0x4b, 0xcd, 0xed, 0xbf, 0x58, 0x90, 0x97, 0xeb, 0x68, + 0x0d, 0x26, 0x4e, 0x88, 0xeb, 0x91, 0xc8, 0xb8, 0xee, 0x72, 0x96, 0xcc, 0x27, 0x94, 0xf8, 0xde, + 0xb6, 0x87, 0x0d, 0x06, 0x3d, 0x84, 0xb1, 0x88, 0x9d, 0x0a, 0xe3, 0x09, 0xec, 0x3b, 0x97, 0xea, + 0x53, 0xc5, 0xec, 0x14, 0x4b, 0x48, 0xe5, 0x11, 0x8c, 0x62, 0x76, 0x8a, 0x1e, 0xc2, 0xb8, 0x3c, + 0x9b, 0xd9, 0x3f, 0xf3, 0x4c, 0x87, 0x82, 0x13, 0x6b, 0x80, 0xfd, 0xa3, 0x24, 0x14, 0x31, 0x89, + 0x3b, 0x3e, 0x47, 0xdf, 0x85, 0x42, 0xea, 0x4e, 0xae, 0x70, 0x1a, 0xc9, 0x8b, 0x13, 0x10, 0xfa, + 0x16, 0x20, 0x33, 0x76, 0x78, 0xd4, 0x09, 0x9a, 0x2e, 0x27, 0x2a, 0x14, 0x0b, 0xf8, 0x9a, 0x59, + 0x39, 0x30, 0x0b, 0xf6, 0xef, 0x73, 0x30, 0xa1, 0x85, 0xa0, 0x39, 0xc8, 0xab, 0x38, 0x52, 0xb7, + 0xab, 0x26, 0xfd, 0x7e, 0x9a, 0x7b, 0x2d, 0x3f, 0x7d, 0x02, 0x90, 0x4a, 0x0b, 0xa3, 0x43, 0xa5, + 0x85, 0x14, 0x12, 0x3d, 0x82, 0x82, 0xcf, 0x9a, 0xd2, 0x97, 0xb5, 0xfb, 0x64, 0x6a, 0xb2, 0xa3, + 0x79, 0x71, 0x82, 0x42, 0x1f, 0x40, 0xa9, 0x19, 0x11, 0x97, 0x13, 0x47, 0x64, 0x45, 0x99, 0x0b, + 0x4a, 0xf5, 0x4a, 0x4f, 0x88, 0xca, 0xb3, 0xd5, 0x03, 0x93, 0x67, 0x31, 0x28, 0x76, 0x41, 0xb0, + 0xff, 0x3c, 0x0a, 0x05, 0x23, 0x13, 0x3d, 0x02, 0x38, 0xea, 0x72, 0xe2, 0x44, 0x6e, 0xd0, 0x32, + 0xf1, 0x9b, 0x79, 0xf1, 0x58, 0x30, 0xe2, 0xa2, 0x00, 0xc9, 0x21, 0xfa, 0x3e, 0x4c, 0x37, 0x99, + 0x47, 0x42, 0x46, 0x03, 0xae, 0xc5, 0xe4, 0xae, 0x2a, 0x66, 0x2a, 0x41, 0x1a, 0x59, 0x25, 0xda, + 0x76, 0x5b, 0xc4, 0x39, 0x62, 0x67, 0x44, 0x24, 0x4b, 0xe1, 0x39, 0x77, 0x32, 0xaf, 0x49, 0xb0, + 0x27, 0x16, 0x02, 0x89, 0x5e, 0x17, 0x60, 0xb4, 0x01, 0x10, 0x91, 0x26, 0x8b, 0x3c, 0xe7, 0x39, + 0xe9, 0x6a, 0x3b, 0x67, 0x86, 0x05, 0x96, 0xdc, 0x1f, 0x91, 0x2e, 0x2e, 0x46, 0x66, 0x88, 0x3e, + 0x14, 0x8e, 0x4c, 0x7c, 0xcf, 0xa1, 0xde, 0x62, 0x5e, 0xca, 0xb8, 0x5a, 0x58, 0x1e, 0xab, 0x01, + 0xda, 0x83, 0x29, 0x19, 0xf5, 0x4e, 0x72, 0xe3, 0xea, 0xb2, 0xee, 0x5c, 0x1a, 0xa0, 0xc9, 0xa1, + 0xca, 0x3c, 0x3d, 0xb5, 0xef, 0x42, 0xb9, 0x6f, 0x1d, 0xdd, 0x80, 0x62, 0xc4, 0x4e, 0x1d, 0x1a, + 0x78, 0xe4, 0x4c, 0x27, 0xc0, 0x42, 0xc4, 0x4e, 0xb7, 0xc5, 0xdc, 0xae, 0x41, 0x5e, 0x99, 0x76, + 0x0e, 0xf2, 0x31, 0x77, 0x23, 0xae, 0x39, 0xd4, 0x04, 0xcd, 0xc0, 0x28, 0x09, 0x54, 0x5c, 0x8d, + 0x62, 0x31, 0xb4, 0x9b, 0x50, 0xee, 0xb3, 0xa9, 0x60, 0xe1, 0x2c, 0x94, 0xb0, 0x3c, 0x16, 0x43, + 0x91, 0x3d, 0x7d, 0x72, 0xcc, 0x75, 0x9e, 0x96, 0x63, 0x21, 0xfe, 0x94, 0x7a, 0xfc, 0x44, 0x17, + 0x38, 0x35, 0x41, 0x0b, 0x30, 0x7e, 0x42, 0x68, 0xeb, 0x84, 0x4b, 0xfb, 0xe7, 0xb1, 0x9e, 0xd9, + 0x5f, 0xe7, 0x61, 0x0e, 0x13, 0xcf, 0x95, 0x45, 0x47, 0x64, 0x65, 0x4c, 0x3e, 0xef, 0x90, 0x98, + 0x0b, 0x73, 0x51, 0x95, 0x48, 0x9c, 0xa6, 0x4c, 0xf3, 0xda, 0x25, 0xef, 0x5c, 0xb9, 0x7e, 0xe1, + 0x32, 0xed, 0x6b, 0x0a, 0xd6, 0x20, 0x2f, 0x12, 0xad, 0x49, 0x8c, 0xef, 0x66, 0x09, 0x4a, 0x95, + 0x08, 0xac, 0x50, 0xa8, 0x05, 0xd3, 0x11, 0x09, 0x7d, 0xb7, 0x49, 0xb4, 0x42, 0xc6, 0x2b, 0x3f, + 0xcc, 0x76, 0xa5, 0x8b, 0x67, 0xab, 0x62, 0x25, 0x47, 0xab, 0x39, 0x15, 0xa5, 0xa7, 0x31, 0x7a, + 0x09, 0xd7, 0x95, 0xeb, 0x47, 0x12, 0x4b, 0x59, 0x90, 0x6c, 0x38, 0x26, 0x37, 0xdc, 0x1c, 0x7a, + 0x43, 0x79, 0x8f, 0xd8, 0x88, 0xd3, 0xfb, 0xce, 0xd3, 0x01, 0x54, 0x59, 0xd7, 0xfb, 0xf4, 0xfb, + 0x86, 0xea, 0xba, 0xb1, 0xdd, 0x29, 0xe5, 0x27, 0xd2, 0x5f, 0x8a, 0xb8, 0xa4, 0x69, 0x9f, 0x52, + 0x7e, 0x52, 0xf9, 0xbb, 0x05, 0x73, 0x83, 0xd4, 0x44, 0x8d, 0xd7, 0xdc, 0x7e, 0x6b, 0x24, 0xa5, + 0xc0, 0x8a, 0xb8, 0x3c, 0x21, 0xd7, 0x71, 0x7d, 0xdf, 0xe1, 0xe4, 0x4c, 0xf9, 0x6c, 0x61, 0x6b, + 0x04, 0x97, 0xd5, 0xc2, 0x63, 0xdf, 0x3f, 0x20, 0x67, 0x5c, 0x24, 0xb1, 0xb4, 0xdd, 0x7d, 0x16, + 0x49, 0x47, 0xbe, 0x24, 0x89, 0x35, 0x04, 0xa3, 0xb8, 0xc9, 0x44, 0x77, 0x9f, 0x45, 0xeb, 0x05, + 0x18, 0xe7, 0x6e, 0xd4, 0x22, 0xdc, 0x6e, 0x40, 0x5e, 0x92, 0x44, 0x0c, 0x45, 0xc4, 0x93, 0xe7, + 0xc8, 0x61, 0x31, 0x14, 0xf1, 0xd2, 0x8a, 0x08, 0x09, 0xa4, 0x42, 0x39, 0xac, 0x26, 0x22, 0xb2, + 0x8e, 0x4c, 0xb3, 0x91, 0xc3, 0x72, 0x6c, 0x1f, 0xc2, 0xfc, 0xb9, 0xdb, 0x8d, 0x43, 0x16, 0xc4, + 0xa4, 0xe7, 0xd9, 0xd6, 0xeb, 0x78, 0xb6, 0xfd, 0x3b, 0x0b, 0xe6, 0x7b, 0x91, 0xf3, 0xbf, 0x1c, + 0x84, 0xf6, 0x0f, 0x61, 0xe1, 0xbc, 0xa6, 0xda, 0x06, 0x0d, 0x98, 0x88, 0x64, 0xc7, 0x61, 0xac, + 0x70, 0x15, 0x1d, 0x55, 0x8f, 0x82, 0x0d, 0xd2, 0xfe, 0x67, 0x0e, 0x6e, 0x36, 0x64, 0x7d, 0xd4, + 0x0c, 0x49, 0xab, 0xf9, 0xdf, 0xb3, 0xc8, 0x1e, 0x4c, 0xe9, 0x17, 0x94, 0x91, 0x98, 0xbb, 0x5c, + 0xe2, 0xbe, 0x42, 0x18, 0x89, 0x71, 0x7a, 0x8a, 0x0e, 0xa0, 0xcc, 0x3a, 0x3c, 0xec, 0x24, 0x2a, + 0x2a, 0x07, 0xae, 0x65, 0x09, 0xdc, 0x95, 0x80, 0x7e, 0xb1, 0x93, 0x4a, 0x8a, 0x96, 0x7a, 0x08, + 0x33, 0xc9, 0xb3, 0xd0, 0x08, 0x56, 0x75, 0xf0, 0xff, 0x33, 0x05, 0xf7, 0x37, 0xeb, 0x78, 0x9a, + 0xf5, 0x13, 0xec, 0xaf, 0x2c, 0x98, 0x1d, 0xb0, 0x3b, 0x7a, 0x6c, 0xfa, 0xea, 0x2b, 0x18, 0x78, + 0x9d, 0xb6, 0x9e, 0x75, 0x48, 0xd4, 0xed, 0xef, 0xaf, 0xd1, 0x33, 0x98, 0x34, 0xa6, 0x0d, 0x5d, + 0x9d, 0x76, 0x4a, 0xf5, 0xbb, 0x99, 0x3e, 0xe7, 0xb3, 0x8e, 0xa7, 0x15, 0xd9, 0x73, 0xf9, 0xc9, + 0xd6, 0x08, 0x2e, 0xc5, 0xbd, 0xe9, 0xfa, 0xb8, 0x7a, 0x2f, 0xd8, 0x6d, 0x40, 0x26, 0xd1, 0xec, + 0x8b, 0xf7, 0x74, 0xcc, 0x69, 0x33, 0xfe, 0x26, 0x52, 0xe5, 0x1c, 0xe4, 0x9b, 0xac, 0x13, 0x70, + 0x5d, 0x89, 0xd5, 0xc4, 0xfe, 0x6a, 0x0c, 0x16, 0xcf, 0xbb, 0xe4, 0xc7, 0x84, 0xbb, 0xf2, 0x65, + 0xf2, 0x2e, 0x4c, 0x87, 0x11, 0x6b, 0x92, 0x38, 0x26, 0x9e, 0x23, 0xda, 0x31, 0xf3, 0xfa, 0x99, + 0x4a, 0xc8, 0xeb, 0x82, 0x8a, 0xea, 0x30, 0xcf, 0x19, 0x77, 0x7d, 0x87, 0xc4, 0x9c, 0xb6, 0x45, + 0xbb, 0xac, 0xd9, 0xc7, 0x24, 0xfb, 0xac, 0x5c, 0xdc, 0x34, 0x6b, 0x0a, 0x73, 0x08, 0xd3, 0xbd, + 0x97, 0x64, 0xcc, 0x5d, 0x6e, 0x42, 0xb7, 0x7a, 0x95, 0x83, 0xf5, 0x6c, 0x23, 0xdc, 0xbe, 0x47, + 0x8b, 0xcf, 0x37, 0xae, 0xa3, 0xc3, 0x34, 0xae, 0xc8, 0x81, 0x85, 0x48, 0x05, 0xa4, 0x73, 0x2e, + 0x1a, 0xf3, 0xc3, 0x46, 0xe3, 0x9c, 0x16, 0xd4, 0xff, 0x01, 0x21, 0xb5, 0xc1, 0xb9, 0xe0, 0x1c, + 0x1f, 0x36, 0x38, 0xcd, 0x06, 0xfd, 0xde, 0xdd, 0x84, 0x79, 0xb3, 0x41, 0x7f, 0xac, 0x4e, 0xbc, + 0x5e, 0xac, 0xce, 0x6a, 0x69, 0xbb, 0xa9, 0x90, 0xb5, 0xef, 0x26, 0xd9, 0x32, 0x95, 0xc7, 0xe4, + 0xab, 0x0c, 0xc1, 0x58, 0xe0, 0xb6, 0x93, 0x67, 0xaf, 0x18, 0xdb, 0x3f, 0xb1, 0xa0, 0xb2, 0x43, + 0x13, 0x4b, 0x98, 0x27, 0xb3, 0xc9, 0x7c, 0x03, 0x20, 0xa2, 0xe1, 0x0c, 0x85, 0x6d, 0x62, 0xfa, + 0x05, 0xd1, 0x4d, 0x60, 0x41, 0x10, 0xf6, 0xe9, 0x17, 0x04, 0xdd, 0x04, 0x90, 0x8b, 0x9c, 0x3d, + 0x27, 0x81, 0x7a, 0x35, 0x63, 0xc9, 0x7e, 0x20, 0x08, 0xa2, 0x23, 0x3c, 0xa6, 0x3e, 0x27, 0x91, + 0xf4, 0xbe, 0x22, 0xd6, 0x33, 0xfb, 0x67, 0x16, 0xdc, 0x18, 0xa8, 0x86, 0x4e, 0xf4, 0x8f, 0x61, + 0x5c, 0xa5, 0xeb, 0x21, 0x32, 0xaf, 0xce, 0xf3, 0x1a, 0x88, 0x6e, 0xc3, 0x74, 0x40, 0xce, 0xb8, + 0x93, 0x52, 0x4f, 0x75, 0x24, 0x65, 0x41, 0xde, 0x33, 0x2a, 0xda, 0xbf, 0xb1, 0x60, 0xd6, 0x78, + 0xf2, 0x06, 0x89, 0x9b, 0x11, 0x0d, 0x65, 0x23, 0x3c, 0xc8, 0x14, 0xb7, 0x60, 0xd2, 0xa3, 0x71, + 0xe8, 0xbb, 0x5d, 0x47, 0xae, 0xe9, 0x16, 0x47, 0xd3, 0x9e, 0x0a, 0x96, 0x5d, 0x00, 0xf1, 0x46, + 0x6d, 0xb1, 0x88, 0x26, 0x4f, 0x9a, 0xcc, 0x8b, 0x6e, 0x28, 0xee, 0x6e, 0x6a, 0x6f, 0x9c, 0x12, + 0x61, 0x7f, 0x0a, 0x73, 0xca, 0x52, 0xfa, 0x93, 0x95, 0xb9, 0xaa, 0x0a, 0x14, 0x34, 0x57, 0x57, + 0xeb, 0x98, 0xcc, 0xd1, 0x32, 0x94, 0x7d, 0x37, 0x68, 0x75, 0x94, 0x4b, 0x7b, 0x46, 0xd1, 0x49, + 0x43, 0x6c, 0x30, 0x8f, 0xd8, 0x2d, 0x98, 0x3f, 0x27, 0x58, 0x1b, 0xff, 0xe9, 0x80, 0x0f, 0x6b, + 0xb5, 0xab, 0x24, 0x82, 0xf4, 0x11, 0x7a, 0xdf, 0xd8, 0xec, 0x1d, 0x98, 0x1d, 0x70, 0xc8, 0xd7, + 0x34, 0xb0, 0xfd, 0x08, 0xde, 0x10, 0x6a, 0x63, 0xc6, 0x78, 0x23, 0xb1, 0x92, 0x31, 0xca, 0x85, + 0x83, 0x5b, 0x03, 0x0e, 0xde, 0x56, 0x21, 0x70, 0x5e, 0x82, 0x3e, 0x7d, 0xff, 0x05, 0x5a, 0xff, + 0xf9, 0x05, 0xfe, 0x2d, 0x07, 0x79, 0xf9, 0xfd, 0x04, 0xbd, 0x03, 0x65, 0x1a, 0x70, 0xd2, 0x22, + 0x91, 0xa3, 0xbe, 0x32, 0xc9, 0x0c, 0xbe, 0x35, 0x82, 0x27, 0x35, 0x59, 0xb1, 0xdd, 0x82, 0xd2, + 0xb1, 0xcf, 0x5c, 0xae, 0x99, 0x84, 0x0d, 0xac, 0xad, 0x11, 0x0c, 0x92, 0xa8, 0x58, 0x96, 0x45, + 0xd1, 0x8b, 0x68, 0xd0, 0x72, 0xfa, 0x3f, 0x57, 0x95, 0x14, 0x35, 0xd9, 0xee, 0x88, 0x31, 0x9f, + 0xb8, 0x81, 0xe6, 0x1a, 0xd3, 0xdd, 0xf0, 0xa4, 0x26, 0x2b, 0xb6, 0x4d, 0x98, 0x4e, 0xbe, 0xd0, + 0x6a, 0xc6, 0xfc, 0x65, 0x89, 0x7a, 0x6b, 0x04, 0x4f, 0x25, 0x20, 0x25, 0xe6, 0x01, 0x80, 0xa0, + 0x68, 0x09, 0x2a, 0x83, 0x2e, 0x18, 0x09, 0xc2, 0x95, 0x24, 0x7a, 0xf7, 0x78, 0xc3, 0xed, 0x6e, + 0x8d, 0xe0, 0xa2, 0xe0, 0x55, 0xc0, 0x3a, 0x80, 0x27, 0x4a, 0x84, 0x02, 0xaa, 0xd4, 0x78, 0xad, + 0x0f, 0xb8, 0xe1, 0x72, 0x51, 0xf0, 0x8b, 0x82, 0x4d, 0x62, 0x4c, 0x85, 0x5e, 0xe5, 0x00, 0xa9, + 0xaf, 0xaf, 0x15, 0x58, 0xd8, 0xd9, 0xfe, 0x68, 0x73, 0x67, 0x7b, 0x6b, 0x77, 0x77, 0xc3, 0xf9, + 0xe4, 0xe9, 0xfe, 0xde, 0x66, 0x63, 0xfb, 0xc9, 0xf6, 0xe6, 0xc6, 0xcc, 0x08, 0xba, 0x06, 0xe5, + 0xc3, 0x4d, 0xfc, 0x99, 0xf3, 0xc9, 0x53, 0xc9, 0xf2, 0xd9, 0x8c, 0x85, 0x26, 0xa1, 0x90, 0xcc, + 0x72, 0x62, 0xb6, 0xb7, 0xbb, 0xbf, 0xbf, 0xbd, 0xbe, 0xb3, 0x39, 0x33, 0x8a, 0x00, 0xc6, 0xf5, + 0xca, 0x18, 0x9a, 0x86, 0x92, 0x84, 0x6a, 0x42, 0xbe, 0xfe, 0xaf, 0x09, 0x80, 0x0d, 0x3f, 0xdc, + 0x27, 0xd1, 0x0b, 0xda, 0x24, 0xe8, 0xd7, 0x16, 0x4c, 0xf5, 0x37, 0xac, 0xe8, 0xde, 0xd5, 0x6a, + 0x53, 0xaa, 0x0d, 0xaf, 0xd4, 0x87, 0x81, 0x28, 0x5f, 0xb5, 0x97, 0x7f, 0xfc, 0xd7, 0xaf, 0x7f, + 0x9e, 0xbb, 0x69, 0x2f, 0x26, 0xdf, 0xe9, 0x9b, 0x8a, 0xe3, 0x7d, 0x5d, 0x31, 0xdf, 0xb7, 0x56, + 0xd1, 0x2f, 0x2d, 0xf1, 0xd8, 0x4b, 0x3d, 0x29, 0xd0, 0x7b, 0xc3, 0xbe, 0x2d, 0x2b, 0xf7, 0x86, + 0x40, 0x68, 0xdd, 0x6c, 0xa9, 0xdb, 0x9b, 0xf6, 0xf5, 0x0b, 0xba, 0xa9, 0x07, 0x94, 0x50, 0xed, + 0x57, 0x16, 0x2c, 0x0c, 0x6e, 0xc5, 0xd1, 0xc3, 0xcc, 0x90, 0xcb, 0x6a, 0xdf, 0x2b, 0x37, 0x0d, + 0x34, 0xf5, 0xb7, 0xa3, 0xd7, 0xa2, 0xda, 0xb7, 0xa5, 0x62, 0x4b, 0xf6, 0x8d, 0x44, 0x31, 0x6d, + 0xac, 0xd4, 0x1f, 0x11, 0xa1, 0xdc, 0x9f, 0x2c, 0x98, 0x1d, 0x50, 0xa3, 0xd0, 0xfd, 0xec, 0x6f, + 0x80, 0xaf, 0xaa, 0xad, 0x95, 0x07, 0x43, 0xe3, 0xb4, 0x25, 0xeb, 0x52, 0xe1, 0xbb, 0x68, 0x35, + 0x51, 0xf8, 0x4b, 0x91, 0x1c, 0xd7, 0x8c, 0xda, 0xfa, 0x61, 0x53, 0x5b, 0x7d, 0x59, 0x4b, 0x3e, + 0xa8, 0xfe, 0xd1, 0x82, 0x72, 0x5f, 0x76, 0xcf, 0xbe, 0xf4, 0x41, 0x15, 0x26, 0xfb, 0xd2, 0x07, + 0x96, 0x0e, 0xfb, 0xbe, 0x54, 0xf5, 0x3d, 0x54, 0x4d, 0x54, 0x8d, 0xfa, 0xb2, 0x6c, 0xed, 0x4b, + 0x53, 0xa3, 0xd6, 0x56, 0x5f, 0xd6, 0x7a, 0xbf, 0x61, 0x7e, 0x6b, 0x01, 0xba, 0x98, 0x93, 0xd1, + 0x77, 0x2e, 0xd3, 0x60, 0x60, 0x15, 0xa8, 0xdc, 0x1f, 0x16, 0xa6, 0xb5, 0x7f, 0x4b, 0x6a, 0xff, + 0x06, 0xba, 0xfe, 0x0a, 0xed, 0xd7, 0x7f, 0x6a, 0xc1, 0xff, 0x35, 0x59, 0x3b, 0x43, 0xfc, 0x7a, + 0x61, 0xc3, 0x0f, 0xf7, 0x44, 0xbe, 0xdc, 0xb3, 0x7e, 0xb0, 0xa6, 0xf9, 0x5a, 0x4c, 0xd4, 0x9f, + 0x2a, 0x8b, 0x5a, 0xb5, 0x16, 0x09, 0x64, 0x36, 0xad, 0xa9, 0x25, 0x37, 0xa4, 0xf1, 0xa0, 0xff, + 0x6d, 0x1f, 0x78, 0x7e, 0xf8, 0x87, 0xdc, 0xe2, 0xf7, 0x14, 0x5e, 0xbe, 0x57, 0xaa, 0x1b, 0x7e, + 0x58, 0x3d, 0xac, 0xaf, 0x8b, 0xe5, 0xa3, 0x71, 0x29, 0xe4, 0xdb, 0xff, 0x0e, 0x00, 0x00, 0xff, + 0xff, 0x01, 0xfb, 0x51, 0xc8, 0x38, 0x1c, 0x00, 0x00, } diff --git a/vendor/google.golang.org/genproto/googleapis/privacy/dlp/v2beta1/storage.pb.go b/vendor/google.golang.org/genproto/googleapis/privacy/dlp/v2beta1/storage.pb.go index 63558571..043ba03f 100644 --- a/vendor/google.golang.org/genproto/googleapis/privacy/dlp/v2beta1/storage.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/privacy/dlp/v2beta1/storage.pb.go @@ -7,6 +7,7 @@ import proto "github.com/golang/protobuf/proto" import fmt "fmt" import math "math" import _ "google.golang.org/genproto/googleapis/api/annotations" +import _ "github.com/golang/protobuf/ptypes/timestamp" // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal @@ -15,10 +16,7 @@ var _ = math.Inf // Type of information detected by the API. type InfoType struct { - // Name of the information type. For built-in info types, this is provided by - // the API call ListInfoTypes. For user-defined info types, this is - // provided by the user. All user-defined info types must have unique names, - // and cannot conflict with built-in info type names. + // Name of the information type. Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` } @@ -36,7 +34,7 @@ func (m *InfoType) GetName() string { // General identifier of a data field in a storage service. type FieldId struct { - // Column name describing the field. + // Name describing the field. ColumnName string `protobuf:"bytes,1,opt,name=column_name,json=columnName" json:"column_name,omitempty"` } @@ -232,18 +230,47 @@ func (m *CloudStoragePath) GetPath() string { return "" } +// Options defining BigQuery table and row identifiers. +type BigQueryOptions struct { + // Complete BigQuery table reference. + TableReference *BigQueryTable `protobuf:"bytes,1,opt,name=table_reference,json=tableReference" json:"table_reference,omitempty"` + // References to fields uniquely identifying rows within the table. + // Nested fields in the format, like `person.birthdate.year`, are allowed. + IdentifyingFields []*FieldId `protobuf:"bytes,2,rep,name=identifying_fields,json=identifyingFields" json:"identifying_fields,omitempty"` +} + +func (m *BigQueryOptions) Reset() { *m = BigQueryOptions{} } +func (m *BigQueryOptions) String() string { return proto.CompactTextString(m) } +func (*BigQueryOptions) ProtoMessage() {} +func (*BigQueryOptions) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{9} } + +func (m *BigQueryOptions) GetTableReference() *BigQueryTable { + if m != nil { + return m.TableReference + } + return nil +} + +func (m *BigQueryOptions) GetIdentifyingFields() []*FieldId { + if m != nil { + return m.IdentifyingFields + } + return nil +} + // Shared message indicating Cloud storage type. type StorageConfig struct { // Types that are valid to be assigned to Type: // *StorageConfig_DatastoreOptions // *StorageConfig_CloudStorageOptions + // *StorageConfig_BigQueryOptions Type isStorageConfig_Type `protobuf_oneof:"type"` } func (m *StorageConfig) Reset() { *m = StorageConfig{} } func (m *StorageConfig) String() string { return proto.CompactTextString(m) } func (*StorageConfig) ProtoMessage() {} -func (*StorageConfig) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{9} } +func (*StorageConfig) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{10} } type isStorageConfig_Type interface { isStorageConfig_Type() @@ -255,9 +282,13 @@ type StorageConfig_DatastoreOptions struct { type StorageConfig_CloudStorageOptions struct { CloudStorageOptions *CloudStorageOptions `protobuf:"bytes,3,opt,name=cloud_storage_options,json=cloudStorageOptions,oneof"` } +type StorageConfig_BigQueryOptions struct { + BigQueryOptions *BigQueryOptions `protobuf:"bytes,4,opt,name=big_query_options,json=bigQueryOptions,oneof"` +} func (*StorageConfig_DatastoreOptions) isStorageConfig_Type() {} func (*StorageConfig_CloudStorageOptions) isStorageConfig_Type() {} +func (*StorageConfig_BigQueryOptions) isStorageConfig_Type() {} func (m *StorageConfig) GetType() isStorageConfig_Type { if m != nil { @@ -280,11 +311,19 @@ func (m *StorageConfig) GetCloudStorageOptions() *CloudStorageOptions { return nil } +func (m *StorageConfig) GetBigQueryOptions() *BigQueryOptions { + if x, ok := m.GetType().(*StorageConfig_BigQueryOptions); ok { + return x.BigQueryOptions + } + return nil +} + // XXX_OneofFuncs is for the internal use of the proto package. func (*StorageConfig) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) { return _StorageConfig_OneofMarshaler, _StorageConfig_OneofUnmarshaler, _StorageConfig_OneofSizer, []interface{}{ (*StorageConfig_DatastoreOptions)(nil), (*StorageConfig_CloudStorageOptions)(nil), + (*StorageConfig_BigQueryOptions)(nil), } } @@ -302,6 +341,11 @@ func _StorageConfig_OneofMarshaler(msg proto.Message, b *proto.Buffer) error { if err := b.EncodeMessage(x.CloudStorageOptions); err != nil { return err } + case *StorageConfig_BigQueryOptions: + b.EncodeVarint(4<<3 | proto.WireBytes) + if err := b.EncodeMessage(x.BigQueryOptions); err != nil { + return err + } case nil: default: return fmt.Errorf("StorageConfig.Type has unexpected type %T", x) @@ -328,6 +372,14 @@ func _StorageConfig_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto. err := b.DecodeMessage(msg) m.Type = &StorageConfig_CloudStorageOptions{msg} return true, err + case 4: // type.big_query_options + if wire != proto.WireBytes { + return true, proto.ErrInternalBadWireType + } + msg := new(BigQueryOptions) + err := b.DecodeMessage(msg) + m.Type = &StorageConfig_BigQueryOptions{msg} + return true, err default: return false, nil } @@ -347,6 +399,11 @@ func _StorageConfig_OneofSizer(msg proto.Message) (n int) { n += proto.SizeVarint(3<<3 | proto.WireBytes) n += proto.SizeVarint(uint64(s)) n += s + case *StorageConfig_BigQueryOptions: + s := proto.Size(x.BigQueryOptions) + n += proto.SizeVarint(4<<3 | proto.WireBytes) + n += proto.SizeVarint(uint64(s)) + n += s case nil: default: panic(fmt.Sprintf("proto: unexpected type %T in oneof", x)) @@ -365,7 +422,7 @@ type CloudStorageKey struct { func (m *CloudStorageKey) Reset() { *m = CloudStorageKey{} } func (m *CloudStorageKey) String() string { return proto.CompactTextString(m) } func (*CloudStorageKey) ProtoMessage() {} -func (*CloudStorageKey) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{10} } +func (*CloudStorageKey) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{11} } func (m *CloudStorageKey) GetFilePath() string { if m != nil { @@ -390,7 +447,7 @@ type DatastoreKey struct { func (m *DatastoreKey) Reset() { *m = DatastoreKey{} } func (m *DatastoreKey) String() string { return proto.CompactTextString(m) } func (*DatastoreKey) ProtoMessage() {} -func (*DatastoreKey) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{11} } +func (*DatastoreKey) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{12} } func (m *DatastoreKey) GetEntityKey() *Key { if m != nil { @@ -423,7 +480,7 @@ type Key struct { func (m *Key) Reset() { *m = Key{} } func (m *Key) String() string { return proto.CompactTextString(m) } func (*Key) ProtoMessage() {} -func (*Key) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{12} } +func (*Key) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{13} } func (m *Key) GetPartitionId() *PartitionId { if m != nil { @@ -460,7 +517,7 @@ type Key_PathElement struct { func (m *Key_PathElement) Reset() { *m = Key_PathElement{} } func (m *Key_PathElement) String() string { return proto.CompactTextString(m) } func (*Key_PathElement) ProtoMessage() {} -func (*Key_PathElement) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{12, 0} } +func (*Key_PathElement) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{13, 0} } type isKey_PathElement_IdType interface { isKey_PathElement_IdType() @@ -580,7 +637,7 @@ type RecordKey struct { func (m *RecordKey) Reset() { *m = RecordKey{} } func (m *RecordKey) String() string { return proto.CompactTextString(m) } func (*RecordKey) ProtoMessage() {} -func (*RecordKey) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{13} } +func (*RecordKey) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{14} } type isRecordKey_Type interface { isRecordKey_Type() @@ -691,6 +748,47 @@ func _RecordKey_OneofSizer(msg proto.Message) (n int) { return n } +// Message defining the location of a BigQuery table. A table is uniquely +// identified by its project_id, dataset_id, and table_name. Within a query +// a table is often referenced with a string in the format of: +// `:.` or +// `..`. +type BigQueryTable struct { + // The Google Cloud Platform project ID of the project containing the table. + // If omitted, project ID is inferred from the API call. + ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId" json:"project_id,omitempty"` + // Dataset ID of the table. + DatasetId string `protobuf:"bytes,2,opt,name=dataset_id,json=datasetId" json:"dataset_id,omitempty"` + // Name of the table. + TableId string `protobuf:"bytes,3,opt,name=table_id,json=tableId" json:"table_id,omitempty"` +} + +func (m *BigQueryTable) Reset() { *m = BigQueryTable{} } +func (m *BigQueryTable) String() string { return proto.CompactTextString(m) } +func (*BigQueryTable) ProtoMessage() {} +func (*BigQueryTable) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{15} } + +func (m *BigQueryTable) GetProjectId() string { + if m != nil { + return m.ProjectId + } + return "" +} + +func (m *BigQueryTable) GetDatasetId() string { + if m != nil { + return m.DatasetId + } + return "" +} + +func (m *BigQueryTable) GetTableId() string { + if m != nil { + return m.TableId + } + return "" +} + func init() { proto.RegisterType((*InfoType)(nil), "google.privacy.dlp.v2beta1.InfoType") proto.RegisterType((*FieldId)(nil), "google.privacy.dlp.v2beta1.FieldId") @@ -702,64 +800,75 @@ func init() { proto.RegisterType((*CloudStorageOptions)(nil), "google.privacy.dlp.v2beta1.CloudStorageOptions") proto.RegisterType((*CloudStorageOptions_FileSet)(nil), "google.privacy.dlp.v2beta1.CloudStorageOptions.FileSet") proto.RegisterType((*CloudStoragePath)(nil), "google.privacy.dlp.v2beta1.CloudStoragePath") + proto.RegisterType((*BigQueryOptions)(nil), "google.privacy.dlp.v2beta1.BigQueryOptions") proto.RegisterType((*StorageConfig)(nil), "google.privacy.dlp.v2beta1.StorageConfig") proto.RegisterType((*CloudStorageKey)(nil), "google.privacy.dlp.v2beta1.CloudStorageKey") proto.RegisterType((*DatastoreKey)(nil), "google.privacy.dlp.v2beta1.DatastoreKey") proto.RegisterType((*Key)(nil), "google.privacy.dlp.v2beta1.Key") proto.RegisterType((*Key_PathElement)(nil), "google.privacy.dlp.v2beta1.Key.PathElement") proto.RegisterType((*RecordKey)(nil), "google.privacy.dlp.v2beta1.RecordKey") + proto.RegisterType((*BigQueryTable)(nil), "google.privacy.dlp.v2beta1.BigQueryTable") } func init() { proto.RegisterFile("google/privacy/dlp/v2beta1/storage.proto", fileDescriptor1) } var fileDescriptor1 = []byte{ - // 762 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0xdd, 0x6e, 0xe3, 0x44, - 0x14, 0x8e, 0x93, 0x68, 0xdb, 0x1c, 0x67, 0xd9, 0xd4, 0x0b, 0x52, 0x94, 0x85, 0xfd, 0xb1, 0xd0, - 0x6e, 0xb4, 0x05, 0x5b, 0x84, 0x0b, 0x2e, 0x10, 0x45, 0x4a, 0x7f, 0x48, 0x88, 0xd4, 0x04, 0xb7, - 0x02, 0x01, 0x17, 0xd6, 0xd4, 0x33, 0x71, 0x87, 0x3a, 0x33, 0x23, 0x7b, 0x5a, 0xe1, 0x17, 0x40, - 0x3c, 0x0b, 0x2f, 0xc1, 0x83, 0x70, 0x8f, 0x78, 0x0c, 0x34, 0x3f, 0x49, 0xdc, 0x1f, 0xd2, 0x22, - 0xed, 0xdd, 0xe4, 0xe4, 0x9c, 0xef, 0xcc, 0xf9, 0xbe, 0xef, 0x8c, 0xa1, 0x9f, 0x72, 0x9e, 0x66, - 0x24, 0x14, 0x39, 0xbd, 0x42, 0x49, 0x19, 0xe2, 0x4c, 0x84, 0x57, 0x83, 0x33, 0x22, 0xd1, 0x67, - 0x61, 0x21, 0x79, 0x8e, 0x52, 0x12, 0x88, 0x9c, 0x4b, 0xee, 0xf5, 0x4c, 0x66, 0x60, 0x33, 0x03, - 0x9c, 0x89, 0xc0, 0x66, 0xf6, 0x3e, 0xb4, 0x28, 0x48, 0xd0, 0x10, 0x31, 0xc6, 0x25, 0x92, 0x94, - 0xb3, 0xc2, 0x54, 0xfa, 0xcf, 0x61, 0x7b, 0xcc, 0xe6, 0xfc, 0xb4, 0x14, 0xc4, 0xf3, 0xa0, 0xc9, - 0xd0, 0x82, 0x74, 0x9d, 0x97, 0x4e, 0xbf, 0x15, 0xe9, 0xb3, 0xff, 0x16, 0xb6, 0x8e, 0x28, 0xc9, - 0xf0, 0x18, 0x7b, 0x2f, 0xc0, 0x4d, 0x78, 0x76, 0xb9, 0x60, 0x71, 0x25, 0x0b, 0x4c, 0xe8, 0x58, - 0xe5, 0x4e, 0xc1, 0x9d, 0xa1, 0x5c, 0x52, 0x85, 0x3f, 0xc6, 0xde, 0x47, 0x00, 0x22, 0xe7, 0xbf, - 0x90, 0x44, 0xc6, 0x14, 0x77, 0xeb, 0x3a, 0xbd, 0x65, 0x23, 0x63, 0xec, 0xbd, 0x82, 0xb6, 0xc2, - 0x29, 0x04, 0x4a, 0x88, 0x4a, 0x68, 0xea, 0x04, 0x77, 0x15, 0x1b, 0x63, 0xff, 0x63, 0x78, 0x6f, - 0x42, 0x19, 0x3e, 0xfc, 0x55, 0xe4, 0xa4, 0x28, 0x28, 0x67, 0x77, 0x5e, 0xf1, 0x0d, 0xec, 0xcc, - 0x72, 0x2e, 0x48, 0x2e, 0xcb, 0x88, 0xcc, 0x49, 0x4e, 0x58, 0xb2, 0x9e, 0xa5, 0x5e, 0x49, 0xfc, - 0x01, 0x60, 0x66, 0xda, 0x2b, 0xa8, 0x31, 0x6c, 0x0b, 0x5b, 0xa6, 0xe1, 0xdc, 0xc1, 0xa7, 0xc1, - 0x7f, 0xd3, 0x18, 0xdc, 0x6a, 0x11, 0xad, 0xca, 0xfd, 0xbf, 0x1d, 0xe8, 0x1c, 0x20, 0x89, 0x94, - 0x28, 0x64, 0x2a, 0x34, 0xbf, 0xde, 0xb7, 0xd0, 0x16, 0x4b, 0x36, 0xd4, 0x7c, 0xa6, 0xc7, 0x9b, - 0x8d, 0x3d, 0xd6, 0xec, 0x45, 0xae, 0xa8, 0x50, 0xb9, 0x07, 0xcd, 0x0b, 0xca, 0x0c, 0x89, 0xee, - 0xe0, 0xed, 0x26, 0x8c, 0xeb, 0x84, 0x45, 0xba, 0xce, 0x3b, 0x5a, 0x49, 0x41, 0x39, 0xeb, 0x36, - 0x5e, 0x36, 0xfa, 0xee, 0xe0, 0xf5, 0x3d, 0xd3, 0xda, 0xec, 0xa8, 0x52, 0xe9, 0xff, 0xe6, 0xc0, - 0xd3, 0xfd, 0x8c, 0x5f, 0xe2, 0x13, 0x63, 0xbf, 0xe5, 0xac, 0x11, 0x6c, 0xcf, 0x69, 0x46, 0xe2, - 0x82, 0x48, 0x3b, 0xe7, 0x17, 0x9b, 0xd0, 0xef, 0x80, 0x08, 0x8e, 0x68, 0x46, 0x4e, 0x88, 0x8c, - 0xb6, 0xe6, 0xe6, 0xd0, 0x7b, 0xa6, 0x9c, 0xa7, 0x8f, 0x5e, 0x07, 0x1a, 0x97, 0x79, 0x66, 0x45, - 0x57, 0x47, 0xff, 0x35, 0x74, 0xaa, 0x20, 0x33, 0x24, 0xcf, 0x95, 0xe4, 0x02, 0xc9, 0xf3, 0xa5, - 0x37, 0xd4, 0xd9, 0xff, 0xcb, 0x81, 0xc7, 0x36, 0x67, 0x9f, 0xb3, 0x39, 0x4d, 0xbd, 0x9f, 0x61, - 0x07, 0x2f, 0xa5, 0x8a, 0xb9, 0x69, 0x6e, 0x79, 0xfd, 0x64, 0xd3, 0x9d, 0x6f, 0xea, 0x3b, 0xaa, - 0x45, 0x1d, 0x7c, 0x53, 0x73, 0x02, 0x1f, 0x24, 0xea, 0x5a, 0xb1, 0x5d, 0xcf, 0x55, 0x83, 0x86, - 0x6e, 0x10, 0xfe, 0x4f, 0x52, 0x46, 0xb5, 0xe8, 0x69, 0x72, 0x3b, 0x3c, 0x7c, 0x04, 0x4d, 0x59, - 0x0a, 0xe2, 0x7f, 0x07, 0x4f, 0xaa, 0x55, 0x13, 0x52, 0x7a, 0xcf, 0xa0, 0xa5, 0x95, 0xa8, 0x30, - 0xa1, 0xa5, 0xd1, 0x0c, 0xbd, 0x82, 0x76, 0x21, 0x51, 0x2e, 0x63, 0x3e, 0x9f, 0x2b, 0xa9, 0xd4, - 0xd8, 0x8d, 0xc8, 0xd5, 0xb1, 0xa9, 0x0e, 0xf9, 0xc7, 0xd0, 0x5e, 0x4d, 0xaa, 0xf0, 0xf6, 0x00, - 0x08, 0x93, 0x54, 0x96, 0xf1, 0x05, 0x59, 0xee, 0xc9, 0x8b, 0x8d, 0xfe, 0x23, 0x65, 0xd4, 0x32, - 0x25, 0x13, 0x52, 0xfa, 0xff, 0x38, 0xd0, 0x50, 0x38, 0xef, 0x72, 0x1b, 0xbe, 0xb6, 0x42, 0xd7, - 0xb5, 0x8f, 0x77, 0xef, 0xb9, 0x4d, 0xa0, 0x46, 0x3f, 0xcc, 0xc8, 0x82, 0x30, 0x69, 0x5c, 0xd1, - 0x3b, 0x55, 0x0f, 0xd5, 0x2a, 0xa8, 0x8c, 0xa3, 0xb7, 0xcb, 0x1a, 0x47, 0x6f, 0x4c, 0x07, 0xea, - 0xf6, 0xd1, 0x6a, 0x8c, 0x6a, 0x51, 0x9d, 0x62, 0xef, 0x7d, 0xfb, 0xa2, 0x28, 0x29, 0x5b, 0xa3, - 0x9a, 0x79, 0x53, 0x86, 0x2d, 0xd8, 0xa2, 0x38, 0xd6, 0x6a, 0xfc, 0xe9, 0x40, 0x2b, 0x22, 0x09, - 0xcf, 0xb1, 0x1a, 0xf8, 0x47, 0xd8, 0xb9, 0x6e, 0x85, 0x35, 0x7f, 0xbb, 0x0f, 0xb5, 0xc1, 0x84, - 0x94, 0xa3, 0x5a, 0xf4, 0x24, 0xb9, 0xa1, 0xf1, 0x14, 0x1e, 0xaf, 0x2d, 0xac, 0x60, 0x8d, 0x7d, - 0xfb, 0x0f, 0xb2, 0xaf, 0xc1, 0x6c, 0xe3, 0xca, 0xef, 0xa5, 0x9f, 0x86, 0xbf, 0x3b, 0xf0, 0x3c, - 0xe1, 0x8b, 0x0d, 0x38, 0x43, 0x38, 0xc8, 0xc4, 0x72, 0xe9, 0x9c, 0x9f, 0xbe, 0xb2, 0x99, 0x29, - 0xcf, 0x10, 0x4b, 0x03, 0x9e, 0xa7, 0x61, 0x4a, 0x98, 0xfe, 0xb2, 0x84, 0xe6, 0x2f, 0x24, 0x68, - 0x71, 0xd7, 0x07, 0xec, 0x4b, 0x9c, 0x89, 0x3f, 0xea, 0xdd, 0x6f, 0x4c, 0xbd, 0x1e, 0x3a, 0x38, - 0xc8, 0x44, 0xf0, 0xfd, 0x60, 0xa8, 0xfe, 0x3e, 0x7b, 0xa4, 0x41, 0x3e, 0xff, 0x37, 0x00, 0x00, - 0xff, 0xff, 0x86, 0xa8, 0xf9, 0x3f, 0x04, 0x07, 0x00, 0x00, + // 909 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0xef, 0x6e, 0x1b, 0x45, + 0x10, 0xcf, 0xd9, 0x56, 0x13, 0x8f, 0x9d, 0xc6, 0xbe, 0x82, 0x64, 0x5c, 0xda, 0xb4, 0x07, 0x6a, + 0x43, 0x03, 0x77, 0xc2, 0x7c, 0xe0, 0x03, 0xa2, 0x48, 0x6e, 0x1a, 0x62, 0x22, 0x35, 0xe9, 0x36, + 0x02, 0x15, 0x3e, 0x9c, 0xd6, 0xb7, 0x7b, 0x97, 0xa5, 0xe7, 0xdb, 0xe5, 0x6e, 0x5d, 0x71, 0x2f, + 0x80, 0x78, 0x16, 0x1e, 0x00, 0x89, 0x4f, 0xbc, 0x0d, 0xe2, 0x31, 0xd0, 0xfe, 0xf1, 0xf9, 0x62, + 0x8c, 0x1b, 0xa4, 0x7e, 0x5b, 0xcf, 0xcd, 0xfc, 0x66, 0xe7, 0x37, 0xbf, 0x99, 0x35, 0x1c, 0x24, + 0x9c, 0x27, 0x29, 0x0d, 0x44, 0xce, 0x5e, 0xe3, 0xa8, 0x0c, 0x48, 0x2a, 0x82, 0xd7, 0xa3, 0x29, + 0x95, 0xf8, 0xd3, 0xa0, 0x90, 0x3c, 0xc7, 0x09, 0xf5, 0x45, 0xce, 0x25, 0x77, 0x87, 0xc6, 0xd3, + 0xb7, 0x9e, 0x3e, 0x49, 0x85, 0x6f, 0x3d, 0x87, 0xef, 0x5b, 0x14, 0x2c, 0x58, 0x80, 0xb3, 0x8c, + 0x4b, 0x2c, 0x19, 0xcf, 0x0a, 0x13, 0x39, 0xdc, 0xaf, 0x72, 0x70, 0xc9, 0xa7, 0xf3, 0x38, 0x90, + 0x6c, 0x46, 0x0b, 0x89, 0x67, 0xc2, 0x38, 0x78, 0x77, 0x61, 0x67, 0x92, 0xc5, 0xfc, 0xa2, 0x14, + 0xd4, 0x75, 0xa1, 0x95, 0xe1, 0x19, 0x1d, 0x38, 0xf7, 0x9c, 0x83, 0x36, 0xd2, 0x67, 0xef, 0x11, + 0x6c, 0x1f, 0x33, 0x9a, 0x92, 0x09, 0x71, 0xf7, 0xa1, 0x13, 0xf1, 0x74, 0x3e, 0xcb, 0xc2, 0x9a, + 0x17, 0x18, 0xd3, 0x33, 0xe5, 0x7b, 0x06, 0x9d, 0x73, 0x9c, 0x4b, 0xa6, 0x2e, 0x30, 0x21, 0xee, + 0x1d, 0x00, 0x91, 0xf3, 0x1f, 0x69, 0x24, 0x43, 0x46, 0x06, 0x0d, 0xed, 0xde, 0xb6, 0x96, 0x09, + 0x71, 0xef, 0x43, 0x57, 0xe1, 0x14, 0x02, 0x47, 0x54, 0x39, 0xb4, 0xb4, 0x43, 0xa7, 0xb2, 0x4d, + 0x88, 0xf7, 0x21, 0xdc, 0x3c, 0x65, 0x19, 0x79, 0xfa, 0xb3, 0xc8, 0x69, 0x51, 0x30, 0x9e, 0xad, + 0xbd, 0xe2, 0x43, 0xe8, 0x9f, 0xe7, 0x5c, 0xd0, 0x5c, 0x96, 0x88, 0xc6, 0x34, 0xa7, 0x59, 0xb4, + 0xac, 0xa5, 0x51, 0x73, 0xfc, 0x0e, 0xe0, 0xdc, 0xa4, 0x57, 0x50, 0x13, 0xd8, 0x11, 0x36, 0x4c, + 0xc3, 0x75, 0x46, 0x9f, 0xf8, 0xff, 0xcd, 0xb3, 0xff, 0xaf, 0x14, 0xa8, 0x0a, 0xf7, 0xfe, 0x72, + 0xa0, 0x77, 0x84, 0x25, 0x56, 0x5d, 0xa3, 0x67, 0x42, 0x37, 0xc0, 0xfd, 0x06, 0xba, 0x62, 0xc1, + 0x86, 0xaa, 0xcf, 0xe4, 0x78, 0xb8, 0x31, 0xc7, 0x92, 0x3d, 0xd4, 0x11, 0x35, 0x2a, 0x1f, 0x43, + 0xeb, 0x15, 0xcb, 0x0c, 0x89, 0x9d, 0xd1, 0xa3, 0x4d, 0x18, 0x57, 0x09, 0x43, 0x3a, 0xce, 0x3d, + 0xae, 0x5a, 0xc1, 0x78, 0x36, 0x68, 0xde, 0x6b, 0x1e, 0x74, 0x46, 0x0f, 0xde, 0x50, 0xad, 0xf5, + 0x46, 0xb5, 0x48, 0xef, 0x17, 0x07, 0x6e, 0x3d, 0x49, 0xf9, 0x9c, 0xbc, 0x30, 0xfa, 0x5c, 0xd4, + 0x8a, 0x60, 0x27, 0x66, 0x29, 0x0d, 0x0b, 0x2a, 0x6d, 0x9d, 0x9f, 0x6f, 0x42, 0x5f, 0x03, 0xe1, + 0x1f, 0xb3, 0x94, 0xbe, 0xa0, 0x12, 0x6d, 0xc7, 0xe6, 0x30, 0xbc, 0xad, 0x94, 0xa7, 0x8f, 0x6e, + 0x0f, 0x9a, 0xf3, 0x3c, 0xb5, 0x4d, 0x57, 0x47, 0xef, 0x01, 0xf4, 0xea, 0x20, 0xe7, 0x58, 0x5e, + 0xaa, 0x96, 0x0b, 0x2c, 0x2f, 0x17, 0xda, 0x50, 0x67, 0xef, 0x0f, 0x07, 0xf6, 0xc6, 0x2c, 0x79, + 0x3e, 0xa7, 0x79, 0xb9, 0xbc, 0xec, 0x9e, 0xc4, 0xd3, 0x94, 0x86, 0xf9, 0xa2, 0x95, 0xf6, 0xce, + 0x1f, 0x6d, 0xba, 0xf3, 0x02, 0xe5, 0x42, 0x85, 0xa2, 0x9b, 0x1a, 0x61, 0x29, 0x37, 0x04, 0x2e, + 0x23, 0x34, 0x93, 0x2c, 0x2e, 0x59, 0x96, 0x84, 0xb1, 0x1a, 0x99, 0x62, 0xd0, 0xd0, 0x44, 0x7f, + 0xb0, 0x09, 0xd6, 0x0e, 0x17, 0xea, 0xd7, 0xc2, 0xb5, 0xad, 0xf0, 0x7e, 0x6f, 0xc0, 0xae, 0xad, + 0xef, 0x09, 0xcf, 0x62, 0x96, 0xb8, 0x3f, 0x40, 0x9f, 0x2c, 0x64, 0x16, 0x72, 0x53, 0x8e, 0xd5, + 0xc4, 0xc7, 0x9b, 0x92, 0xac, 0x6a, 0xf3, 0x64, 0x0b, 0xf5, 0xc8, 0xaa, 0x5e, 0x29, 0xbc, 0x1b, + 0x29, 0x4a, 0x43, 0xbb, 0x7b, 0xaa, 0x04, 0x4d, 0x9d, 0x20, 0xf8, 0x9f, 0x0d, 0x3d, 0xd9, 0x42, + 0xb7, 0xa2, 0x35, 0x52, 0x79, 0x09, 0xfd, 0x29, 0x4b, 0xc2, 0x9f, 0x14, 0x97, 0x55, 0x8a, 0x96, + 0x4e, 0x71, 0x78, 0x1d, 0xfe, 0x97, 0xf0, 0x7b, 0xd3, 0xab, 0xa6, 0xf1, 0x0d, 0x68, 0xc9, 0x52, + 0x50, 0xef, 0x39, 0xec, 0xd5, 0x2f, 0x74, 0x4a, 0x4b, 0xf7, 0x36, 0xb4, 0xb5, 0x40, 0x6b, 0x02, + 0xd1, 0x8a, 0xd5, 0xc2, 0xb9, 0x0f, 0xdd, 0x42, 0xe2, 0x5c, 0x86, 0x3c, 0x8e, 0x95, 0x82, 0x15, + 0xa3, 0x4d, 0xd4, 0xd1, 0xb6, 0x33, 0x6d, 0xf2, 0x9e, 0x41, 0xb7, 0x22, 0x51, 0xe1, 0x3d, 0x06, + 0x50, 0xed, 0x92, 0x65, 0xf8, 0x8a, 0x2e, 0xd6, 0xc7, 0xfe, 0xc6, 0xb1, 0xa4, 0x25, 0x6a, 0x9b, + 0x90, 0x53, 0x5a, 0x7a, 0x7f, 0x3b, 0xd0, 0x54, 0x38, 0x6f, 0x73, 0x49, 0x7c, 0x65, 0xf5, 0x6f, + 0x54, 0x77, 0xf8, 0x86, 0xdb, 0xf8, 0xaa, 0xf4, 0xa7, 0x29, 0x9d, 0xd1, 0x4c, 0x9a, 0x61, 0x19, + 0x5e, 0xa8, 0xfd, 0x5d, 0x19, 0xd5, 0x3c, 0xe9, 0xa5, 0x63, 0xe7, 0x49, 0x2f, 0x92, 0x1e, 0x34, + 0xec, 0x2e, 0x6f, 0x9e, 0x6c, 0xa1, 0x06, 0x23, 0xee, 0x3b, 0x76, 0xd1, 0x2a, 0x95, 0xb4, 0x4f, + 0xb6, 0xcc, 0xaa, 0x1d, 0xb7, 0x61, 0x9b, 0x91, 0x50, 0x77, 0xe3, 0x4f, 0x07, 0xda, 0x88, 0x46, + 0x3c, 0x27, 0xaa, 0xe0, 0x97, 0xd0, 0xbf, 0xaa, 0xb2, 0x25, 0x7f, 0x87, 0xd7, 0x55, 0xd8, 0x29, + 0x2d, 0x55, 0xfb, 0xa3, 0x95, 0x1e, 0x9f, 0xc1, 0xee, 0x72, 0x3a, 0x14, 0xac, 0x99, 0x8c, 0x83, + 0x6b, 0x4d, 0x86, 0xc1, 0xec, 0x92, 0xda, 0xef, 0x4a, 0x4f, 0x97, 0xb0, 0x7b, 0x65, 0xfa, 0x57, + 0x5e, 0x36, 0x67, 0xf5, 0x65, 0xbb, 0x03, 0xa0, 0x71, 0x68, 0xfd, 0xe1, 0xb3, 0x96, 0x09, 0x71, + 0xdf, 0x83, 0x1d, 0xb3, 0x7f, 0x18, 0x31, 0xac, 0xa1, 0x6d, 0xfd, 0x7b, 0x42, 0xc6, 0xbf, 0x3a, + 0x70, 0x37, 0xe2, 0xb3, 0x0d, 0x37, 0x1e, 0xc3, 0x51, 0x2a, 0x16, 0x5b, 0xcf, 0xf9, 0xfe, 0x4b, + 0xeb, 0x99, 0xf0, 0x14, 0x67, 0x89, 0xcf, 0xf3, 0x24, 0x48, 0x68, 0xa6, 0x9f, 0xf6, 0xc0, 0x7c, + 0xc2, 0x82, 0x15, 0xeb, 0xfe, 0x62, 0x7c, 0x41, 0x52, 0xf1, 0x5b, 0x63, 0xf0, 0xb5, 0x89, 0xd7, + 0xf4, 0xfa, 0x47, 0xa9, 0xf0, 0xbf, 0x1d, 0x8d, 0xd5, 0xe7, 0xe9, 0x0d, 0x0d, 0xf2, 0xd9, 0x3f, + 0x01, 0x00, 0x00, 0xff, 0xff, 0x8c, 0xe7, 0xe9, 0x4f, 0xa6, 0x08, 0x00, 0x00, } diff --git a/vendor/google.golang.org/genproto/googleapis/pubsub/v1/pubsub.pb.go b/vendor/google.golang.org/genproto/googleapis/pubsub/v1/pubsub.pb.go index 519c9434..ab4768df 100644 --- a/vendor/google.golang.org/genproto/googleapis/pubsub/v1/pubsub.pb.go +++ b/vendor/google.golang.org/genproto/googleapis/pubsub/v1/pubsub.pb.go @@ -11,6 +11,7 @@ It has these top-level messages: Topic PubsubMessage GetTopicRequest + UpdateTopicRequest PublishRequest PublishResponse ListTopicsRequest @@ -34,6 +35,7 @@ It has these top-level messages: StreamingPullRequest StreamingPullResponse CreateSnapshotRequest + UpdateSnapshotRequest Snapshot ListSnapshotsRequest ListSnapshotsResponse @@ -77,6 +79,8 @@ type Topic struct { // signs (`%`). It must be between 3 and 255 characters in length, and it // must not start with `"goog"`. Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` + // User labels. + Labels map[string]string `protobuf:"bytes,2,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` } func (m *Topic) Reset() { *m = Topic{} } @@ -91,6 +95,13 @@ func (m *Topic) GetName() string { return "" } +func (m *Topic) GetLabels() map[string]string { + if m != nil { + return m.Labels + } + return nil +} + // A message data and its attributes. The message payload must not be empty; // it must contain either a non-empty data field, or at least one attribute. type PubsubMessage struct { @@ -161,6 +172,34 @@ func (m *GetTopicRequest) GetTopic() string { return "" } +// Request for the UpdateTopic method. +type UpdateTopicRequest struct { + // The topic to update. + Topic *Topic `protobuf:"bytes,1,opt,name=topic" json:"topic,omitempty"` + // Indicates which fields in the provided topic to update. + // Must be specified and non-empty. + UpdateMask *google_protobuf3.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask" json:"update_mask,omitempty"` +} + +func (m *UpdateTopicRequest) Reset() { *m = UpdateTopicRequest{} } +func (m *UpdateTopicRequest) String() string { return proto.CompactTextString(m) } +func (*UpdateTopicRequest) ProtoMessage() {} +func (*UpdateTopicRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } + +func (m *UpdateTopicRequest) GetTopic() *Topic { + if m != nil { + return m.Topic + } + return nil +} + +func (m *UpdateTopicRequest) GetUpdateMask() *google_protobuf3.FieldMask { + if m != nil { + return m.UpdateMask + } + return nil +} + // Request for the Publish method. type PublishRequest struct { // The messages in the request will be published on this topic. @@ -173,7 +212,7 @@ type PublishRequest struct { func (m *PublishRequest) Reset() { *m = PublishRequest{} } func (m *PublishRequest) String() string { return proto.CompactTextString(m) } func (*PublishRequest) ProtoMessage() {} -func (*PublishRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } +func (*PublishRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } func (m *PublishRequest) GetTopic() string { if m != nil { @@ -200,7 +239,7 @@ type PublishResponse struct { func (m *PublishResponse) Reset() { *m = PublishResponse{} } func (m *PublishResponse) String() string { return proto.CompactTextString(m) } func (*PublishResponse) ProtoMessage() {} -func (*PublishResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } +func (*PublishResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } func (m *PublishResponse) GetMessageIds() []string { if m != nil { @@ -225,7 +264,7 @@ type ListTopicsRequest struct { func (m *ListTopicsRequest) Reset() { *m = ListTopicsRequest{} } func (m *ListTopicsRequest) String() string { return proto.CompactTextString(m) } func (*ListTopicsRequest) ProtoMessage() {} -func (*ListTopicsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } +func (*ListTopicsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } func (m *ListTopicsRequest) GetProject() string { if m != nil { @@ -260,7 +299,7 @@ type ListTopicsResponse struct { func (m *ListTopicsResponse) Reset() { *m = ListTopicsResponse{} } func (m *ListTopicsResponse) String() string { return proto.CompactTextString(m) } func (*ListTopicsResponse) ProtoMessage() {} -func (*ListTopicsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } +func (*ListTopicsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } func (m *ListTopicsResponse) GetTopics() []*Topic { if m != nil { @@ -292,7 +331,7 @@ type ListTopicSubscriptionsRequest struct { func (m *ListTopicSubscriptionsRequest) Reset() { *m = ListTopicSubscriptionsRequest{} } func (m *ListTopicSubscriptionsRequest) String() string { return proto.CompactTextString(m) } func (*ListTopicSubscriptionsRequest) ProtoMessage() {} -func (*ListTopicSubscriptionsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } +func (*ListTopicSubscriptionsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } func (m *ListTopicSubscriptionsRequest) GetTopic() string { if m != nil { @@ -328,7 +367,7 @@ type ListTopicSubscriptionsResponse struct { func (m *ListTopicSubscriptionsResponse) Reset() { *m = ListTopicSubscriptionsResponse{} } func (m *ListTopicSubscriptionsResponse) String() string { return proto.CompactTextString(m) } func (*ListTopicSubscriptionsResponse) ProtoMessage() {} -func (*ListTopicSubscriptionsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } +func (*ListTopicSubscriptionsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } func (m *ListTopicSubscriptionsResponse) GetSubscriptions() []string { if m != nil { @@ -354,7 +393,7 @@ type DeleteTopicRequest struct { func (m *DeleteTopicRequest) Reset() { *m = DeleteTopicRequest{} } func (m *DeleteTopicRequest) String() string { return proto.CompactTextString(m) } func (*DeleteTopicRequest) ProtoMessage() {} -func (*DeleteTopicRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } +func (*DeleteTopicRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } func (m *DeleteTopicRequest) GetTopic() string { if m != nil { @@ -413,12 +452,14 @@ type Subscription struct { // can be done. Defaults to 7 days. Cannot be more than 7 days or less than 10 // minutes. MessageRetentionDuration *google_protobuf1.Duration `protobuf:"bytes,8,opt,name=message_retention_duration,json=messageRetentionDuration" json:"message_retention_duration,omitempty"` + // User labels. + Labels map[string]string `protobuf:"bytes,9,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` } func (m *Subscription) Reset() { *m = Subscription{} } func (m *Subscription) String() string { return proto.CompactTextString(m) } func (*Subscription) ProtoMessage() {} -func (*Subscription) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } +func (*Subscription) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } func (m *Subscription) GetName() string { if m != nil { @@ -462,6 +503,13 @@ func (m *Subscription) GetMessageRetentionDuration() *google_protobuf1.Duration return nil } +func (m *Subscription) GetLabels() map[string]string { + if m != nil { + return m.Labels + } + return nil +} + // Configuration for a push delivery endpoint. type PushConfig struct { // A URL locating the endpoint to which messages should be pushed. @@ -494,7 +542,7 @@ type PushConfig struct { func (m *PushConfig) Reset() { *m = PushConfig{} } func (m *PushConfig) String() string { return proto.CompactTextString(m) } func (*PushConfig) ProtoMessage() {} -func (*PushConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } +func (*PushConfig) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } func (m *PushConfig) GetPushEndpoint() string { if m != nil { @@ -521,7 +569,7 @@ type ReceivedMessage struct { func (m *ReceivedMessage) Reset() { *m = ReceivedMessage{} } func (m *ReceivedMessage) String() string { return proto.CompactTextString(m) } func (*ReceivedMessage) ProtoMessage() {} -func (*ReceivedMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } +func (*ReceivedMessage) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } func (m *ReceivedMessage) GetAckId() string { if m != nil { @@ -547,7 +595,7 @@ type GetSubscriptionRequest struct { func (m *GetSubscriptionRequest) Reset() { *m = GetSubscriptionRequest{} } func (m *GetSubscriptionRequest) String() string { return proto.CompactTextString(m) } func (*GetSubscriptionRequest) ProtoMessage() {} -func (*GetSubscriptionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } +func (*GetSubscriptionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} } func (m *GetSubscriptionRequest) GetSubscription() string { if m != nil { @@ -568,7 +616,7 @@ type UpdateSubscriptionRequest struct { func (m *UpdateSubscriptionRequest) Reset() { *m = UpdateSubscriptionRequest{} } func (m *UpdateSubscriptionRequest) String() string { return proto.CompactTextString(m) } func (*UpdateSubscriptionRequest) ProtoMessage() {} -func (*UpdateSubscriptionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} } +func (*UpdateSubscriptionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } func (m *UpdateSubscriptionRequest) GetSubscription() *Subscription { if m != nil { @@ -600,7 +648,7 @@ type ListSubscriptionsRequest struct { func (m *ListSubscriptionsRequest) Reset() { *m = ListSubscriptionsRequest{} } func (m *ListSubscriptionsRequest) String() string { return proto.CompactTextString(m) } func (*ListSubscriptionsRequest) ProtoMessage() {} -func (*ListSubscriptionsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } +func (*ListSubscriptionsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } func (m *ListSubscriptionsRequest) GetProject() string { if m != nil { @@ -636,7 +684,7 @@ type ListSubscriptionsResponse struct { func (m *ListSubscriptionsResponse) Reset() { *m = ListSubscriptionsResponse{} } func (m *ListSubscriptionsResponse) String() string { return proto.CompactTextString(m) } func (*ListSubscriptionsResponse) ProtoMessage() {} -func (*ListSubscriptionsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } +func (*ListSubscriptionsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } func (m *ListSubscriptionsResponse) GetSubscriptions() []*Subscription { if m != nil { @@ -662,7 +710,7 @@ type DeleteSubscriptionRequest struct { func (m *DeleteSubscriptionRequest) Reset() { *m = DeleteSubscriptionRequest{} } func (m *DeleteSubscriptionRequest) String() string { return proto.CompactTextString(m) } func (*DeleteSubscriptionRequest) ProtoMessage() {} -func (*DeleteSubscriptionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } +func (*DeleteSubscriptionRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } func (m *DeleteSubscriptionRequest) GetSubscription() string { if m != nil { @@ -688,7 +736,7 @@ type ModifyPushConfigRequest struct { func (m *ModifyPushConfigRequest) Reset() { *m = ModifyPushConfigRequest{} } func (m *ModifyPushConfigRequest) String() string { return proto.CompactTextString(m) } func (*ModifyPushConfigRequest) ProtoMessage() {} -func (*ModifyPushConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } +func (*ModifyPushConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } func (m *ModifyPushConfigRequest) GetSubscription() string { if m != nil { @@ -724,7 +772,7 @@ type PullRequest struct { func (m *PullRequest) Reset() { *m = PullRequest{} } func (m *PullRequest) String() string { return proto.CompactTextString(m) } func (*PullRequest) ProtoMessage() {} -func (*PullRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } +func (*PullRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} } func (m *PullRequest) GetSubscription() string { if m != nil { @@ -759,7 +807,7 @@ type PullResponse struct { func (m *PullResponse) Reset() { *m = PullResponse{} } func (m *PullResponse) String() string { return proto.CompactTextString(m) } func (*PullResponse) ProtoMessage() {} -func (*PullResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} } +func (*PullResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} } func (m *PullResponse) GetReceivedMessages() []*ReceivedMessage { if m != nil { @@ -788,7 +836,7 @@ type ModifyAckDeadlineRequest struct { func (m *ModifyAckDeadlineRequest) Reset() { *m = ModifyAckDeadlineRequest{} } func (m *ModifyAckDeadlineRequest) String() string { return proto.CompactTextString(m) } func (*ModifyAckDeadlineRequest) ProtoMessage() {} -func (*ModifyAckDeadlineRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} } +func (*ModifyAckDeadlineRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} } func (m *ModifyAckDeadlineRequest) GetSubscription() string { if m != nil { @@ -824,7 +872,7 @@ type AcknowledgeRequest struct { func (m *AcknowledgeRequest) Reset() { *m = AcknowledgeRequest{} } func (m *AcknowledgeRequest) String() string { return proto.CompactTextString(m) } func (*AcknowledgeRequest) ProtoMessage() {} -func (*AcknowledgeRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} } +func (*AcknowledgeRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} } func (m *AcknowledgeRequest) GetSubscription() string { if m != nil { @@ -883,7 +931,7 @@ type StreamingPullRequest struct { func (m *StreamingPullRequest) Reset() { *m = StreamingPullRequest{} } func (m *StreamingPullRequest) String() string { return proto.CompactTextString(m) } func (*StreamingPullRequest) ProtoMessage() {} -func (*StreamingPullRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} } +func (*StreamingPullRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} } func (m *StreamingPullRequest) GetSubscription() string { if m != nil { @@ -930,7 +978,7 @@ type StreamingPullResponse struct { func (m *StreamingPullResponse) Reset() { *m = StreamingPullResponse{} } func (m *StreamingPullResponse) String() string { return proto.CompactTextString(m) } func (*StreamingPullResponse) ProtoMessage() {} -func (*StreamingPullResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} } +func (*StreamingPullResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} } func (m *StreamingPullResponse) GetReceivedMessages() []*ReceivedMessage { if m != nil { @@ -962,7 +1010,7 @@ type CreateSnapshotRequest struct { func (m *CreateSnapshotRequest) Reset() { *m = CreateSnapshotRequest{} } func (m *CreateSnapshotRequest) String() string { return proto.CompactTextString(m) } func (*CreateSnapshotRequest) ProtoMessage() {} -func (*CreateSnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} } +func (*CreateSnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} } func (m *CreateSnapshotRequest) GetName() string { if m != nil { @@ -978,6 +1026,34 @@ func (m *CreateSnapshotRequest) GetSubscription() string { return "" } +// Request for the UpdateSnapshot method. +type UpdateSnapshotRequest struct { + // The updated snpashot object. + Snapshot *Snapshot `protobuf:"bytes,1,opt,name=snapshot" json:"snapshot,omitempty"` + // Indicates which fields in the provided snapshot to update. + // Must be specified and non-empty. + UpdateMask *google_protobuf3.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask" json:"update_mask,omitempty"` +} + +func (m *UpdateSnapshotRequest) Reset() { *m = UpdateSnapshotRequest{} } +func (m *UpdateSnapshotRequest) String() string { return proto.CompactTextString(m) } +func (*UpdateSnapshotRequest) ProtoMessage() {} +func (*UpdateSnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} } + +func (m *UpdateSnapshotRequest) GetSnapshot() *Snapshot { + if m != nil { + return m.Snapshot + } + return nil +} + +func (m *UpdateSnapshotRequest) GetUpdateMask() *google_protobuf3.FieldMask { + if m != nil { + return m.UpdateMask + } + return nil +} + // A snapshot resource. type Snapshot struct { // The name of the snapshot. @@ -994,12 +1070,14 @@ type Snapshot struct { // will always capture this 3-day-old backlog as long as the snapshot // exists -- will expire in 4 days. ExpireTime *google_protobuf4.Timestamp `protobuf:"bytes,3,opt,name=expire_time,json=expireTime" json:"expire_time,omitempty"` + // User labels. + Labels map[string]string `protobuf:"bytes,4,rep,name=labels" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` } func (m *Snapshot) Reset() { *m = Snapshot{} } func (m *Snapshot) String() string { return proto.CompactTextString(m) } func (*Snapshot) ProtoMessage() {} -func (*Snapshot) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} } +func (*Snapshot) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} } func (m *Snapshot) GetName() string { if m != nil { @@ -1022,6 +1100,13 @@ func (m *Snapshot) GetExpireTime() *google_protobuf4.Timestamp { return nil } +func (m *Snapshot) GetLabels() map[string]string { + if m != nil { + return m.Labels + } + return nil +} + // Request for the `ListSnapshots` method. type ListSnapshotsRequest struct { // The name of the cloud project that snapshots belong to. @@ -1038,7 +1123,7 @@ type ListSnapshotsRequest struct { func (m *ListSnapshotsRequest) Reset() { *m = ListSnapshotsRequest{} } func (m *ListSnapshotsRequest) String() string { return proto.CompactTextString(m) } func (*ListSnapshotsRequest) ProtoMessage() {} -func (*ListSnapshotsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} } +func (*ListSnapshotsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} } func (m *ListSnapshotsRequest) GetProject() string { if m != nil { @@ -1073,7 +1158,7 @@ type ListSnapshotsResponse struct { func (m *ListSnapshotsResponse) Reset() { *m = ListSnapshotsResponse{} } func (m *ListSnapshotsResponse) String() string { return proto.CompactTextString(m) } func (*ListSnapshotsResponse) ProtoMessage() {} -func (*ListSnapshotsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} } +func (*ListSnapshotsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} } func (m *ListSnapshotsResponse) GetSnapshots() []*Snapshot { if m != nil { @@ -1099,7 +1184,7 @@ type DeleteSnapshotRequest struct { func (m *DeleteSnapshotRequest) Reset() { *m = DeleteSnapshotRequest{} } func (m *DeleteSnapshotRequest) String() string { return proto.CompactTextString(m) } func (*DeleteSnapshotRequest) ProtoMessage() {} -func (*DeleteSnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} } +func (*DeleteSnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} } func (m *DeleteSnapshotRequest) GetSnapshot() string { if m != nil { @@ -1121,7 +1206,7 @@ type SeekRequest struct { func (m *SeekRequest) Reset() { *m = SeekRequest{} } func (m *SeekRequest) String() string { return proto.CompactTextString(m) } func (*SeekRequest) ProtoMessage() {} -func (*SeekRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} } +func (*SeekRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{32} } type isSeekRequest_Target interface { isSeekRequest_Target() @@ -1241,12 +1326,13 @@ type SeekResponse struct { func (m *SeekResponse) Reset() { *m = SeekResponse{} } func (m *SeekResponse) String() string { return proto.CompactTextString(m) } func (*SeekResponse) ProtoMessage() {} -func (*SeekResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} } +func (*SeekResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{33} } func init() { proto.RegisterType((*Topic)(nil), "google.pubsub.v1.Topic") proto.RegisterType((*PubsubMessage)(nil), "google.pubsub.v1.PubsubMessage") proto.RegisterType((*GetTopicRequest)(nil), "google.pubsub.v1.GetTopicRequest") + proto.RegisterType((*UpdateTopicRequest)(nil), "google.pubsub.v1.UpdateTopicRequest") proto.RegisterType((*PublishRequest)(nil), "google.pubsub.v1.PublishRequest") proto.RegisterType((*PublishResponse)(nil), "google.pubsub.v1.PublishResponse") proto.RegisterType((*ListTopicsRequest)(nil), "google.pubsub.v1.ListTopicsRequest") @@ -1270,6 +1356,7 @@ func init() { proto.RegisterType((*StreamingPullRequest)(nil), "google.pubsub.v1.StreamingPullRequest") proto.RegisterType((*StreamingPullResponse)(nil), "google.pubsub.v1.StreamingPullResponse") proto.RegisterType((*CreateSnapshotRequest)(nil), "google.pubsub.v1.CreateSnapshotRequest") + proto.RegisterType((*UpdateSnapshotRequest)(nil), "google.pubsub.v1.UpdateSnapshotRequest") proto.RegisterType((*Snapshot)(nil), "google.pubsub.v1.Snapshot") proto.RegisterType((*ListSnapshotsRequest)(nil), "google.pubsub.v1.ListSnapshotsRequest") proto.RegisterType((*ListSnapshotsResponse)(nil), "google.pubsub.v1.ListSnapshotsResponse") @@ -1304,6 +1391,10 @@ type SubscriberClient interface { GetSubscription(ctx context.Context, in *GetSubscriptionRequest, opts ...grpc.CallOption) (*Subscription, error) // Updates an existing subscription. Note that certain properties of a // subscription, such as its topic, are not modifiable. + // NOTE: The style guide requires body: "subscription" instead of body: "*". + // Keeping the latter for internal consistency in V1, however it should be + // corrected in V2. See + // https://cloud.google.com/apis/design/standard_methods#update for details. UpdateSubscription(ctx context.Context, in *UpdateSubscriptionRequest, opts ...grpc.CallOption) (*Subscription, error) // Lists matching subscriptions. ListSubscriptions(ctx context.Context, in *ListSubscriptionsRequest, opts ...grpc.CallOption) (*ListSubscriptionsResponse, error) @@ -1365,6 +1456,13 @@ type SubscriberClient interface { // The generated name is populated in the returned Snapshot object. // Note that for REST API requests, you must specify a name in the request. CreateSnapshot(ctx context.Context, in *CreateSnapshotRequest, opts ...grpc.CallOption) (*Snapshot, error) + // Updates an existing snapshot. Note that certain properties of a snapshot + // are not modifiable. + // NOTE: The style guide requires body: "snapshot" instead of body: "*". + // Keeping the latter for internal consistency in V1, however it should be + // corrected in V2. See + // https://cloud.google.com/apis/design/standard_methods#update for details. + UpdateSnapshot(ctx context.Context, in *UpdateSnapshotRequest, opts ...grpc.CallOption) (*Snapshot, error) // Removes an existing snapshot. All messages retained in the snapshot // are immediately dropped. After a snapshot is deleted, a new one may be // created with the same name, but the new one has no association with the old @@ -1513,6 +1611,15 @@ func (c *subscriberClient) CreateSnapshot(ctx context.Context, in *CreateSnapsho return out, nil } +func (c *subscriberClient) UpdateSnapshot(ctx context.Context, in *UpdateSnapshotRequest, opts ...grpc.CallOption) (*Snapshot, error) { + out := new(Snapshot) + err := grpc.Invoke(ctx, "/google.pubsub.v1.Subscriber/UpdateSnapshot", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *subscriberClient) DeleteSnapshot(ctx context.Context, in *DeleteSnapshotRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) { out := new(google_protobuf2.Empty) err := grpc.Invoke(ctx, "/google.pubsub.v1.Subscriber/DeleteSnapshot", in, out, c.cc, opts...) @@ -1549,6 +1656,10 @@ type SubscriberServer interface { GetSubscription(context.Context, *GetSubscriptionRequest) (*Subscription, error) // Updates an existing subscription. Note that certain properties of a // subscription, such as its topic, are not modifiable. + // NOTE: The style guide requires body: "subscription" instead of body: "*". + // Keeping the latter for internal consistency in V1, however it should be + // corrected in V2. See + // https://cloud.google.com/apis/design/standard_methods#update for details. UpdateSubscription(context.Context, *UpdateSubscriptionRequest) (*Subscription, error) // Lists matching subscriptions. ListSubscriptions(context.Context, *ListSubscriptionsRequest) (*ListSubscriptionsResponse, error) @@ -1610,6 +1721,13 @@ type SubscriberServer interface { // The generated name is populated in the returned Snapshot object. // Note that for REST API requests, you must specify a name in the request. CreateSnapshot(context.Context, *CreateSnapshotRequest) (*Snapshot, error) + // Updates an existing snapshot. Note that certain properties of a snapshot + // are not modifiable. + // NOTE: The style guide requires body: "snapshot" instead of body: "*". + // Keeping the latter for internal consistency in V1, however it should be + // corrected in V2. See + // https://cloud.google.com/apis/design/standard_methods#update for details. + UpdateSnapshot(context.Context, *UpdateSnapshotRequest) (*Snapshot, error) // Removes an existing snapshot. All messages retained in the snapshot // are immediately dropped. After a snapshot is deleted, a new one may be // created with the same name, but the new one has no association with the old @@ -1848,6 +1966,24 @@ func _Subscriber_CreateSnapshot_Handler(srv interface{}, ctx context.Context, de return interceptor(ctx, in, info, handler) } +func _Subscriber_UpdateSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateSnapshotRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SubscriberServer).UpdateSnapshot(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.pubsub.v1.Subscriber/UpdateSnapshot", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SubscriberServer).UpdateSnapshot(ctx, req.(*UpdateSnapshotRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Subscriber_DeleteSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(DeleteSnapshotRequest) if err := dec(in); err != nil { @@ -1932,6 +2068,10 @@ var _Subscriber_serviceDesc = grpc.ServiceDesc{ MethodName: "CreateSnapshot", Handler: _Subscriber_CreateSnapshot_Handler, }, + { + MethodName: "UpdateSnapshot", + Handler: _Subscriber_UpdateSnapshot_Handler, + }, { MethodName: "DeleteSnapshot", Handler: _Subscriber_DeleteSnapshot_Handler, @@ -1957,6 +2097,13 @@ var _Subscriber_serviceDesc = grpc.ServiceDesc{ type PublisherClient interface { // Creates the given topic with the given name. CreateTopic(ctx context.Context, in *Topic, opts ...grpc.CallOption) (*Topic, error) + // Updates an existing topic. Note that certain properties of a topic are not + // modifiable. Options settings follow the style guide: + // NOTE: The style guide requires body: "topic" instead of body: "*". + // Keeping the latter for internal consistency in V1, however it should be + // corrected in V2. See + // https://cloud.google.com/apis/design/standard_methods#update for details. + UpdateTopic(ctx context.Context, in *UpdateTopicRequest, opts ...grpc.CallOption) (*Topic, error) // Adds one or more messages to the topic. Returns `NOT_FOUND` if the topic // does not exist. The message payload must not be empty; it must contain // either a non-empty data field, or at least one attribute. @@ -1992,6 +2139,15 @@ func (c *publisherClient) CreateTopic(ctx context.Context, in *Topic, opts ...gr return out, nil } +func (c *publisherClient) UpdateTopic(ctx context.Context, in *UpdateTopicRequest, opts ...grpc.CallOption) (*Topic, error) { + out := new(Topic) + err := grpc.Invoke(ctx, "/google.pubsub.v1.Publisher/UpdateTopic", in, out, c.cc, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *publisherClient) Publish(ctx context.Context, in *PublishRequest, opts ...grpc.CallOption) (*PublishResponse, error) { out := new(PublishResponse) err := grpc.Invoke(ctx, "/google.pubsub.v1.Publisher/Publish", in, out, c.cc, opts...) @@ -2042,6 +2198,13 @@ func (c *publisherClient) DeleteTopic(ctx context.Context, in *DeleteTopicReques type PublisherServer interface { // Creates the given topic with the given name. CreateTopic(context.Context, *Topic) (*Topic, error) + // Updates an existing topic. Note that certain properties of a topic are not + // modifiable. Options settings follow the style guide: + // NOTE: The style guide requires body: "topic" instead of body: "*". + // Keeping the latter for internal consistency in V1, however it should be + // corrected in V2. See + // https://cloud.google.com/apis/design/standard_methods#update for details. + UpdateTopic(context.Context, *UpdateTopicRequest) (*Topic, error) // Adds one or more messages to the topic. Returns `NOT_FOUND` if the topic // does not exist. The message payload must not be empty; it must contain // either a non-empty data field, or at least one attribute. @@ -2082,6 +2245,24 @@ func _Publisher_CreateTopic_Handler(srv interface{}, ctx context.Context, dec fu return interceptor(ctx, in, info, handler) } +func _Publisher_UpdateTopic_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateTopicRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(PublisherServer).UpdateTopic(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/google.pubsub.v1.Publisher/UpdateTopic", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(PublisherServer).UpdateTopic(ctx, req.(*UpdateTopicRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Publisher_Publish_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(PublishRequest) if err := dec(in); err != nil { @@ -2180,6 +2361,10 @@ var _Publisher_serviceDesc = grpc.ServiceDesc{ MethodName: "CreateTopic", Handler: _Publisher_CreateTopic_Handler, }, + { + MethodName: "UpdateTopic", + Handler: _Publisher_UpdateTopic_Handler, + }, { MethodName: "Publish", Handler: _Publisher_Publish_Handler, @@ -2208,122 +2393,131 @@ var _Publisher_serviceDesc = grpc.ServiceDesc{ func init() { proto.RegisterFile("google/pubsub/v1/pubsub.proto", fileDescriptor0) } var fileDescriptor0 = []byte{ - // 1867 bytes of a gzipped FileDescriptorProto + // 2011 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x59, 0xcb, 0x73, 0xdb, 0xc6, - 0x19, 0x0f, 0x48, 0x3d, 0xa8, 0x0f, 0x94, 0x65, 0x6f, 0x25, 0x9b, 0x86, 0x5f, 0x12, 0xec, 0x5a, - 0x0c, 0x63, 0x93, 0x32, 0x33, 0x49, 0x13, 0xbb, 0x4a, 0x46, 0x96, 0x5c, 0x47, 0x9d, 0xb8, 0x51, - 0x21, 0xb7, 0x9d, 0xe9, 0xa1, 0x1c, 0x90, 0x58, 0x51, 0x08, 0x89, 0x87, 0xb1, 0x80, 0x2a, 0xa6, - 0xcd, 0x4c, 0x9b, 0x74, 0x3a, 0xd3, 0x69, 0x0f, 0x4d, 0x7b, 0x6c, 0x0e, 0x9d, 0xe9, 0xad, 0xc7, - 0x1e, 0x7a, 0xec, 0x3f, 0xd1, 0x7f, 0xa1, 0x87, 0xfe, 0x09, 0x3d, 0x76, 0xf6, 0x01, 0x12, 0x20, - 0x16, 0x7c, 0x28, 0xe3, 0x1b, 0xb8, 0xfb, 0xed, 0xfe, 0x7e, 0xdf, 0xfb, 0xd3, 0x0a, 0x6e, 0x75, - 0x3d, 0xaf, 0xdb, 0xc7, 0x0d, 0x3f, 0x6a, 0x93, 0xa8, 0xdd, 0x38, 0x7b, 0x24, 0xbe, 0xea, 0x7e, - 0xe0, 0x85, 0x1e, 0xba, 0xcc, 0xb7, 0xeb, 0x62, 0xf1, 0xec, 0x91, 0x76, 0x53, 0x1c, 0x30, 0x7d, - 0xbb, 0x61, 0xba, 0xae, 0x17, 0x9a, 0xa1, 0xed, 0xb9, 0x84, 0xcb, 0x6b, 0xb7, 0xe3, 0xeb, 0xe8, - 0xaf, 0x76, 0x74, 0xd2, 0xb0, 0xa2, 0x80, 0x09, 0x88, 0xfd, 0x1b, 0xe3, 0xfb, 0xd8, 0xf1, 0xc3, - 0x81, 0xd8, 0xdc, 0x1c, 0xdf, 0x3c, 0xb1, 0x71, 0xdf, 0x6a, 0x39, 0x26, 0xe9, 0x09, 0x89, 0x3b, - 0xe3, 0x12, 0xa1, 0xed, 0x60, 0x12, 0x9a, 0x8e, 0xcf, 0x05, 0xf4, 0x1b, 0xb0, 0xf8, 0xd2, 0xf3, - 0xed, 0x0e, 0x42, 0xb0, 0xe0, 0x9a, 0x0e, 0xae, 0x28, 0x9b, 0x4a, 0x75, 0xc5, 0x60, 0xdf, 0xfa, - 0x57, 0x05, 0x58, 0x3d, 0x62, 0x8a, 0xbc, 0xc0, 0x84, 0x98, 0x5d, 0x4c, 0xa5, 0x2c, 0x33, 0x34, - 0x99, 0x54, 0xd9, 0x60, 0xdf, 0xe8, 0x13, 0x00, 0x33, 0x0c, 0x03, 0xbb, 0x1d, 0x85, 0x98, 0x54, - 0x0a, 0x9b, 0xc5, 0xaa, 0xda, 0x6c, 0xd4, 0xc7, 0xed, 0x50, 0x4f, 0x5d, 0x54, 0xdf, 0x1b, 0x9e, - 0x78, 0xe6, 0x86, 0xc1, 0xc0, 0x48, 0x5c, 0x81, 0x6e, 0x01, 0x38, 0x5c, 0xac, 0x65, 0x5b, 0x95, - 0x22, 0x23, 0xb4, 0x22, 0x56, 0x0e, 0x2d, 0xb4, 0x0b, 0x65, 0x3f, 0x6a, 0xf7, 0x6d, 0x72, 0xda, - 0xa2, 0xda, 0x54, 0x16, 0x36, 0x95, 0xaa, 0xda, 0xd4, 0x86, 0x88, 0x42, 0xd5, 0xfa, 0xcb, 0x58, - 0x55, 0x43, 0x15, 0xf2, 0x74, 0x45, 0xdb, 0x85, 0xb5, 0x31, 0x70, 0x74, 0x19, 0x8a, 0x3d, 0x3c, - 0x10, 0xaa, 0xd3, 0x4f, 0xb4, 0x0e, 0x8b, 0x67, 0x66, 0x3f, 0xc2, 0x95, 0x02, 0x5b, 0xe3, 0x3f, - 0x1e, 0x17, 0xde, 0x53, 0xf4, 0x6d, 0x58, 0x7b, 0x8e, 0x43, 0x66, 0x33, 0x03, 0xbf, 0x8a, 0x30, - 0x09, 0xa9, 0x70, 0x48, 0x7f, 0x8b, 0x0b, 0xf8, 0x0f, 0xbd, 0x03, 0x97, 0x8e, 0x38, 0xec, 0x44, - 0x39, 0xf4, 0x04, 0x4a, 0x42, 0xb7, 0xd8, 0x78, 0x77, 0xa6, 0x18, 0xcf, 0x18, 0x1e, 0xd0, 0x9b, - 0xb0, 0x36, 0x04, 0x21, 0xbe, 0xe7, 0x12, 0x8c, 0xee, 0x80, 0x3a, 0xb2, 0x1e, 0xa9, 0x28, 0x9b, - 0xc5, 0xea, 0x8a, 0x01, 0x43, 0xf3, 0x11, 0xdd, 0x86, 0x2b, 0x1f, 0xdb, 0x84, 0xab, 0x40, 0x62, - 0x6e, 0x15, 0x58, 0xf6, 0x03, 0xef, 0x53, 0xdc, 0x09, 0x05, 0xbb, 0xf8, 0x27, 0xba, 0x01, 0x2b, - 0x3e, 0xbd, 0x8c, 0xd8, 0x9f, 0x71, 0x73, 0x2c, 0x1a, 0x25, 0xba, 0x70, 0x6c, 0x7f, 0x86, 0xa9, - 0xab, 0xd8, 0x66, 0xe8, 0xf5, 0xb0, 0x1b, 0xbb, 0x8a, 0xae, 0xbc, 0xa4, 0x0b, 0xba, 0x03, 0x28, - 0x09, 0x25, 0x18, 0x36, 0x60, 0x89, 0xa9, 0xce, 0xc9, 0xa9, 0xcd, 0x6b, 0x59, 0x7d, 0xb9, 0x7d, - 0x85, 0x18, 0xba, 0x0f, 0x6b, 0x2e, 0x3e, 0x0f, 0x5b, 0x09, 0x28, 0xee, 0x97, 0x55, 0xba, 0x7c, - 0x34, 0x84, 0x7b, 0x05, 0xb7, 0x86, 0x70, 0xc7, 0x51, 0x9b, 0x74, 0x02, 0xdb, 0x67, 0xc9, 0x36, - 0xd9, 0x03, 0xdf, 0x44, 0x43, 0x17, 0x6e, 0xe7, 0x41, 0x0a, 0x6d, 0xef, 0xc1, 0x2a, 0x49, 0x6e, - 0x08, 0x8f, 0xa4, 0x17, 0x67, 0x56, 0xb1, 0x06, 0xe8, 0x00, 0xf7, 0x71, 0x88, 0x67, 0x88, 0xc0, - 0x7f, 0x16, 0xa0, 0x9c, 0xe4, 0x24, 0xcb, 0xf1, 0xd1, 0xd1, 0x42, 0xd2, 0x24, 0xbb, 0xa0, 0xfa, - 0x11, 0x39, 0x6d, 0x75, 0x3c, 0xf7, 0xc4, 0xee, 0x8a, 0x14, 0xbb, 0x29, 0x8b, 0x4b, 0x72, 0xba, - 0xcf, 0x64, 0x0c, 0xf0, 0x87, 0xdf, 0x68, 0x07, 0xd6, 0xcd, 0x4e, 0xaf, 0x65, 0x61, 0xd3, 0xea, - 0xdb, 0x2e, 0x6e, 0x11, 0xdc, 0xf1, 0x5c, 0x8b, 0x54, 0x16, 0x99, 0x71, 0x91, 0xd9, 0xe9, 0x1d, - 0x88, 0xad, 0x63, 0xbe, 0x83, 0x9a, 0xb0, 0x11, 0xe0, 0xd0, 0xb4, 0xdd, 0x96, 0xd9, 0xe9, 0x61, - 0xab, 0x35, 0x4c, 0x89, 0xe5, 0x4d, 0xa5, 0x5a, 0x32, 0xbe, 0xc5, 0x37, 0xf7, 0xe8, 0x9e, 0xc8, - 0x02, 0x82, 0x7e, 0x02, 0x5a, 0x1c, 0xe9, 0x01, 0x0e, 0xb1, 0x4b, 0x75, 0x6c, 0xc5, 0xf5, 0xb3, - 0x52, 0x62, 0x9c, 0xaf, 0x67, 0xca, 0xc2, 0x81, 0x10, 0x30, 0x2a, 0xe2, 0xb0, 0x11, 0x9f, 0x8d, - 0x77, 0xf4, 0x7f, 0x29, 0x00, 0x23, 0xcd, 0xd0, 0x5d, 0x58, 0x65, 0xc6, 0xc0, 0xae, 0xe5, 0x7b, - 0xb6, 0x1b, 0x67, 0x48, 0x99, 0x2e, 0x3e, 0x13, 0x6b, 0xe8, 0x63, 0x49, 0x15, 0x7c, 0x30, 0xc9, - 0x60, 0x93, 0x4a, 0xe0, 0x37, 0x2d, 0x52, 0x1d, 0x58, 0x33, 0x70, 0x07, 0xdb, 0x67, 0x43, 0x6b, - 0xa1, 0x0d, 0x58, 0xa2, 0x2e, 0xb1, 0xad, 0x38, 0x46, 0xcc, 0x4e, 0xef, 0xd0, 0x42, 0xef, 0xc3, - 0xb2, 0x30, 0x03, 0xbb, 0x65, 0x86, 0xe2, 0x13, 0xcb, 0xeb, 0xdf, 0x85, 0xab, 0xcf, 0x71, 0x98, - 0x0c, 0xb0, 0x38, 0x1c, 0x75, 0x28, 0x27, 0xa3, 0x3b, 0xb6, 0x57, 0x72, 0x4d, 0xff, 0x5a, 0x81, - 0xeb, 0x3f, 0xf2, 0x2d, 0x33, 0xc4, 0xb2, 0x1b, 0x9e, 0x4a, 0x6e, 0x50, 0x9b, 0xb7, 0xb3, 0xdc, - 0x52, 0x87, 0x53, 0x67, 0xd0, 0x13, 0x50, 0x23, 0x06, 0xc0, 0x1a, 0xa2, 0x50, 0x2f, 0xdb, 0x26, - 0xbe, 0x47, 0x7b, 0xe6, 0x0b, 0x93, 0xf4, 0x0c, 0xe0, 0xe2, 0xf4, 0x5b, 0xf7, 0xa1, 0x42, 0xf3, - 0x5a, 0x5a, 0x45, 0x5e, 0x4f, 0xad, 0xfc, 0x9d, 0x02, 0xd7, 0x25, 0x90, 0xa2, 0x8a, 0x1c, 0xc8, - 0xaa, 0xc8, 0x74, 0x8b, 0x5c, 0xb0, 0xca, 0x7c, 0x08, 0xd7, 0x79, 0x95, 0xb9, 0xa8, 0x77, 0x7f, - 0x09, 0xd7, 0x5e, 0x78, 0x96, 0x7d, 0x32, 0x48, 0x14, 0x88, 0xd9, 0x8f, 0x8f, 0x97, 0x9f, 0xc2, - 0x7c, 0xe5, 0x47, 0xff, 0x52, 0x01, 0xf5, 0x28, 0xea, 0xf7, 0xe7, 0x81, 0x7c, 0x08, 0x28, 0xc0, - 0x61, 0x14, 0xb8, 0x2d, 0xdb, 0x71, 0xb0, 0x65, 0x9b, 0x21, 0xee, 0x0f, 0x18, 0x72, 0xc9, 0xb8, - 0xc2, 0x77, 0x0e, 0x47, 0x1b, 0x68, 0x0b, 0xca, 0x8e, 0x79, 0x3e, 0x2a, 0x53, 0x45, 0xe6, 0x6c, - 0xd5, 0x31, 0xcf, 0xe3, 0xf2, 0xa4, 0xff, 0x0c, 0xca, 0x9c, 0x84, 0x70, 0xe1, 0x0f, 0xe0, 0x4a, - 0x20, 0x92, 0x72, 0x74, 0x8e, 0xbb, 0x71, 0x2b, 0xab, 0xda, 0x58, 0xfe, 0x1a, 0x97, 0x83, 0xf4, - 0x02, 0xa1, 0x01, 0x53, 0xe1, 0x46, 0xde, 0x1b, 0xd5, 0xd3, 0x79, 0x54, 0xbe, 0x06, 0xcb, 0xbc, - 0x24, 0x90, 0xca, 0x02, 0xeb, 0x49, 0x4b, 0xac, 0x26, 0x90, 0xdc, 0xf2, 0x5d, 0xcc, 0x2b, 0xdf, - 0xfa, 0x0f, 0x01, 0xed, 0x75, 0x7a, 0xae, 0xf7, 0xf3, 0x3e, 0xb6, 0xba, 0x17, 0x25, 0x51, 0x48, - 0x92, 0xd0, 0x7f, 0x5d, 0x80, 0xf5, 0xe3, 0x30, 0xc0, 0xa6, 0x63, 0xbb, 0xdd, 0x79, 0xbd, 0x99, - 0x77, 0x2b, 0x7a, 0x17, 0xae, 0x39, 0xcc, 0x66, 0x32, 0xed, 0x8a, 0xd5, 0x45, 0x63, 0x83, 0x6f, - 0x8f, 0xf7, 0xa7, 0x77, 0xb2, 0xe7, 0xd2, 0xb6, 0x5b, 0x4f, 0x9f, 0xdb, 0xe3, 0x70, 0xbb, 0x70, - 0x83, 0x30, 0x1d, 0x5a, 0x13, 0xfa, 0x61, 0x85, 0x8b, 0xec, 0x65, 0xcd, 0xda, 0x85, 0x8d, 0x31, - 0x13, 0xbc, 0xa6, 0x58, 0xfa, 0x04, 0x36, 0xf6, 0x03, 0x4c, 0x8b, 0xb1, 0x6b, 0xfa, 0xe4, 0xd4, - 0x0b, 0x63, 0x63, 0xcb, 0x46, 0x86, 0x71, 0x07, 0x14, 0x24, 0x05, 0xe0, 0x15, 0x94, 0xe2, 0xab, - 0xe6, 0x18, 0x3b, 0x9e, 0x80, 0x8a, 0xcf, 0x7d, 0x3b, 0xc0, 0x7c, 0xb2, 0x2f, 0x4e, 0x9d, 0xec, - 0x81, 0x8b, 0xd3, 0x05, 0xbd, 0x0f, 0xeb, 0xac, 0x7e, 0x0a, 0xd8, 0xd7, 0x5c, 0xae, 0x07, 0xb0, - 0x31, 0x86, 0x26, 0x5c, 0xf3, 0x1e, 0xac, 0x90, 0x78, 0x51, 0xb8, 0x44, 0x93, 0x54, 0xe9, 0xd8, - 0xce, 0x23, 0xe1, 0x99, 0xab, 0xf3, 0xdb, 0xb0, 0x21, 0xaa, 0xf3, 0x98, 0xb3, 0x34, 0x28, 0xc5, - 0xb7, 0x09, 0x55, 0x87, 0xbf, 0xf5, 0xdf, 0x2b, 0xa0, 0x1e, 0x63, 0xdc, 0x9b, 0x27, 0x8b, 0x76, - 0x60, 0x81, 0xf9, 0xa1, 0x30, 0xcd, 0x0f, 0x1f, 0xbd, 0x61, 0x30, 0x49, 0x74, 0x33, 0xc1, 0x80, - 0x99, 0xec, 0xa3, 0x37, 0x46, 0x1c, 0x9e, 0x96, 0x60, 0x29, 0x34, 0x83, 0x2e, 0x0e, 0xf5, 0x4b, - 0x50, 0xe6, 0x64, 0xb8, 0xd1, 0x9a, 0xff, 0x5d, 0x03, 0x10, 0xbd, 0xa6, 0x8d, 0x03, 0xf4, 0x5b, - 0x05, 0x90, 0x88, 0xc7, 0x24, 0x9f, 0x29, 0xdd, 0x4e, 0x9b, 0xb2, 0xaf, 0xef, 0x7c, 0xf1, 0xef, - 0xff, 0xfc, 0xb9, 0x50, 0xd3, 0xbe, 0x4d, 0xff, 0x6c, 0xff, 0x05, 0x8d, 0xc3, 0x5d, 0x11, 0x0a, - 0xa4, 0x51, 0x6b, 0xa4, 0x5a, 0x65, 0xa3, 0xf6, 0xf9, 0x63, 0xa5, 0x86, 0xfe, 0xa4, 0xb0, 0x3f, - 0xf7, 0x52, 0x2c, 0xaa, 0x59, 0x14, 0xf9, 0x1c, 0x34, 0x95, 0xcf, 0x3b, 0x8c, 0x4f, 0x03, 0x3d, - 0x64, 0x7c, 0x92, 0xf8, 0x93, 0x78, 0xa1, 0xbf, 0x2a, 0x80, 0xb2, 0xa3, 0x13, 0x7a, 0x2b, 0x8b, - 0x96, 0x3b, 0x60, 0x4d, 0xa5, 0xb6, 0xcb, 0xa8, 0x7d, 0xa7, 0xd9, 0xcc, 0x50, 0xab, 0xcf, 0x62, - 0xb7, 0xaf, 0x15, 0xfe, 0x47, 0x66, 0x6a, 0x98, 0x41, 0xb5, 0x2c, 0x68, 0xde, 0x90, 0xa5, 0xbd, - 0x35, 0x93, 0x2c, 0x0f, 0x1f, 0xbd, 0xce, 0xd8, 0x56, 0xd1, 0x7d, 0xc6, 0x56, 0x70, 0x4b, 0x70, - 0xfc, 0x3c, 0x4d, 0x12, 0xfd, 0x51, 0x89, 0xff, 0x8c, 0x9a, 0x66, 0xc1, 0xdc, 0x31, 0x48, 0xbb, - 0x9a, 0x49, 0x87, 0x67, 0x8e, 0x1f, 0x0e, 0x62, 0xa7, 0xd6, 0xe6, 0x74, 0xea, 0xdf, 0x14, 0xb8, - 0x92, 0xe9, 0xe6, 0x32, 0x8b, 0xe5, 0xb5, 0xfc, 0x5c, 0x42, 0xdf, 0x67, 0x84, 0x0e, 0xf4, 0x0f, - 0xe7, 0x22, 0xf4, 0xd8, 0x19, 0xc7, 0xa1, 0x7e, 0xfd, 0x4a, 0x01, 0x35, 0xd1, 0xe8, 0xd1, 0xbd, - 0x2c, 0xbf, 0xec, 0x1c, 0x90, 0xcb, 0xec, 0x80, 0x31, 0xfb, 0x40, 0x7f, 0x7f, 0x3e, 0x66, 0xe6, - 0x08, 0x81, 0x72, 0xfa, 0x8d, 0x02, 0x0b, 0xb4, 0x39, 0xa2, 0x5b, 0xb2, 0x01, 0x71, 0x38, 0x37, - 0xc8, 0x42, 0x3e, 0xd9, 0x53, 0xe3, 0x90, 0xd7, 0x9b, 0xf3, 0xb1, 0xf1, 0xa3, 0x7e, 0x9f, 0xd2, - 0xb0, 0x60, 0x35, 0xd5, 0xab, 0xd1, 0x7d, 0x49, 0x8a, 0x49, 0xe6, 0x19, 0x6d, 0x7b, 0xaa, 0x1c, - 0x27, 0x58, 0x55, 0x76, 0x14, 0x9a, 0xfb, 0x97, 0xc7, 0x27, 0x6b, 0xf4, 0x66, 0x5e, 0x94, 0x64, - 0xa6, 0xef, 0x5c, 0x57, 0x1c, 0x32, 0xe5, 0xf7, 0xf5, 0x0f, 0x2e, 0x12, 0x24, 0x23, 0x18, 0x6a, - 0x88, 0x3f, 0x28, 0xb0, 0x9a, 0x6a, 0x8d, 0x32, 0x4b, 0xc8, 0x3a, 0xb5, 0xcc, 0x12, 0xd2, 0x1e, - 0xab, 0xd7, 0x18, 0xdb, 0x7b, 0x48, 0xcf, 0xcf, 0xf7, 0x21, 0xf8, 0x97, 0x0a, 0x5c, 0x4a, 0xcf, - 0x36, 0x48, 0x82, 0x23, 0x9d, 0x7e, 0xb4, 0x09, 0x8d, 0x5b, 0x7f, 0xc0, 0x38, 0xdc, 0xd7, 0xb6, - 0xe4, 0xcd, 0x24, 0xc6, 0x17, 0x05, 0xf1, 0x57, 0x0a, 0x5c, 0x4a, 0x37, 0x6d, 0x19, 0x0b, 0x69, - 0x5b, 0xcf, 0xf5, 0xd9, 0x43, 0xc6, 0x60, 0xbb, 0xc6, 0xdb, 0x59, 0x8c, 0x98, 0xc7, 0x82, 0xe5, - 0x09, 0x6d, 0xba, 0xb2, 0x3c, 0x49, 0x4c, 0x06, 0xd2, 0xd6, 0x90, 0xe8, 0xd5, 0x17, 0xcd, 0x13, - 0x82, 0x71, 0xef, 0xb1, 0x52, 0x6b, 0xfe, 0x65, 0x09, 0x56, 0xc4, 0x9b, 0x25, 0x0e, 0xd0, 0xa7, - 0xa0, 0x72, 0xd3, 0xf3, 0x57, 0xe8, 0xbc, 0xa7, 0x40, 0x2d, 0x6f, 0x43, 0x7f, 0x93, 0xb1, 0xb9, - 0xab, 0xdd, 0x96, 0xba, 0x81, 0x3f, 0x20, 0x0a, 0x1f, 0x7c, 0xa1, 0xc0, 0xb2, 0x40, 0x46, 0x9b, - 0xd2, 0x67, 0x8e, 0xc4, 0x6b, 0xad, 0xb6, 0x35, 0x41, 0x42, 0x58, 0xa2, 0xc9, 0xb0, 0x1f, 0xe8, - 0xdb, 0x0c, 0x9b, 0x61, 0xc9, 0xc1, 0xc5, 0xfb, 0x33, 0x25, 0xe1, 0x41, 0x29, 0x7e, 0x3f, 0x46, - 0x5b, 0xd2, 0x49, 0x22, 0xf9, 0xb2, 0x97, 0xaf, 0xf7, 0x36, 0xc3, 0xde, 0x42, 0x77, 0xa6, 0x60, - 0xd3, 0xc8, 0x83, 0xd1, 0x23, 0x2c, 0xba, 0x2b, 0xcf, 0xb1, 0xd4, 0x6b, 0xb0, 0x76, 0x6f, 0xb2, - 0x90, 0x50, 0x3f, 0x4d, 0x41, 0x96, 0x85, 0xe2, 0xfd, 0xf6, 0x1f, 0x0a, 0x5c, 0x95, 0xbf, 0x92, - 0xa2, 0xc6, 0x04, 0x24, 0xe9, 0x5c, 0xb0, 0x33, 0xfb, 0x01, 0x41, 0x33, 0x3d, 0x65, 0xe5, 0x5b, - 0x6a, 0x6c, 0x46, 0x08, 0x41, 0x4d, 0xbc, 0xb4, 0xca, 0x3a, 0x5d, 0xf6, 0x21, 0x36, 0x37, 0x55, - 0x85, 0xa9, 0x6a, 0xd3, 0xbc, 0xf5, 0x74, 0x00, 0xeb, 0x1d, 0xcf, 0xc9, 0x60, 0x3d, 0x55, 0xf9, - 0x23, 0xdc, 0x11, 0xbd, 0xf6, 0x48, 0xf9, 0xe9, 0xbb, 0x42, 0xa0, 0xeb, 0xf5, 0x4d, 0xb7, 0x5b, - 0xf7, 0x82, 0x6e, 0xa3, 0x8b, 0x5d, 0x06, 0xda, 0xe0, 0x5b, 0xa6, 0x6f, 0x93, 0xd1, 0x3f, 0xa9, - 0x9e, 0xf0, 0xaf, 0xff, 0x29, 0xca, 0xdf, 0x0b, 0x57, 0x9f, 0xf3, 0xb3, 0xfb, 0x7d, 0x2f, 0xb2, - 0x68, 0x4c, 0x1f, 0x47, 0xed, 0xfa, 0x8f, 0x1f, 0xb5, 0x97, 0xd8, 0xf1, 0xb7, 0xff, 0x1f, 0x00, - 0x00, 0xff, 0xff, 0x93, 0x6b, 0x90, 0xee, 0xe2, 0x1a, 0x00, 0x00, + 0x19, 0xcf, 0x92, 0x7a, 0x50, 0x1f, 0xf4, 0xf2, 0x56, 0xb2, 0x69, 0xf8, 0x25, 0xc1, 0x8a, 0x45, + 0x33, 0x36, 0x29, 0x33, 0x13, 0x37, 0xb6, 0x2a, 0x67, 0x24, 0xcb, 0x75, 0xdc, 0xb1, 0x1b, 0x15, + 0x72, 0xdb, 0x99, 0x1e, 0xca, 0x01, 0x89, 0x35, 0x8d, 0x90, 0x04, 0x10, 0x00, 0x54, 0xad, 0xb4, + 0x9e, 0x49, 0x93, 0x4e, 0x67, 0x3a, 0xf5, 0xa1, 0x69, 0x6e, 0x9d, 0x1c, 0x3a, 0xd3, 0x5b, 0x8f, + 0x9d, 0xe9, 0xb5, 0xff, 0x44, 0xff, 0x85, 0x1e, 0x7b, 0x6f, 0x8f, 0x99, 0x7d, 0x00, 0xc4, 0x63, + 0x41, 0x8a, 0xb2, 0x7d, 0x03, 0xf6, 0xfb, 0x76, 0xbf, 0xdf, 0xf7, 0xfe, 0x80, 0x85, 0x4b, 0x1d, + 0xc7, 0xe9, 0xf4, 0x48, 0xdd, 0x1d, 0xb4, 0xfc, 0x41, 0xab, 0x7e, 0x74, 0x4b, 0x3c, 0xd5, 0x5c, + 0xcf, 0x09, 0x1c, 0xbc, 0xcc, 0xc9, 0x35, 0xb1, 0x78, 0x74, 0x4b, 0xbd, 0x28, 0x36, 0x18, 0xae, + 0x55, 0x37, 0x6c, 0xdb, 0x09, 0x8c, 0xc0, 0x72, 0x6c, 0x9f, 0xf3, 0xab, 0x97, 0xc3, 0xe3, 0xe8, + 0x5b, 0x6b, 0xf0, 0xac, 0x6e, 0x0e, 0x3c, 0xc6, 0x20, 0xe8, 0x17, 0xd2, 0x74, 0xd2, 0x77, 0x83, + 0x63, 0x41, 0x5c, 0x4b, 0x13, 0x9f, 0x59, 0xa4, 0x67, 0x36, 0xfb, 0x86, 0xdf, 0x15, 0x1c, 0x57, + 0xd2, 0x1c, 0x81, 0xd5, 0x27, 0x7e, 0x60, 0xf4, 0x5d, 0xce, 0xa0, 0x7d, 0x83, 0x60, 0xfa, 0xa9, + 0xe3, 0x5a, 0x6d, 0x8c, 0x61, 0xca, 0x36, 0xfa, 0xa4, 0x8c, 0xd6, 0x50, 0x65, 0x4e, 0x67, 0xcf, + 0x78, 0x1b, 0x66, 0x7a, 0x46, 0x8b, 0xf4, 0xfc, 0x72, 0x61, 0xad, 0x58, 0x51, 0x1a, 0x57, 0x6b, + 0x69, 0xf5, 0x6a, 0x6c, 0x73, 0xed, 0x31, 0xe3, 0x7a, 0x60, 0x07, 0xde, 0xb1, 0x2e, 0xb6, 0xa8, + 0x77, 0x40, 0x89, 0x2d, 0xe3, 0x65, 0x28, 0x76, 0xc9, 0xb1, 0x38, 0x9e, 0x3e, 0xe2, 0x15, 0x98, + 0x3e, 0x32, 0x7a, 0x03, 0x52, 0x2e, 0xb0, 0x35, 0xfe, 0x72, 0xb7, 0xf0, 0x21, 0xd2, 0xbe, 0x2e, + 0xc0, 0xc2, 0x01, 0x13, 0xf1, 0x84, 0xf8, 0xbe, 0xd1, 0x21, 0x14, 0x9d, 0x69, 0x04, 0x06, 0xdb, + 0x3e, 0xaf, 0xb3, 0x67, 0xfc, 0x09, 0x80, 0x11, 0x04, 0x9e, 0xd5, 0x1a, 0x04, 0x24, 0x44, 0x58, + 0xcf, 0x22, 0x4c, 0x1c, 0x54, 0xdb, 0x8d, 0x76, 0x70, 0xb4, 0xb1, 0x23, 0xf0, 0x25, 0x80, 0x3e, + 0x67, 0x6b, 0x5a, 0x66, 0xb9, 0xc8, 0x50, 0xcd, 0x89, 0x95, 0x47, 0x26, 0xde, 0x81, 0x79, 0x77, + 0xd0, 0xea, 0x59, 0xfe, 0xf3, 0x26, 0x35, 0x63, 0x79, 0x6a, 0x0d, 0x55, 0x94, 0x86, 0x1a, 0x49, + 0x14, 0x36, 0xae, 0x3d, 0x0d, 0x6d, 0xac, 0x2b, 0x82, 0x9f, 0xae, 0xa8, 0x3b, 0xb0, 0x94, 0x12, + 0x3e, 0x91, 0x4d, 0x36, 0x61, 0xe9, 0x21, 0x09, 0x98, 0xb9, 0x75, 0xf2, 0xd9, 0x80, 0xf8, 0x01, + 0x65, 0x0e, 0xe8, 0xbb, 0x38, 0x80, 0xbf, 0x68, 0x5f, 0x20, 0xc0, 0x3f, 0x75, 0x4d, 0x23, 0x20, + 0x09, 0xe6, 0x9b, 0x71, 0x66, 0xa5, 0x71, 0x2e, 0xc7, 0x95, 0xe2, 0x14, 0xbc, 0x0d, 0xca, 0x80, + 0x1d, 0xc2, 0xc2, 0x89, 0xc1, 0x91, 0xe9, 0xfa, 0x43, 0x1a, 0x71, 0x4f, 0x0c, 0xbf, 0xab, 0x03, + 0x67, 0xa7, 0xcf, 0x5a, 0x1b, 0x16, 0x0f, 0xb8, 0xe6, 0x23, 0xa1, 0xe2, 0x6d, 0x28, 0x09, 0xf3, + 0x86, 0xfe, 0xbb, 0x32, 0xc6, 0x7f, 0x7a, 0xb4, 0x41, 0x6b, 0xc0, 0x52, 0x24, 0xc4, 0x77, 0x1d, + 0xdb, 0x27, 0xf8, 0x0a, 0x28, 0x43, 0x07, 0xfa, 0x65, 0xb4, 0x56, 0xac, 0xcc, 0xe9, 0x10, 0x79, + 0xd0, 0xd7, 0x2c, 0x38, 0xf3, 0xd8, 0xf2, 0xb9, 0x15, 0xfd, 0x10, 0x5b, 0x19, 0x66, 0x5d, 0xcf, + 0xf9, 0x94, 0xb4, 0x03, 0x81, 0x2e, 0x7c, 0xc5, 0x17, 0x60, 0xce, 0xa5, 0x87, 0xf9, 0xd6, 0xe7, + 0xdc, 0x23, 0xd3, 0x7a, 0x89, 0x2e, 0x1c, 0x5a, 0x9f, 0x13, 0x1a, 0x2d, 0x8c, 0x18, 0x38, 0x5d, + 0x62, 0x87, 0xd1, 0x42, 0x57, 0x9e, 0xd2, 0x05, 0xad, 0x0f, 0x38, 0x2e, 0x4a, 0x20, 0xac, 0xc3, + 0x0c, 0x53, 0x9d, 0x83, 0x1b, 0xe1, 0x06, 0xc1, 0x86, 0xaf, 0xc1, 0x92, 0x4d, 0x5e, 0x04, 0xcd, + 0x98, 0x28, 0x1e, 0x1a, 0x0b, 0x74, 0xf9, 0x20, 0x12, 0xf7, 0x19, 0x5c, 0x8a, 0xc4, 0x1d, 0x0e, + 0x5a, 0x7e, 0xdb, 0xb3, 0x5c, 0x56, 0x68, 0x46, 0x7b, 0xe0, 0x75, 0x34, 0xb4, 0xe1, 0x72, 0x9e, + 0x48, 0xa1, 0xed, 0x06, 0x2c, 0xf8, 0x71, 0x82, 0xf0, 0x48, 0x72, 0xf1, 0xc4, 0x2a, 0x56, 0x01, + 0xef, 0x93, 0x1e, 0x49, 0xc5, 0xb5, 0x3c, 0x09, 0xfe, 0x59, 0x84, 0xf9, 0x38, 0x26, 0x69, 0x79, + 0x8b, 0xb6, 0x16, 0xe2, 0x26, 0xd9, 0x01, 0xc5, 0x1d, 0xf8, 0xcf, 0x9b, 0x6d, 0xc7, 0x7e, 0x66, + 0x75, 0x44, 0x96, 0x5f, 0x94, 0xc5, 0xa5, 0xff, 0xfc, 0x3e, 0xe3, 0xd1, 0xc1, 0x8d, 0x9e, 0xf1, + 0x16, 0xac, 0x18, 0xed, 0x6e, 0xd3, 0x24, 0x86, 0xd9, 0xb3, 0x6c, 0xd2, 0xf4, 0x49, 0xdb, 0xb1, + 0x4d, 0xbf, 0x3c, 0xcd, 0x8c, 0x8b, 0x8d, 0x76, 0x77, 0x5f, 0x90, 0x0e, 0x39, 0x05, 0x37, 0x60, + 0xd5, 0x23, 0x81, 0x61, 0xd9, 0x4d, 0xa3, 0xdd, 0x25, 0x66, 0x33, 0x4a, 0x89, 0xd9, 0x35, 0x54, + 0x29, 0xe9, 0xdf, 0xe3, 0xc4, 0x5d, 0x4a, 0x13, 0x59, 0xe0, 0xe3, 0x9f, 0x83, 0x1a, 0x46, 0xba, + 0x47, 0x02, 0x62, 0x53, 0x1d, 0x9b, 0x61, 0xef, 0x28, 0x97, 0x18, 0xe6, 0xf3, 0x99, 0x6c, 0xdd, + 0x17, 0x0c, 0x7a, 0x59, 0x6c, 0xd6, 0xc3, 0xbd, 0x21, 0x05, 0xef, 0x45, 0x25, 0x7f, 0x8e, 0x05, + 0x68, 0x35, 0xab, 0x78, 0xdc, 0xae, 0x6f, 0xba, 0xf2, 0xff, 0x0b, 0x01, 0x0c, 0x0d, 0x8b, 0xaf, + 0xc2, 0x02, 0xf3, 0x05, 0xb1, 0x4d, 0xd7, 0xb1, 0xec, 0x30, 0x41, 0xe7, 0xe9, 0xe2, 0x03, 0xb1, + 0x86, 0x1f, 0x4b, 0xfa, 0xc0, 0x8d, 0x51, 0xfe, 0x1a, 0xd5, 0x04, 0x5e, 0xb7, 0x4c, 0xb7, 0x61, + 0x49, 0x27, 0x6d, 0x62, 0x1d, 0x45, 0xce, 0xc2, 0xab, 0x30, 0x43, 0x23, 0xc2, 0x32, 0xc3, 0x10, + 0x35, 0xda, 0xdd, 0x47, 0x26, 0xbe, 0x03, 0xb3, 0xc2, 0x0b, 0xa2, 0xba, 0x8e, 0xad, 0x7d, 0x21, + 0xbf, 0xf6, 0x03, 0x38, 0xfb, 0x90, 0x04, 0x71, 0x3f, 0x84, 0xd9, 0xa0, 0xc1, 0x7c, 0x3c, 0xb9, + 0x42, 0x7b, 0xc5, 0xd7, 0xb4, 0x6f, 0x11, 0x9c, 0xe7, 0x0d, 0x42, 0x76, 0xc2, 0x9e, 0xe4, 0x04, + 0xa5, 0x71, 0x79, 0x74, 0x18, 0x24, 0x25, 0xbc, 0x5e, 0xf3, 0x70, 0xa1, 0x4c, 0xcb, 0x8a, 0xb4, + 0x88, 0xbd, 0x9d, 0x52, 0xfd, 0x07, 0x04, 0xe7, 0x25, 0x22, 0x45, 0x11, 0xdb, 0x97, 0x15, 0xb1, + 0xf1, 0x16, 0x39, 0x65, 0x91, 0xfb, 0x08, 0xce, 0xf3, 0x22, 0x77, 0x5a, 0xef, 0xfe, 0x06, 0xce, + 0x3d, 0x71, 0x4c, 0xeb, 0xd9, 0x71, 0xac, 0x3e, 0x9d, 0x7c, 0x7b, 0xba, 0xfa, 0x15, 0x26, 0xab, + 0x7e, 0xda, 0x57, 0x08, 0x94, 0x83, 0x41, 0xaf, 0x37, 0x89, 0xc8, 0x9b, 0x80, 0x3d, 0x12, 0x0c, + 0x3c, 0xbb, 0x69, 0xf5, 0xfb, 0xc4, 0xb4, 0x8c, 0x80, 0xf4, 0x8e, 0x99, 0xe4, 0x92, 0x7e, 0x86, + 0x53, 0x1e, 0x0d, 0x09, 0x78, 0x1d, 0xe6, 0xfb, 0xc6, 0x8b, 0x61, 0x95, 0x2c, 0x32, 0x67, 0x2b, + 0x7d, 0xe3, 0x45, 0x58, 0x1d, 0xb5, 0x5f, 0xc2, 0x3c, 0x07, 0x21, 0x5c, 0xf8, 0x63, 0x38, 0xe3, + 0x89, 0xa4, 0x1c, 0xee, 0xe3, 0x6e, 0x5c, 0xcf, 0xaa, 0x96, 0xca, 0x5f, 0x7d, 0xd9, 0x4b, 0x2e, + 0xf8, 0x34, 0x60, 0xca, 0xdc, 0xc8, 0xbb, 0xc3, 0x72, 0x3e, 0x89, 0xca, 0xe7, 0x60, 0x96, 0x97, + 0x04, 0xbf, 0x3c, 0xc5, 0x5a, 0xe2, 0x0c, 0xab, 0x09, 0x7e, 0x6e, 0xf7, 0x28, 0xe6, 0x75, 0x0f, + 0xed, 0x27, 0x80, 0x77, 0xdb, 0x5d, 0xdb, 0xf9, 0x55, 0x8f, 0x98, 0x9d, 0xd3, 0x82, 0x28, 0xc4, + 0x41, 0x68, 0xbf, 0x2d, 0xc0, 0xca, 0x61, 0xe0, 0x11, 0xa3, 0x6f, 0xd9, 0x9d, 0x49, 0xbd, 0x99, + 0x77, 0x2a, 0xbe, 0x0d, 0xe7, 0xfa, 0xcc, 0x66, 0x32, 0xed, 0x8a, 0x95, 0x69, 0x7d, 0x95, 0x93, + 0xd3, 0xed, 0xf1, 0x83, 0xec, 0xbe, 0xa4, 0xed, 0x56, 0x92, 0xfb, 0x76, 0xb9, 0xb8, 0x1d, 0xb8, + 0xe0, 0x33, 0x1d, 0x9a, 0x23, 0xda, 0x71, 0x99, 0xb3, 0xec, 0x66, 0xcd, 0xda, 0x81, 0xd5, 0x94, + 0x09, 0xde, 0x52, 0x2c, 0x7d, 0x02, 0xab, 0xf7, 0x3d, 0x42, 0x8b, 0xb1, 0x6d, 0xb8, 0xfe, 0x73, + 0x27, 0x08, 0x8d, 0x2d, 0x9b, 0x58, 0xd2, 0x0e, 0x28, 0x48, 0x0a, 0xc0, 0x2b, 0x04, 0xab, 0xa2, + 0xbc, 0xa7, 0x4e, 0xbc, 0x0d, 0x25, 0x5f, 0x2c, 0x89, 0xb2, 0xae, 0x4a, 0x8a, 0x58, 0xb8, 0x29, + 0xe2, 0x7d, 0xbd, 0x72, 0xfe, 0x5f, 0x04, 0xa5, 0xf0, 0xcc, 0x09, 0xa6, 0xb0, 0x6d, 0x50, 0xc8, + 0x0b, 0xd7, 0xf2, 0x08, 0xff, 0xd6, 0x2a, 0x8e, 0xfd, 0xd6, 0x02, 0xce, 0x4e, 0x17, 0xf0, 0xbd, + 0x68, 0x88, 0x99, 0x62, 0x8e, 0xb9, 0x96, 0xaf, 0xe6, 0x9b, 0x1e, 0x60, 0x7a, 0xb0, 0xc2, 0x5a, + 0x89, 0x38, 0xfe, 0x2d, 0x77, 0xae, 0x63, 0x58, 0x4d, 0x49, 0x13, 0x51, 0xfa, 0x21, 0xcc, 0x85, + 0xee, 0x0b, 0xa3, 0x73, 0x94, 0xaf, 0x87, 0xcc, 0x27, 0x6e, 0x54, 0xef, 0xc3, 0xaa, 0x68, 0x54, + 0xa9, 0x28, 0x53, 0x53, 0x51, 0x36, 0x37, 0x8c, 0x24, 0xed, 0x8f, 0x08, 0x94, 0x43, 0x42, 0xba, + 0x93, 0x14, 0x94, 0x2d, 0x98, 0x62, 0x21, 0x50, 0x18, 0x17, 0x02, 0x1f, 0xbf, 0xa3, 0x33, 0x4e, + 0x7c, 0x31, 0x86, 0x80, 0x99, 0xec, 0xe3, 0x77, 0x86, 0x18, 0xf6, 0x4a, 0x30, 0x13, 0x18, 0x5e, + 0x87, 0x04, 0xda, 0x22, 0xcc, 0x73, 0x30, 0xdc, 0x68, 0x8d, 0xff, 0x2d, 0x03, 0x88, 0xb6, 0xdb, + 0x22, 0x1e, 0xfe, 0x3d, 0x02, 0x2c, 0x52, 0x33, 0x8e, 0x67, 0x4c, 0xe3, 0x57, 0xc7, 0xd0, 0xb5, + 0xad, 0x2f, 0xff, 0xfd, 0x9f, 0x6f, 0x0a, 0x55, 0xf5, 0xdd, 0xfa, 0xd1, 0xad, 0xfa, 0xaf, 0x69, + 0x0a, 0xec, 0x88, 0x50, 0xf0, 0xeb, 0xd5, 0x7a, 0x62, 0x6a, 0xa8, 0x57, 0x5f, 0xde, 0x45, 0x55, + 0xfc, 0x67, 0xc4, 0xbe, 0xfd, 0x13, 0x28, 0x2a, 0x59, 0x29, 0xf2, 0x91, 0x70, 0x2c, 0x9e, 0x0f, + 0x18, 0x9e, 0x3a, 0xbe, 0xc9, 0xf0, 0xc4, 0xe5, 0x8f, 0xc2, 0x85, 0xff, 0x1a, 0xfd, 0x66, 0x48, + 0xe0, 0x7a, 0x2f, 0x2b, 0x2d, 0x77, 0xd6, 0x1c, 0x0b, 0x6d, 0x87, 0x41, 0xfb, 0x7e, 0xa3, 0x91, + 0x81, 0x56, 0x3b, 0x89, 0xdd, 0xbe, 0x45, 0xfc, 0x73, 0x3f, 0x31, 0xd7, 0x61, 0xc9, 0x17, 0x4d, + 0xde, 0xbc, 0xa9, 0xbe, 0x77, 0x22, 0x5e, 0x1e, 0x3e, 0x5a, 0x8d, 0xa1, 0xad, 0xe0, 0x6b, 0x0c, + 0xad, 0xc0, 0x16, 0xc3, 0xf8, 0x32, 0x09, 0x12, 0xff, 0x09, 0x85, 0x1f, 0xb4, 0xe3, 0x2c, 0x98, + 0x3b, 0x11, 0xaa, 0x67, 0x33, 0xe9, 0xf0, 0xa0, 0xef, 0x06, 0xc7, 0xa1, 0x53, 0xab, 0x13, 0x3a, + 0xf5, 0x6f, 0x08, 0xce, 0x64, 0x06, 0x1b, 0x99, 0xc5, 0xf2, 0xa6, 0x9f, 0x5c, 0x40, 0x3f, 0x62, + 0x80, 0xf6, 0xb5, 0x8f, 0x26, 0x02, 0x74, 0xb7, 0x9f, 0x96, 0x43, 0xfd, 0xfa, 0x35, 0x02, 0x25, + 0x36, 0xf3, 0xe0, 0x8d, 0x2c, 0xbe, 0xec, 0x48, 0x94, 0x8b, 0x6c, 0x9f, 0x21, 0xbb, 0xa7, 0xdd, + 0x99, 0x0c, 0x99, 0x31, 0x94, 0x40, 0x31, 0xfd, 0x0e, 0xc1, 0x14, 0x9d, 0x13, 0xf0, 0x25, 0xd9, + 0xac, 0x1c, 0x8d, 0x50, 0xb2, 0x90, 0x8f, 0x8f, 0x17, 0x61, 0xc8, 0x6b, 0x8d, 0xc9, 0xd0, 0xb8, + 0x83, 0x5e, 0x8f, 0xc2, 0x30, 0x61, 0x21, 0x31, 0xb6, 0x60, 0x59, 0xeb, 0x93, 0x8c, 0x76, 0xea, + 0xe6, 0x58, 0x3e, 0x0e, 0xb0, 0x82, 0xb6, 0x10, 0xcd, 0xfd, 0xe5, 0xf4, 0x47, 0x06, 0xbe, 0x9e, + 0x17, 0x25, 0x99, 0x0f, 0x91, 0x5c, 0x57, 0x3c, 0x62, 0xca, 0xdf, 0xd7, 0xee, 0x9d, 0x26, 0x48, + 0x86, 0x62, 0xa8, 0x21, 0x5e, 0x21, 0x58, 0x48, 0xb4, 0x46, 0x99, 0x25, 0x64, 0x9d, 0x5a, 0x66, + 0x09, 0x69, 0x8f, 0xd5, 0xaa, 0x0c, 0xed, 0x06, 0xd6, 0xf2, 0xf3, 0x3d, 0x12, 0xfe, 0x15, 0x82, + 0xc5, 0xe4, 0x98, 0x87, 0x25, 0x72, 0xa4, 0x83, 0xa0, 0x3a, 0xa2, 0x71, 0x6b, 0x37, 0x18, 0x86, + 0x6b, 0xea, 0xba, 0xbc, 0x99, 0x84, 0xf2, 0x45, 0x41, 0x7c, 0x85, 0x60, 0x31, 0x39, 0x1a, 0xca, + 0x50, 0x48, 0x87, 0xc7, 0x91, 0x28, 0x44, 0xb5, 0x69, 0x54, 0xb9, 0xdf, 0xc2, 0xd1, 0x6a, 0x1c, + 0x9c, 0x2f, 0x10, 0x2c, 0x26, 0x67, 0x08, 0x19, 0x1c, 0xe9, 0x94, 0x91, 0x1b, 0x42, 0x37, 0x19, + 0x94, 0xcd, 0xea, 0xbb, 0x09, 0x28, 0x79, 0x28, 0x58, 0xda, 0xd2, 0x19, 0x40, 0x96, 0xb6, 0xb1, + 0x41, 0x45, 0xda, 0xa9, 0x62, 0xa3, 0xc3, 0x69, 0xd3, 0xd6, 0x27, 0xa4, 0x7b, 0x17, 0x55, 0x1b, + 0x7f, 0x99, 0x85, 0x39, 0xf1, 0x33, 0x9b, 0x78, 0xf8, 0x53, 0x50, 0x78, 0x24, 0xf0, 0x9b, 0x99, + 0xbc, 0x7f, 0xc4, 0x6a, 0x1e, 0x41, 0xbb, 0xce, 0xd0, 0x5c, 0x55, 0x2f, 0x4b, 0xa3, 0x82, 0xff, + 0x59, 0x16, 0x3e, 0x78, 0x09, 0x4a, 0xec, 0xb2, 0x40, 0x56, 0x4a, 0xb3, 0x77, 0x09, 0xf9, 0x82, + 0xeb, 0x4c, 0xf0, 0xf5, 0xc6, 0x06, 0x13, 0xcc, 0x04, 0xd5, 0x46, 0x8a, 0xff, 0x12, 0xc1, 0xac, + 0x50, 0x1c, 0xaf, 0x49, 0xff, 0x7f, 0xc5, 0x6e, 0x11, 0xd4, 0xf5, 0x11, 0x1c, 0xc2, 0x11, 0x0d, + 0x86, 0xe0, 0x86, 0xb6, 0x39, 0x44, 0x20, 0x17, 0x2e, 0xae, 0x66, 0x28, 0x08, 0x07, 0x4a, 0xe1, + 0xd5, 0x0a, 0x5e, 0x97, 0xce, 0x55, 0x27, 0xd3, 0x7e, 0x93, 0xc9, 0x5e, 0xc7, 0x57, 0xc6, 0xc8, + 0xa6, 0x81, 0x0f, 0xc3, 0xcb, 0x01, 0x7c, 0x55, 0x5e, 0x71, 0x12, 0xb7, 0x14, 0xea, 0xc6, 0x68, + 0x26, 0xa1, 0x7e, 0x12, 0x82, 0xac, 0x26, 0x89, 0x7b, 0x85, 0x7f, 0x20, 0x38, 0x2b, 0xff, 0x7b, + 0x8f, 0xeb, 0x23, 0x24, 0x49, 0xa7, 0xa4, 0xad, 0x93, 0x6f, 0x10, 0x30, 0x93, 0x33, 0x67, 0xbe, + 0xa5, 0x52, 0x13, 0x53, 0x00, 0x4a, 0xec, 0x06, 0x40, 0x16, 0xac, 0xd9, 0x0b, 0x82, 0xdc, 0x4a, + 0x21, 0x4c, 0x55, 0x1d, 0xe7, 0xad, 0xbd, 0x63, 0x58, 0x69, 0x3b, 0xfd, 0x8c, 0xac, 0x3d, 0x85, + 0xff, 0x9d, 0x3d, 0xa0, 0xc7, 0x1e, 0xa0, 0x5f, 0xdc, 0x16, 0x0c, 0x1d, 0xa7, 0x67, 0xd8, 0x9d, + 0x9a, 0xe3, 0x75, 0xea, 0x1d, 0x62, 0x33, 0xa1, 0x75, 0x4e, 0x32, 0x5c, 0xcb, 0x1f, 0x5e, 0x1c, + 0x6f, 0xf3, 0xa7, 0xff, 0x23, 0xf4, 0xf7, 0xc2, 0xd9, 0x87, 0x7c, 0xef, 0xfd, 0x9e, 0x33, 0x30, + 0x69, 0x4c, 0x1f, 0x0e, 0x5a, 0xb5, 0x9f, 0xdd, 0x6a, 0xcd, 0xb0, 0xed, 0xef, 0x7f, 0x17, 0x00, + 0x00, 0xff, 0xff, 0x68, 0xa2, 0x62, 0x98, 0x76, 0x1e, 0x00, 0x00, } diff --git a/vendor/google.golang.org/genproto/protobuf/api/api.pb.go b/vendor/google.golang.org/genproto/protobuf/api/api.pb.go index 0ff1d4f0..d41ce3c6 100644 --- a/vendor/google.golang.org/genproto/protobuf/api/api.pb.go +++ b/vendor/google.golang.org/genproto/protobuf/api/api.pb.go @@ -31,22 +31,29 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package -// Api is a light-weight descriptor for a protocol buffer service. +// Api is a light-weight descriptor for an API Interface. +// +// Interfaces are also described as "protocol buffer services" in some contexts, +// such as by the "service" keyword in a .proto file, but they are different +// from API Services, which represent a concrete implementation of an interface +// as opposed to simply a description of methods and bindings. They are also +// sometimes simply referred to as "APIs" in other contexts, such as the name of +// this message itself. See https://cloud.google.com/apis/design/glossary for +// detailed terminology. type Api struct { - // The fully qualified name of this api, including package name - // followed by the api's simple name. + // The fully qualified name of this interface, including package name + // followed by the interface's simple name. Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` - // The methods of this api, in unspecified order. + // The methods of this interface, in unspecified order. Methods []*Method `protobuf:"bytes,2,rep,name=methods" json:"methods,omitempty"` - // Any metadata attached to the API. + // Any metadata attached to the interface. Options []*google_protobuf2.Option `protobuf:"bytes,3,rep,name=options" json:"options,omitempty"` - // A version string for this api. If specified, must have the form - // `major-version.minor-version`, as in `1.10`. If the minor version - // is omitted, it defaults to zero. If the entire version field is - // empty, the major version is derived from the package name, as - // outlined below. If the field is not empty, the version in the - // package name will be verified to be consistent with what is - // provided here. + // A version string for this interface. If specified, must have the form + // `major-version.minor-version`, as in `1.10`. If the minor version is + // omitted, it defaults to zero. If the entire version field is empty, the + // major version is derived from the package name, as outlined below. If the + // field is not empty, the version in the package name will be verified to be + // consistent with what is provided here. // // The versioning schema uses [semantic // versioning](http://semver.org) where the major version number @@ -56,17 +63,17 @@ type Api struct { // chosen based on the product plan. // // The major version is also reflected in the package name of the - // API, which must end in `v`, as in + // interface, which must end in `v`, as in // `google.feature.v1`. For major versions 0 and 1, the suffix can // be omitted. Zero major versions must only be used for - // experimental, none-GA apis. + // experimental, non-GA interfaces. // // Version string `protobuf:"bytes,4,opt,name=version" json:"version,omitempty"` // Source context for the protocol buffer service represented by this // message. SourceContext *google_protobuf.SourceContext `protobuf:"bytes,5,opt,name=source_context,json=sourceContext" json:"source_context,omitempty"` - // Included APIs. See [Mixin][]. + // Included interfaces. See [Mixin][]. Mixins []*Mixin `protobuf:"bytes,6,rep,name=mixins" json:"mixins,omitempty"` // The source syntax of the service. Syntax google_protobuf2.Syntax `protobuf:"varint,7,opt,name=syntax,enum=google.protobuf.Syntax" json:"syntax,omitempty"` @@ -126,7 +133,7 @@ func (m *Api) GetSyntax() google_protobuf2.Syntax { return google_protobuf2.Syntax_SYNTAX_PROTO2 } -// Method represents a method of an api. +// Method represents a method of an API interface. type Method struct { // The simple name of this method. Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` @@ -198,9 +205,9 @@ func (m *Method) GetSyntax() google_protobuf2.Syntax { return google_protobuf2.Syntax_SYNTAX_PROTO2 } -// Declares an API to be included in this API. The including API must -// redeclare all the methods from the included API, but documentation -// and options are inherited as follows: +// Declares an API Interface to be included in this interface. The including +// interface must redeclare all the methods from the included interface, but +// documentation and options are inherited as follows: // // - If after comment and whitespace stripping, the documentation // string of the redeclared method is empty, it will be inherited @@ -212,7 +219,8 @@ func (m *Method) GetSyntax() google_protobuf2.Syntax { // // - If an http annotation is inherited, the path pattern will be // modified as follows. Any version prefix will be replaced by the -// version of the including API plus the [root][] path if specified. +// version of the including interface plus the [root][] path if +// specified. // // Example of a simple mixin: // @@ -276,7 +284,7 @@ func (m *Method) GetSyntax() google_protobuf2.Syntax { // ... // } type Mixin struct { - // The fully qualified name of the API which is included. + // The fully qualified name of the interface which is included. Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` // If non-empty specifies a path under which inherited HTTP paths // are rooted. diff --git a/vendor/k8s.io/helm/CONTRIBUTING.md b/vendor/k8s.io/helm/CONTRIBUTING.md index 2c02071e..ff7a0145 100644 --- a/vendor/k8s.io/helm/CONTRIBUTING.md +++ b/vendor/k8s.io/helm/CONTRIBUTING.md @@ -152,7 +152,7 @@ Documentation PRs will follow the same lifecycle as other PRs. They will also be ## The Triager Each week, one of the core maintainers will serve as the designated "triager" starting after the public standup meetings on Thursday. This person will be in charge triaging new PRs and issues -thoughout the work week. +throughout the work week. ## Labels The following tables define all label types used for Helm. It is split up by category. diff --git a/vendor/k8s.io/helm/OWNERS b/vendor/k8s.io/helm/OWNERS index f1dc937c..39016c27 100644 --- a/vendor/k8s.io/helm/OWNERS +++ b/vendor/k8s.io/helm/OWNERS @@ -1,19 +1,27 @@ maintainers: - adamreese + - bacongobbler + - jascott1 - michelleN - migmartri + - nebril - prydonius + - seh - technosophos - thomastaylor312 - vaikas-google - viglesiasce reviewers: - adamreese + - bacongobbler - fibonacci1729 + - jascott1 - michelleN - migmartri + - nebril - prydonius - sebgoa + - seh - technosophos - thomastaylor312 - vaikas-google diff --git a/vendor/k8s.io/helm/README.md b/vendor/k8s.io/helm/README.md index 0f528411..5830e332 100644 --- a/vendor/k8s.io/helm/README.md +++ b/vendor/k8s.io/helm/README.md @@ -2,6 +2,7 @@ [![CircleCI](https://circleci.com/gh/kubernetes/helm.svg?style=svg)](https://circleci.com/gh/kubernetes/helm) [![Go Report Card](https://goreportcard.com/badge/github.com/kubernetes/helm)](https://goreportcard.com/report/github.com/kubernetes/helm) +[![GoDoc](https://godoc.org/github.com/kubernetes/helm?status.svg)](https://godoc.org/github.com/kubernetes/helm) Helm is a tool for managing Kubernetes charts. Charts are packages of pre-configured Kubernetes resources. @@ -33,21 +34,21 @@ Think of it like apt/yum/homebrew for Kubernetes. Binary downloads of the Helm client can be found at the following links: -- [OSX](https://kubernetes-helm.storage.googleapis.com/helm-v2.5.1-darwin-amd64.tar.gz) -- [Linux](https://kubernetes-helm.storage.googleapis.com/helm-v2.5.1-linux-amd64.tar.gz) -- [Linux 32-bit](https://kubernetes-helm.storage.googleapis.com/helm-v2.5.1-linux-386.tar.gz) +- [OSX](https://kubernetes-helm.storage.googleapis.com/helm-v2.6.1-darwin-amd64.tar.gz) +- [Linux](https://kubernetes-helm.storage.googleapis.com/helm-v2.6.1-linux-amd64.tar.gz) +- [Linux 32-bit](https://kubernetes-helm.storage.googleapis.com/helm-v2.6.1-linux-386.tar.gz) Unpack the `helm` binary and add it to your PATH and you are good to go! macOS/[homebrew](https://brew.sh/) users can also use `brew install kubernetes-helm`. -To rapidly get Helm up and running, start with the [Quick Start Guide](docs/quickstart.md). +To rapidly get Helm up and running, start with the [Quick Start Guide](https://docs.helm.sh/using_helm/#quickstart-guide). -See the [installation guide](docs/install.md) for more options, +See the [installation guide](https://docs.helm.sh/using_helm/#installing-helm) for more options, including installing pre-releases. ## Docs -Get started with the [Quick Start guide](docs/quickstart.md) or plunge into the [complete documentation](docs/index.md) +Get started with the [Quick Start guide](https://docs.helm.sh/using_helm/#quickstart-guide) or plunge into the [complete documentation](https://docs.helm.sh) ## Roadmap @@ -60,6 +61,7 @@ You can reach the Helm community and developers via the following channels: - [Kubernetes Slack](https://slack.k8s.io): - #helm-users - #helm-dev + - #charts - Mailing List: https://groups.google.com/forum/#!forum/kubernetes-sig-apps - Developer Call: Thursdays at 9:30-10:00 Pacific. [https://zoom.us/j/4526666954](https://zoom.us/j/4526666954) diff --git a/vendor/k8s.io/helm/_proto/hapi/release/status.proto b/vendor/k8s.io/helm/_proto/hapi/release/status.proto index ee8c07bb..ef28a233 100644 --- a/vendor/k8s.io/helm/_proto/hapi/release/status.proto +++ b/vendor/k8s.io/helm/_proto/hapi/release/status.proto @@ -37,6 +37,12 @@ message Status { FAILED = 4; // Status_DELETING indicates that a delete operation is underway. DELETING = 5; + // Status_PENDING_INSTALL indicates that an install operation is underway. + PENDING_INSTALL = 6; + // Status_PENDING_UPGRADE indicates that an upgrade operation is underway. + PENDING_UPGRADE = 7; + // Status_PENDING_ROLLBACK indicates that an rollback operation is underway. + PENDING_ROLLBACK = 8; } Code code = 1; diff --git a/vendor/k8s.io/helm/cmd/helm/delete.go b/vendor/k8s.io/helm/cmd/helm/delete.go index 67ab4379..05c84534 100755 --- a/vendor/k8s.io/helm/cmd/helm/delete.go +++ b/vendor/k8s.io/helm/cmd/helm/delete.go @@ -80,7 +80,7 @@ func newDeleteCmd(c helm.Interface, out io.Writer) *cobra.Command { f.BoolVar(&del.dryRun, "dry-run", false, "simulate a delete") f.BoolVar(&del.disableHooks, "no-hooks", false, "prevent hooks from running during deletion") f.BoolVar(&del.purge, "purge", false, "remove the release from the store and make its name free for later use") - f.Int64Var(&del.timeout, "timeout", 300, "time in seconds to wait for any individual kubernetes operation (like Jobs for hooks)") + f.Int64Var(&del.timeout, "timeout", 300, "time in seconds to wait for any individual Kubernetes operation (like Jobs for hooks)") return cmd } diff --git a/vendor/k8s.io/helm/cmd/helm/delete_test.go b/vendor/k8s.io/helm/cmd/helm/delete_test.go index 9d7c184d..4f1bd29a 100644 --- a/vendor/k8s.io/helm/cmd/helm/delete_test.go +++ b/vendor/k8s.io/helm/cmd/helm/delete_test.go @@ -21,6 +21,8 @@ import ( "testing" "github.com/spf13/cobra" + + "k8s.io/helm/pkg/helm" ) func TestDelete(t *testing.T) { @@ -60,7 +62,7 @@ func TestDelete(t *testing.T) { err: true, }, } - runReleaseCases(t, tests, func(c *fakeReleaseClient, out io.Writer) *cobra.Command { + runReleaseCases(t, tests, func(c *helm.FakeClient, out io.Writer) *cobra.Command { return newDeleteCmd(c, out) }) } diff --git a/vendor/k8s.io/helm/cmd/helm/dependency.go b/vendor/k8s.io/helm/cmd/helm/dependency.go index a61f1673..23165969 100644 --- a/vendor/k8s.io/helm/cmd/helm/dependency.go +++ b/vendor/k8s.io/helm/cmd/helm/dependency.go @@ -59,8 +59,8 @@ The 'version' field should contain a semantic version or version range. The 'repository' URL should point to a Chart Repository. Helm expects that by appending '/index.yaml' to the URL, it should be able to retrieve the chart -repository's index. Note: 'repository' cannot be a repository alias. It must be -a URL. +repository's index. Note: 'repository' can be an alias. The alias must start +with 'alias:' or '@'. Starting from 2.2.0, repository can be defined as the path to the directory of the dependency charts stored locally. The path should start with a prefix of diff --git a/vendor/k8s.io/helm/cmd/helm/dependency_update_test.go b/vendor/k8s.io/helm/cmd/helm/dependency_update_test.go index 227959c5..e29cb35d 100644 --- a/vendor/k8s.io/helm/cmd/helm/dependency_update_test.go +++ b/vendor/k8s.io/helm/cmd/helm/dependency_update_test.go @@ -172,6 +172,75 @@ func TestDependencyUpdateCmd_SkipRefresh(t *testing.T) { } } +func TestDependencyUpdateCmd_DontDeleteOldChartsOnError(t *testing.T) { + hh, err := tempHelmHome(t) + if err != nil { + t.Fatal(err) + } + cleanup := resetEnv() + defer func() { + os.RemoveAll(hh.String()) + cleanup() + }() + + settings.Home = hh + + srv := repotest.NewServer(hh.String()) + defer srv.Stop() + copied, err := srv.CopyCharts("testdata/testcharts/*.tgz") + if err != nil { + t.Fatal(err) + } + t.Logf("Copied charts:\n%s", strings.Join(copied, "\n")) + t.Logf("Listening on directory %s", srv.Root()) + + chartname := "depupdelete" + if err := createTestingChart(hh.String(), chartname, srv.URL()); err != nil { + t.Fatal(err) + } + + out := bytes.NewBuffer(nil) + duc := &dependencyUpdateCmd{out: out} + duc.helmhome = helmpath.Home(hh) + duc.chartpath = filepath.Join(hh.String(), chartname) + + if err := duc.run(); err != nil { + output := out.String() + t.Logf("Output: %s", output) + t.Fatal(err) + } + + // Chart repo is down + srv.Stop() + + if err := duc.run(); err == nil { + output := out.String() + t.Logf("Output: %s", output) + t.Fatal("Expected error, got nil") + } + + // Make sure charts dir still has dependencies + files, err := ioutil.ReadDir(filepath.Join(duc.chartpath, "charts")) + if err != nil { + t.Fatal(err) + } + dependencies := []string{"compressedchart-0.1.0.tgz", "reqtest-0.1.0.tgz"} + + if len(dependencies) != len(files) { + t.Fatalf("Expected %d chart dependencies, got %d", len(dependencies), len(files)) + } + for index, file := range files { + if dependencies[index] != file.Name() { + t.Fatalf("Chart dependency %s not matching %s", dependencies[index], file.Name()) + } + } + + // Make sure tmpcharts is deleted + if _, err := os.Stat(filepath.Join(duc.chartpath, "tmpcharts")); !os.IsNotExist(err) { + t.Fatalf("tmpcharts dir still exists") + } +} + // createTestingChart creates a basic chart that depends on reqtest-0.1.0 // // The baseURL can be used to point to a particular repository server. diff --git a/vendor/k8s.io/helm/cmd/helm/get_hooks_test.go b/vendor/k8s.io/helm/cmd/helm/get_hooks_test.go index 8d9eda2d..3e6132fb 100644 --- a/vendor/k8s.io/helm/cmd/helm/get_hooks_test.go +++ b/vendor/k8s.io/helm/cmd/helm/get_hooks_test.go @@ -21,6 +21,8 @@ import ( "testing" "github.com/spf13/cobra" + + "k8s.io/helm/pkg/helm" ) func TestGetHooks(t *testing.T) { @@ -37,7 +39,7 @@ func TestGetHooks(t *testing.T) { err: true, }, } - runReleaseCases(t, tests, func(c *fakeReleaseClient, out io.Writer) *cobra.Command { + runReleaseCases(t, tests, func(c *helm.FakeClient, out io.Writer) *cobra.Command { return newGetHooksCmd(c, out) }) } diff --git a/vendor/k8s.io/helm/cmd/helm/get_manifest_test.go b/vendor/k8s.io/helm/cmd/helm/get_manifest_test.go index 47d6d905..4ba80e2a 100644 --- a/vendor/k8s.io/helm/cmd/helm/get_manifest_test.go +++ b/vendor/k8s.io/helm/cmd/helm/get_manifest_test.go @@ -21,6 +21,8 @@ import ( "testing" "github.com/spf13/cobra" + + "k8s.io/helm/pkg/helm" ) func TestGetManifest(t *testing.T) { @@ -37,7 +39,7 @@ func TestGetManifest(t *testing.T) { err: true, }, } - runReleaseCases(t, tests, func(c *fakeReleaseClient, out io.Writer) *cobra.Command { + runReleaseCases(t, tests, func(c *helm.FakeClient, out io.Writer) *cobra.Command { return newGetManifestCmd(c, out) }) } diff --git a/vendor/k8s.io/helm/cmd/helm/get_test.go b/vendor/k8s.io/helm/cmd/helm/get_test.go index 77d8d4d1..23b82c04 100644 --- a/vendor/k8s.io/helm/cmd/helm/get_test.go +++ b/vendor/k8s.io/helm/cmd/helm/get_test.go @@ -21,6 +21,8 @@ import ( "testing" "github.com/spf13/cobra" + + "k8s.io/helm/pkg/helm" ) func TestGetCmd(t *testing.T) { @@ -37,7 +39,7 @@ func TestGetCmd(t *testing.T) { }, } - cmd := func(c *fakeReleaseClient, out io.Writer) *cobra.Command { + cmd := func(c *helm.FakeClient, out io.Writer) *cobra.Command { return newGetCmd(c, out) } runReleaseCases(t, tests, cmd) diff --git a/vendor/k8s.io/helm/cmd/helm/get_values_test.go b/vendor/k8s.io/helm/cmd/helm/get_values_test.go index 63516136..4032253f 100644 --- a/vendor/k8s.io/helm/cmd/helm/get_values_test.go +++ b/vendor/k8s.io/helm/cmd/helm/get_values_test.go @@ -21,6 +21,8 @@ import ( "testing" "github.com/spf13/cobra" + + "k8s.io/helm/pkg/helm" ) func TestGetValuesCmd(t *testing.T) { @@ -36,7 +38,7 @@ func TestGetValuesCmd(t *testing.T) { err: true, }, } - cmd := func(c *fakeReleaseClient, out io.Writer) *cobra.Command { + cmd := func(c *helm.FakeClient, out io.Writer) *cobra.Command { return newGetValuesCmd(c, out) } runReleaseCases(t, tests, cmd) diff --git a/vendor/k8s.io/helm/cmd/helm/helm_test.go b/vendor/k8s.io/helm/cmd/helm/helm_test.go index 833281a1..2a2af135 100644 --- a/vendor/k8s.io/helm/cmd/helm/helm_test.go +++ b/vendor/k8s.io/helm/cmd/helm/helm_test.go @@ -26,7 +26,6 @@ import ( "path/filepath" "regexp" "strings" - "sync" "testing" "github.com/golang/protobuf/ptypes/timestamp" @@ -36,8 +35,6 @@ import ( "k8s.io/helm/pkg/helm/helmpath" "k8s.io/helm/pkg/proto/hapi/chart" "k8s.io/helm/pkg/proto/hapi/release" - rls "k8s.io/helm/pkg/proto/hapi/services" - "k8s.io/helm/pkg/proto/hapi/version" "k8s.io/helm/pkg/repo" ) @@ -124,120 +121,15 @@ func releaseMock(opts *releaseOptions) *release.Release { } } -type fakeReleaseClient struct { - rels []*release.Release - responses map[string]release.TestRun_Status - err error -} - -var _ helm.Interface = &fakeReleaseClient{} -var _ helm.Interface = &helm.Client{} - -func (c *fakeReleaseClient) ListReleases(opts ...helm.ReleaseListOption) (*rls.ListReleasesResponse, error) { - resp := &rls.ListReleasesResponse{ - Count: int64(len(c.rels)), - Releases: c.rels, - } - return resp, c.err -} - -func (c *fakeReleaseClient) InstallRelease(chStr, ns string, opts ...helm.InstallOption) (*rls.InstallReleaseResponse, error) { - return &rls.InstallReleaseResponse{ - Release: c.rels[0], - }, nil -} - -func (c *fakeReleaseClient) InstallReleaseFromChart(chart *chart.Chart, ns string, opts ...helm.InstallOption) (*rls.InstallReleaseResponse, error) { - return &rls.InstallReleaseResponse{ - Release: c.rels[0], - }, nil -} - -func (c *fakeReleaseClient) DeleteRelease(rlsName string, opts ...helm.DeleteOption) (*rls.UninstallReleaseResponse, error) { - return nil, nil -} - -func (c *fakeReleaseClient) ReleaseStatus(rlsName string, opts ...helm.StatusOption) (*rls.GetReleaseStatusResponse, error) { - if c.rels[0] != nil { - return &rls.GetReleaseStatusResponse{ - Name: c.rels[0].Name, - Info: c.rels[0].Info, - Namespace: c.rels[0].Namespace, - }, nil - } - return nil, fmt.Errorf("No such release: %s", rlsName) -} - -func (c *fakeReleaseClient) GetVersion(opts ...helm.VersionOption) (*rls.GetVersionResponse, error) { - return &rls.GetVersionResponse{ - Version: &version.Version{ - SemVer: "1.2.3-fakeclient+testonly", - }, - }, nil -} - -func (c *fakeReleaseClient) UpdateRelease(rlsName string, chStr string, opts ...helm.UpdateOption) (*rls.UpdateReleaseResponse, error) { - return nil, nil -} - -func (c *fakeReleaseClient) UpdateReleaseFromChart(rlsName string, chart *chart.Chart, opts ...helm.UpdateOption) (*rls.UpdateReleaseResponse, error) { - return nil, nil -} - -func (c *fakeReleaseClient) RollbackRelease(rlsName string, opts ...helm.RollbackOption) (*rls.RollbackReleaseResponse, error) { - return nil, nil -} - -func (c *fakeReleaseClient) ReleaseContent(rlsName string, opts ...helm.ContentOption) (resp *rls.GetReleaseContentResponse, err error) { - if len(c.rels) > 0 { - resp = &rls.GetReleaseContentResponse{ - Release: c.rels[0], - } - } - return resp, c.err -} - -func (c *fakeReleaseClient) ReleaseHistory(rlsName string, opts ...helm.HistoryOption) (*rls.GetHistoryResponse, error) { - return &rls.GetHistoryResponse{Releases: c.rels}, c.err -} - -func (c *fakeReleaseClient) RunReleaseTest(rlsName string, opts ...helm.ReleaseTestOption) (<-chan *rls.TestReleaseResponse, <-chan error) { - - results := make(chan *rls.TestReleaseResponse) - errc := make(chan error, 1) - - go func() { - var wg sync.WaitGroup - for m, s := range c.responses { - wg.Add(1) - - go func(msg string, status release.TestRun_Status) { - defer wg.Done() - results <- &rls.TestReleaseResponse{Msg: msg, Status: status} - }(m, s) - } - - wg.Wait() - close(results) - close(errc) - }() - - return results, errc -} - -func (c *fakeReleaseClient) Option(opt ...helm.Option) helm.Interface { - return c -} - -// releaseCmd is a command that works with a fakeReleaseClient -type releaseCmd func(c *fakeReleaseClient, out io.Writer) *cobra.Command +// releaseCmd is a command that works with a FakeClient +type releaseCmd func(c *helm.FakeClient, out io.Writer) *cobra.Command // runReleaseCases runs a set of release cases through the given releaseCmd. func runReleaseCases(t *testing.T, tests []releaseCase, rcmd releaseCmd) { var buf bytes.Buffer for _, tt := range tests { - c := &fakeReleaseClient{ - rels: []*release.Release{tt.resp}, + c := &helm.FakeClient{ + Rels: []*release.Release{tt.resp}, } cmd := rcmd(c, &buf) cmd.ParseFlags(tt.flags) diff --git a/vendor/k8s.io/helm/cmd/helm/history_test.go b/vendor/k8s.io/helm/cmd/helm/history_test.go index 5f57e174..3ff4b4a8 100644 --- a/vendor/k8s.io/helm/cmd/helm/history_test.go +++ b/vendor/k8s.io/helm/cmd/helm/history_test.go @@ -21,6 +21,7 @@ import ( "regexp" "testing" + "k8s.io/helm/pkg/helm" rpb "k8s.io/helm/pkg/proto/hapi/release" ) @@ -66,7 +67,7 @@ func TestHistoryCmd(t *testing.T) { var buf bytes.Buffer for _, tt := range tests { - frc := &fakeReleaseClient{rels: tt.resp} + frc := &helm.FakeClient{Rels: tt.resp} cmd := newHistoryCmd(frc, &buf) cmd.ParseFlags(tt.args) diff --git a/vendor/k8s.io/helm/cmd/helm/init.go b/vendor/k8s.io/helm/cmd/helm/init.go index 64e6805d..b67dc3a2 100644 --- a/vendor/k8s.io/helm/cmd/helm/init.go +++ b/vendor/k8s.io/helm/cmd/helm/init.go @@ -33,14 +33,14 @@ import ( ) const initDesc = ` -This command installs Tiller (the helm server side component) onto your -Kubernetes Cluster and sets up local configuration in $HELM_HOME (default ~/.helm/) +This command installs Tiller (the Helm server-side component) onto your +Kubernetes Cluster and sets up local configuration in $HELM_HOME (default ~/.helm/). As with the rest of the Helm commands, 'helm init' discovers Kubernetes clusters by reading $KUBECONFIG (default '~/.kube/config') and using the default context. To set up just a local environment, use '--client-only'. That will configure -$HELM_HOME, but not attempt to connect to a remote cluster and install the Tiller +$HELM_HOME, but not attempt to connect to a Kubernetes cluster and install the Tiller deployment. When installing Tiller, 'helm init' will attempt to install the latest released @@ -99,23 +99,23 @@ func newInitCmd(out io.Writer) *cobra.Command { } f := cmd.Flags() - f.StringVarP(&i.image, "tiller-image", "i", "", "override tiller image") - f.BoolVar(&i.canary, "canary-image", false, "use the canary tiller image") - f.BoolVar(&i.upgrade, "upgrade", false, "upgrade if tiller is already installed") - f.BoolVarP(&i.clientOnly, "client-only", "c", false, "if set does not install tiller") + f.StringVarP(&i.image, "tiller-image", "i", "", "override Tiller image") + f.BoolVar(&i.canary, "canary-image", false, "use the canary Tiller image") + f.BoolVar(&i.upgrade, "upgrade", false, "upgrade if Tiller is already installed") + f.BoolVarP(&i.clientOnly, "client-only", "c", false, "if set does not install Tiller") f.BoolVar(&i.dryRun, "dry-run", false, "do not install local or remote") f.BoolVar(&i.skipRefresh, "skip-refresh", false, "do not refresh (download) the local repository cache") - f.BoolVar(&tlsEnable, "tiller-tls", false, "install tiller with TLS enabled") - f.BoolVar(&tlsVerify, "tiller-tls-verify", false, "install tiller with TLS enabled and to verify remote certificates") - f.StringVar(&tlsKeyFile, "tiller-tls-key", "", "path to TLS key file to install with tiller") - f.StringVar(&tlsCertFile, "tiller-tls-cert", "", "path to TLS certificate file to install with tiller") + f.BoolVar(&tlsEnable, "tiller-tls", false, "install Tiller with TLS enabled") + f.BoolVar(&tlsVerify, "tiller-tls-verify", false, "install Tiller with TLS enabled and to verify remote certificates") + f.StringVar(&tlsKeyFile, "tiller-tls-key", "", "path to TLS key file to install with Tiller") + f.StringVar(&tlsCertFile, "tiller-tls-cert", "", "path to TLS certificate file to install with Tiller") f.StringVar(&tlsCaCertFile, "tls-ca-cert", "", "path to CA root certificate") f.StringVar(&stableRepositoryURL, "stable-repo-url", stableRepositoryURL, "URL for stable repository") f.StringVar(&localRepositoryURL, "local-repo-url", localRepositoryURL, "URL for local repository") - f.BoolVar(&i.opts.EnableHostNetwork, "net-host", false, "install tiller with net=host") + f.BoolVar(&i.opts.EnableHostNetwork, "net-host", false, "install Tiller with net=host") f.StringVar(&i.serviceAccount, "service-account", "", "name of service account") return cmd @@ -147,7 +147,7 @@ func (i *initCmd) tlsOptions() error { return nil } -// runInit initializes local config and installs tiller to Kubernetes Cluster +// run initializes local config and installs Tiller to Kubernetes cluster. func (i *initCmd) run() error { if err := i.tlsOptions(); err != nil { return err @@ -244,23 +244,23 @@ func (i *initCmd) run() error { if err := installer.Upgrade(i.kubeClient, &i.opts); err != nil { return fmt.Errorf("error when upgrading: %s", err) } - fmt.Fprintln(i.out, "\nTiller (the helm server side component) has been upgraded to the current version.") + fmt.Fprintln(i.out, "\nTiller (the Helm server-side component) has been upgraded to the current version.") } else { fmt.Fprintln(i.out, "Warning: Tiller is already installed in the cluster.\n"+ "(Use --client-only to suppress this message, or --upgrade to upgrade Tiller to the current version.)") } } else { - fmt.Fprintln(i.out, "\nTiller (the helm server side component) has been installed into your Kubernetes Cluster.") + fmt.Fprintln(i.out, "\nTiller (the Helm server-side component) has been installed into your Kubernetes Cluster.") } } else { - fmt.Fprintln(i.out, "Not installing tiller due to 'client-only' flag having been set") + fmt.Fprintln(i.out, "Not installing Tiller due to 'client-only' flag having been set") } fmt.Fprintln(i.out, "Happy Helming!") return nil } -// ensureDirectories checks to see if $HELM_HOME exists +// ensureDirectories checks to see if $HELM_HOME exists. // // If $HELM_HOME does not exist, this function will create it. func ensureDirectories(home helmpath.Home, out io.Writer) error { diff --git a/vendor/k8s.io/helm/cmd/helm/init_test.go b/vendor/k8s.io/helm/cmd/helm/init_test.go index f937a87d..6547e234 100644 --- a/vendor/k8s.io/helm/cmd/helm/init_test.go +++ b/vendor/k8s.io/helm/cmd/helm/init_test.go @@ -67,7 +67,7 @@ func TestInitCmd(t *testing.T) { if !actions[1].Matches("create", "services") { t.Errorf("unexpected action: %v, expected create service", actions[1]) } - expected := "Tiller (the helm server side component) has been installed into your Kubernetes Cluster." + expected := "Tiller (the Helm server-side component) has been installed into your Kubernetes Cluster." if !strings.Contains(buf.String(), expected) { t.Errorf("expected %q, got %q", expected, buf.String()) } @@ -128,7 +128,7 @@ func TestInitCmd_clientOnly(t *testing.T) { if len(fc.Actions()) != 0 { t.Error("expected client call") } - expected := "Not installing tiller due to 'client-only' flag having been set" + expected := "Not installing Tiller due to 'client-only' flag having been set" if !strings.Contains(buf.String(), expected) { t.Errorf("expected %q, got %q", expected, buf.String()) } diff --git a/vendor/k8s.io/helm/cmd/helm/install.go b/vendor/k8s.io/helm/cmd/helm/install.go index ccd94d03..324f68c8 100644 --- a/vendor/k8s.io/helm/cmd/helm/install.go +++ b/vendor/k8s.io/helm/cmd/helm/install.go @@ -177,7 +177,7 @@ func newInstallCmd(c helm.Interface, out io.Writer) *cobra.Command { f := cmd.Flags() f.VarP(&inst.valueFiles, "values", "f", "specify values in a YAML file (can specify multiple)") f.StringVarP(&inst.name, "name", "n", "", "release name. If unspecified, it will autogenerate one for you") - f.StringVar(&inst.namespace, "namespace", "", "namespace to install the release into") + f.StringVar(&inst.namespace, "namespace", "", "namespace to install the release into. Defaults to the current kube config namespace.") f.BoolVar(&inst.dryRun, "dry-run", false, "simulate an install") f.BoolVar(&inst.disableHooks, "no-hooks", false, "prevent hooks from running during install") f.BoolVar(&inst.replace, "replace", false, "re-use the given name, even if that name is already used. This is unsafe in production") @@ -186,7 +186,7 @@ func newInstallCmd(c helm.Interface, out io.Writer) *cobra.Command { f.BoolVar(&inst.verify, "verify", false, "verify the package before installing it") f.StringVar(&inst.keyring, "keyring", defaultKeyring(), "location of public keys used for verification") f.StringVar(&inst.version, "version", "", "specify the exact chart version to install. If this is not specified, the latest version is installed") - f.Int64Var(&inst.timeout, "timeout", 300, "time in seconds to wait for any individual kubernetes operation (like Jobs for hooks)") + f.Int64Var(&inst.timeout, "timeout", 300, "time in seconds to wait for any individual Kubernetes operation (like Jobs for hooks)") f.BoolVar(&inst.wait, "wait", false, "if set, will wait until all Pods, PVCs, Services, and minimum number of Pods of a Deployment are in a ready state before marking the release as successful. It will wait for as long as --timeout") f.StringVar(&inst.repoURL, "repo", "", "chart repository url where to locate the requested chart") f.StringVar(&inst.certFile, "cert-file", "", "identify HTTPS client using this SSL certificate file") @@ -204,7 +204,7 @@ func (i *installCmd) run() error { i.namespace = defaultNamespace() } - rawVals, err := i.vals() + rawVals, err := vals(i.valueFiles, i.values) if err != nil { return err } @@ -302,11 +302,13 @@ func mergeValues(dest map[string]interface{}, src map[string]interface{}) map[st return dest } -func (i *installCmd) vals() ([]byte, error) { +// vals merges values from files specified via -f/--values and +// directly via --set, marshaling them to YAML +func vals(valueFiles valueFiles, values []string) ([]byte, error) { base := map[string]interface{}{} // User specified a values files via -f/--values - for _, filePath := range i.valueFiles { + for _, filePath := range valueFiles { currentMap := map[string]interface{}{} bytes, err := ioutil.ReadFile(filePath) if err != nil { @@ -321,7 +323,7 @@ func (i *installCmd) vals() ([]byte, error) { } // User specified a value via --set - for _, value := range i.values { + for _, value := range values { if err := strvals.ParseInto(value, base); err != nil { return []byte{}, fmt.Errorf("failed parsing --set data: %s", err) } diff --git a/vendor/k8s.io/helm/cmd/helm/install_test.go b/vendor/k8s.io/helm/cmd/helm/install_test.go index b2e47a1d..c68deb48 100644 --- a/vendor/k8s.io/helm/cmd/helm/install_test.go +++ b/vendor/k8s.io/helm/cmd/helm/install_test.go @@ -24,6 +24,8 @@ import ( "testing" "github.com/spf13/cobra" + + "k8s.io/helm/pkg/helm" ) func TestInstall(t *testing.T) { @@ -146,7 +148,7 @@ func TestInstall(t *testing.T) { }, } - runReleaseCases(t, tests, func(c *fakeReleaseClient, out io.Writer) *cobra.Command { + runReleaseCases(t, tests, func(c *helm.FakeClient, out io.Writer) *cobra.Command { return newInstallCmd(c, out) }) } diff --git a/vendor/k8s.io/helm/cmd/helm/installer/install.go b/vendor/k8s.io/helm/cmd/helm/installer/install.go index 0be52d38..8884e6ba 100644 --- a/vendor/k8s.io/helm/cmd/helm/installer/install.go +++ b/vendor/k8s.io/helm/cmd/helm/installer/install.go @@ -30,7 +30,7 @@ import ( "k8s.io/client-go/pkg/apis/extensions/v1beta1" ) -// Install uses kubernetes client to install tiller. +// Install uses Kubernetes client to install Tiller. // // Returns an error if the command failed. func Install(client kubernetes.Interface, opts *Options) error { @@ -48,7 +48,7 @@ func Install(client kubernetes.Interface, opts *Options) error { return nil } -// Upgrade uses kubernetes client to upgrade tiller to current version. +// Upgrade uses Kubernetes client to upgrade Tiller to current version. // // Returns an error if the command failed. func Upgrade(client kubernetes.Interface, opts *Options) error { @@ -62,7 +62,7 @@ func Upgrade(client kubernetes.Interface, opts *Options) error { if _, err := client.Extensions().Deployments(opts.Namespace).Update(obj); err != nil { return err } - // If the service does not exists that would mean we are upgrading from a tiller version + // If the service does not exists that would mean we are upgrading from a Tiller version // that didn't deploy the service, so install it. _, err = client.Core().Services(opts.Namespace).Get(serviceName, metav1.GetOptions{}) if apierrors.IsNotFound(err) { @@ -71,7 +71,7 @@ func Upgrade(client kubernetes.Interface, opts *Options) error { return err } -// createDeployment creates the Tiller deployment reource +// createDeployment creates the Tiller Deployment resource. func createDeployment(client extensionsclient.DeploymentsGetter, opts *Options) error { obj := deployment(opts) _, err := client.Deployments(obj.Namespace).Create(obj) @@ -251,7 +251,6 @@ func createSecret(client corev1.SecretsGetter, opts *Options) error { // generateSecret builds the secret object that hold Tiller secrets. func generateSecret(opts *Options) (*v1.Secret, error) { - const secretName = "tiller-secret" labels := generateLabels(map[string]string{"name": "tiller"}) secret := &v1.Secret{ diff --git a/vendor/k8s.io/helm/cmd/helm/installer/options.go b/vendor/k8s.io/helm/cmd/helm/installer/options.go index a76bb5d6..ddb7706f 100644 --- a/vendor/k8s.io/helm/cmd/helm/installer/options.go +++ b/vendor/k8s.io/helm/cmd/helm/installer/options.go @@ -25,51 +25,51 @@ import ( const defaultImage = "gcr.io/kubernetes-helm/tiller" -// Options control how to install tiller into a cluster, upgrade, and uninstall tiller from a cluster. +// Options control how to install Tiller into a cluster, upgrade, and uninstall Tiller from a cluster. type Options struct { - // EnableTLS instructs tiller to serve with TLS enabled. + // EnableTLS instructs Tiller to serve with TLS enabled. // // Implied by VerifyTLS. If set the TLSKey and TLSCert are required. EnableTLS bool - // VerifyTLS instructs tiller to serve with TLS enabled verify remote certificates. + // VerifyTLS instructs Tiller to serve with TLS enabled verify remote certificates. // // If set TLSKey, TLSCert, TLSCaCert are required. VerifyTLS bool - // UseCanary indicates that tiller should deploy using the latest tiller image. + // UseCanary indicates that Tiller should deploy using the latest Tiller image. UseCanary bool - // Namespace is the kubernetes namespace to use to deploy tiller. + // Namespace is the Kubernetes namespace to use to deploy Tiller. Namespace string - // ServiceAccount is the Kubernetes service account to add to tiller + // ServiceAccount is the Kubernetes service account to add to Tiller. ServiceAccount string - // ImageSpec indentifies the image tiller will use when deployed. + // ImageSpec indentifies the image Tiller will use when deployed. // // Valid if and only if UseCanary is false. ImageSpec string // TLSKeyFile identifies the file containing the pem encoded TLS private - // key tiller should use. + // key Tiller should use. // // Required and valid if and only if EnableTLS or VerifyTLS is set. TLSKeyFile string // TLSCertFile identifies the file containing the pem encoded TLS - // certificate tiller should use. + // certificate Tiller should use. // // Required and valid if and only if EnableTLS or VerifyTLS is set. TLSCertFile string // TLSCaCertFile identifies the file containing the pem encoded TLS CA - // certificate tiller should use to verify remotes certificates. + // certificate Tiller should use to verify remotes certificates. // // Required and valid if and only if VerifyTLS is set. TLSCaCertFile string - // EnableHostNetwork installs Tiller with net=host + // EnableHostNetwork installs Tiller with net=host. EnableHostNetwork bool } diff --git a/vendor/k8s.io/helm/cmd/helm/installer/uninstall.go b/vendor/k8s.io/helm/cmd/helm/installer/uninstall.go index 8c6c46bb..3d071096 100644 --- a/vendor/k8s.io/helm/cmd/helm/installer/uninstall.go +++ b/vendor/k8s.io/helm/cmd/helm/installer/uninstall.go @@ -28,14 +28,18 @@ import ( const ( deploymentName = "tiller-deploy" serviceName = "tiller-deploy" + secretName = "tiller-secret" ) -// Uninstall uses kubernetes client to uninstall tiller +// Uninstall uses Kubernetes client to uninstall Tiller. func Uninstall(client internalclientset.Interface, opts *Options) error { if err := deleteService(client.Core(), opts.Namespace); err != nil { return err } - return deleteDeployment(client, opts.Namespace) + if err := deleteDeployment(client, opts.Namespace); err != nil { + return err + } + return deleteSecret(client.Core(), opts.Namespace) } // deleteService deletes the Tiller Service resource @@ -53,6 +57,12 @@ func deleteDeployment(client internalclientset.Interface, namespace string) erro return ingoreNotFound(err) } +// deleteSecret deletes the Tiller Secret resource +func deleteSecret(client coreclient.SecretsGetter, namespace string) error { + err := client.Secrets(namespace).Delete(secretName, &metav1.DeleteOptions{}) + return ingoreNotFound(err) +} + func ingoreNotFound(err error) error { if apierrors.IsNotFound(err) { return nil diff --git a/vendor/k8s.io/helm/cmd/helm/installer/uninstall_test.go b/vendor/k8s.io/helm/cmd/helm/installer/uninstall_test.go index e7b32552..a6e9d1d3 100644 --- a/vendor/k8s.io/helm/cmd/helm/installer/uninstall_test.go +++ b/vendor/k8s.io/helm/cmd/helm/installer/uninstall_test.go @@ -34,8 +34,8 @@ func TestUninstall(t *testing.T) { t.Errorf("unexpected error: %#+v", err) } - if actions := fc.Actions(); len(actions) != 6 { - t.Errorf("unexpected actions: %v, expected 6 actions got %d", actions, len(actions)) + if actions := fc.Actions(); len(actions) != 7 { + t.Errorf("unexpected actions: %v, expected 7 actions got %d", actions, len(actions)) } } @@ -50,8 +50,8 @@ func TestUninstall_serviceNotFound(t *testing.T) { t.Errorf("unexpected error: %#+v", err) } - if actions := fc.Actions(); len(actions) != 6 { - t.Errorf("unexpected actions: %v, expected 6 actions got %d", actions, len(actions)) + if actions := fc.Actions(); len(actions) != 7 { + t.Errorf("unexpected actions: %v, expected 7 actions got %d", actions, len(actions)) } } @@ -66,7 +66,23 @@ func TestUninstall_deploymentNotFound(t *testing.T) { t.Errorf("unexpected error: %#+v", err) } - if actions := fc.Actions(); len(actions) != 6 { - t.Errorf("unexpected actions: %v, expected 6 actions got %d", actions, len(actions)) + if actions := fc.Actions(); len(actions) != 7 { + t.Errorf("unexpected actions: %v, expected 7 actions got %d", actions, len(actions)) + } +} + +func TestUninstall_secretNotFound(t *testing.T) { + fc := &fake.Clientset{} + fc.AddReactor("delete", "secrets", func(action testcore.Action) (bool, runtime.Object, error) { + return true, nil, apierrors.NewNotFound(api.Resource("secrets"), "1") + }) + + opts := &Options{Namespace: api.NamespaceDefault} + if err := Uninstall(fc, opts); err != nil { + t.Errorf("unexpected error: %#+v", err) + } + + if actions := fc.Actions(); len(actions) != 7 { + t.Errorf("unexpected actions: %v, expect 7 actions got %d", actions, len(actions)) } } diff --git a/vendor/k8s.io/helm/cmd/helm/list.go b/vendor/k8s.io/helm/cmd/helm/list.go index 391e83e2..f6cdaacf 100644 --- a/vendor/k8s.io/helm/cmd/helm/list.go +++ b/vendor/k8s.io/helm/cmd/helm/list.go @@ -72,6 +72,7 @@ type listCmd struct { failed bool namespace string superseded bool + pending bool client helm.Interface } @@ -104,11 +105,12 @@ func newListCmd(client helm.Interface, out io.Writer) *cobra.Command { f.BoolVarP(&list.sortDesc, "reverse", "r", false, "reverse the sort order") f.IntVarP(&list.limit, "max", "m", 256, "maximum number of releases to fetch") f.StringVarP(&list.offset, "offset", "o", "", "next release name in the list, used to offset from start value") - f.BoolVar(&list.all, "all", false, "show all releases, not just the ones marked DEPLOYED") + f.BoolVarP(&list.all, "all", "a", false, "show all releases, not just the ones marked DEPLOYED") f.BoolVar(&list.deleted, "deleted", false, "show deleted releases") f.BoolVar(&list.deleting, "deleting", false, "show releases that are currently being deleted") f.BoolVar(&list.deployed, "deployed", false, "show deployed releases. If no other is specified, this will be automatically enabled") f.BoolVar(&list.failed, "failed", false, "show failed releases") + f.BoolVar(&list.pending, "pending", false, "show pending releases") f.StringVar(&list.namespace, "namespace", "", "show releases within a specific namespace") // TODO: Do we want this as a feature of 'helm list'? @@ -173,6 +175,9 @@ func (l *listCmd) statusCodes() []release.Status_Code { release.Status_DELETED, release.Status_DELETING, release.Status_FAILED, + release.Status_PENDING_INSTALL, + release.Status_PENDING_UPGRADE, + release.Status_PENDING_ROLLBACK, } } status := []release.Status_Code{} @@ -191,6 +196,9 @@ func (l *listCmd) statusCodes() []release.Status_Code { if l.superseded { status = append(status, release.Status_SUPERSEDED) } + if l.pending { + status = append(status, release.Status_PENDING_INSTALL, release.Status_PENDING_UPGRADE, release.Status_PENDING_ROLLBACK) + } // Default case. if len(status) == 0 { diff --git a/vendor/k8s.io/helm/cmd/helm/list_test.go b/vendor/k8s.io/helm/cmd/helm/list_test.go index 611f4797..5660eb26 100644 --- a/vendor/k8s.io/helm/cmd/helm/list_test.go +++ b/vendor/k8s.io/helm/cmd/helm/list_test.go @@ -21,6 +21,7 @@ import ( "regexp" "testing" + "k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/proto/hapi/release" ) @@ -97,12 +98,32 @@ func TestListCmd(t *testing.T) { // See note on previous test. expected: "thomas-guide", }, + { + name: "with a pending release, multiple flags", + args: []string{"--all", "-q"}, + resp: []*release.Release{ + releaseMock(&releaseOptions{name: "thomas-guide", statusCode: release.Status_PENDING_INSTALL}), + releaseMock(&releaseOptions{name: "atlas-guide", statusCode: release.Status_DEPLOYED}), + }, + expected: "thomas-guide\natlas-guide", + }, + { + name: "with a pending release, pending flag", + args: []string{"--pending", "-q"}, + resp: []*release.Release{ + releaseMock(&releaseOptions{name: "thomas-guide", statusCode: release.Status_PENDING_INSTALL}), + releaseMock(&releaseOptions{name: "wild-idea", statusCode: release.Status_PENDING_UPGRADE}), + releaseMock(&releaseOptions{name: "crazy-maps", statusCode: release.Status_PENDING_ROLLBACK}), + releaseMock(&releaseOptions{name: "atlas-guide", statusCode: release.Status_DEPLOYED}), + }, + expected: "thomas-guide\nwild-idea\ncrazy-maps", + }, } var buf bytes.Buffer for _, tt := range tests { - c := &fakeReleaseClient{ - rels: tt.resp, + c := &helm.FakeClient{ + Rels: tt.resp, } cmd := newListCmd(c, &buf) cmd.ParseFlags(tt.args) diff --git a/vendor/k8s.io/helm/cmd/helm/load_plugins.go b/vendor/k8s.io/helm/cmd/helm/load_plugins.go index 2a02e819..2994126c 100644 --- a/vendor/k8s.io/helm/cmd/helm/load_plugins.go +++ b/vendor/k8s.io/helm/cmd/helm/load_plugins.go @@ -81,6 +81,7 @@ func loadPlugins(baseCmd *cobra.Command, out io.Writer) { prog := exec.Command(main, argv...) prog.Env = os.Environ() + prog.Stdin = os.Stdin prog.Stdout = out prog.Stderr = os.Stderr if err := prog.Run(); err != nil { diff --git a/vendor/k8s.io/helm/cmd/helm/release_testing.go b/vendor/k8s.io/helm/cmd/helm/release_testing.go index 1aadd4de..09a6330c 100644 --- a/vendor/k8s.io/helm/cmd/helm/release_testing.go +++ b/vendor/k8s.io/helm/cmd/helm/release_testing.go @@ -64,7 +64,7 @@ func newReleaseTestCmd(c helm.Interface, out io.Writer) *cobra.Command { } f := cmd.Flags() - f.Int64Var(&rlsTest.timeout, "timeout", 300, "time in seconds to wait for any individual kubernetes operation (like Jobs for hooks)") + f.Int64Var(&rlsTest.timeout, "timeout", 300, "time in seconds to wait for any individual Kubernetes operation (like Jobs for hooks)") f.BoolVar(&rlsTest.cleanup, "cleanup", false, "delete test pods upon completion") return cmd diff --git a/vendor/k8s.io/helm/cmd/helm/release_testing_test.go b/vendor/k8s.io/helm/cmd/helm/release_testing_test.go index 2c7a5867..02ab1883 100644 --- a/vendor/k8s.io/helm/cmd/helm/release_testing_test.go +++ b/vendor/k8s.io/helm/cmd/helm/release_testing_test.go @@ -20,6 +20,7 @@ import ( "bytes" "testing" + "k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/proto/hapi/release" ) @@ -82,7 +83,7 @@ func TestReleaseTesting(t *testing.T) { } for _, tt := range tests { - c := &fakeReleaseClient{responses: tt.responses} + c := &helm.FakeClient{Responses: tt.responses} buf := bytes.NewBuffer(nil) cmd := newReleaseTestCmd(c, buf) diff --git a/vendor/k8s.io/helm/cmd/helm/reset.go b/vendor/k8s.io/helm/cmd/helm/reset.go index c30c69c1..cc041506 100644 --- a/vendor/k8s.io/helm/cmd/helm/reset.go +++ b/vendor/k8s.io/helm/cmd/helm/reset.go @@ -32,7 +32,7 @@ import ( ) const resetDesc = ` -This command uninstalls Tiller (the helm server side component) from your +This command uninstalls Tiller (the Helm server-side component) from your Kubernetes Cluster and optionally deletes local configuration in $HELM_HOME (default ~/.helm/) ` @@ -77,7 +77,7 @@ func newResetCmd(client helm.Interface, out io.Writer) *cobra.Command { } f := cmd.Flags() - f.BoolVarP(&d.force, "force", "f", false, "forces Tiller uninstall even if there are releases installed, or if tiller is not in ready state") + f.BoolVarP(&d.force, "force", "f", false, "forces Tiller uninstall even if there are releases installed, or if Tiller is not in ready state") f.BoolVar(&d.removeHelmHome, "remove-helm-home", false, "if set deletes $HELM_HOME") return cmd @@ -114,7 +114,7 @@ func (d *resetCmd) run() error { } } - fmt.Fprintln(d.out, "Tiller (the helm server side component) has been uninstalled from your Kubernetes Cluster.") + fmt.Fprintln(d.out, "Tiller (the Helm server-side component) has been uninstalled from your Kubernetes Cluster.") return nil } diff --git a/vendor/k8s.io/helm/cmd/helm/reset_test.go b/vendor/k8s.io/helm/cmd/helm/reset_test.go index 5df8f223..d6febd13 100644 --- a/vendor/k8s.io/helm/cmd/helm/reset_test.go +++ b/vendor/k8s.io/helm/cmd/helm/reset_test.go @@ -26,6 +26,7 @@ import ( "k8s.io/kubernetes/pkg/api" "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/fake" + "k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/helm/helmpath" "k8s.io/helm/pkg/proto/hapi/release" ) @@ -38,7 +39,7 @@ func TestResetCmd(t *testing.T) { defer os.Remove(home) var buf bytes.Buffer - c := &fakeReleaseClient{} + c := &helm.FakeClient{} fc := fake.NewSimpleClientset() cmd := &resetCmd{ out: &buf, @@ -51,10 +52,10 @@ func TestResetCmd(t *testing.T) { t.Errorf("unexpected error: %v", err) } actions := fc.Actions() - if len(actions) != 2 { - t.Errorf("Expected 2 actions, got %d", len(actions)) + if len(actions) != 3 { + t.Errorf("Expected 3 actions, got %d", len(actions)) } - expected := "Tiller (the helm server side component) has been uninstalled from your Kubernetes Cluster." + expected := "Tiller (the Helm server-side component) has been uninstalled from your Kubernetes Cluster." if !strings.Contains(buf.String(), expected) { t.Errorf("expected %q, got %q", expected, buf.String()) } @@ -71,7 +72,7 @@ func TestResetCmd_removeHelmHome(t *testing.T) { defer os.Remove(home) var buf bytes.Buffer - c := &fakeReleaseClient{} + c := &helm.FakeClient{} fc := fake.NewSimpleClientset() cmd := &resetCmd{ removeHelmHome: true, @@ -85,10 +86,10 @@ func TestResetCmd_removeHelmHome(t *testing.T) { t.Errorf("unexpected error: %v", err) } actions := fc.Actions() - if len(actions) != 2 { - t.Errorf("Expected 2 actions, got %d", len(actions)) + if len(actions) != 3 { + t.Errorf("Expected 3 actions, got %d", len(actions)) } - expected := "Tiller (the helm server side component) has been uninstalled from your Kubernetes Cluster." + expected := "Tiller (the Helm server-side component) has been uninstalled from your Kubernetes Cluster." if !strings.Contains(buf.String(), expected) { t.Errorf("expected %q, got %q", expected, buf.String()) } @@ -108,8 +109,8 @@ func TestReset_deployedReleases(t *testing.T) { resp := []*release.Release{ releaseMock(&releaseOptions{name: "atlas-guide", statusCode: release.Status_DEPLOYED}), } - c := &fakeReleaseClient{ - rels: resp, + c := &helm.FakeClient{ + Rels: resp, } fc := fake.NewSimpleClientset() cmd := &resetCmd{ @@ -140,8 +141,8 @@ func TestReset_forceFlag(t *testing.T) { resp := []*release.Release{ releaseMock(&releaseOptions{name: "atlas-guide", statusCode: release.Status_DEPLOYED}), } - c := &fakeReleaseClient{ - rels: resp, + c := &helm.FakeClient{ + Rels: resp, } fc := fake.NewSimpleClientset() cmd := &resetCmd{ @@ -156,10 +157,10 @@ func TestReset_forceFlag(t *testing.T) { t.Errorf("unexpected error: %v", err) } actions := fc.Actions() - if len(actions) != 2 { - t.Errorf("Expected 2 actions, got %d", len(actions)) + if len(actions) != 3 { + t.Errorf("Expected 3 actions, got %d", len(actions)) } - expected := "Tiller (the helm server side component) has been uninstalled from your Kubernetes Cluster." + expected := "Tiller (the Helm server-side component) has been uninstalled from your Kubernetes Cluster." if !strings.Contains(buf.String(), expected) { t.Errorf("expected %q, got %q", expected, buf.String()) } diff --git a/vendor/k8s.io/helm/cmd/helm/rollback.go b/vendor/k8s.io/helm/cmd/helm/rollback.go index 95c27e2a..c55707f7 100644 --- a/vendor/k8s.io/helm/cmd/helm/rollback.go +++ b/vendor/k8s.io/helm/cmd/helm/rollback.go @@ -81,7 +81,7 @@ func newRollbackCmd(c helm.Interface, out io.Writer) *cobra.Command { f.BoolVar(&rollback.recreate, "recreate-pods", false, "performs pods restart for the resource if applicable") f.BoolVar(&rollback.force, "force", false, "force resource update through delete/recreate if needed") f.BoolVar(&rollback.disableHooks, "no-hooks", false, "prevent hooks from running during rollback") - f.Int64Var(&rollback.timeout, "timeout", 300, "time in seconds to wait for any individual kubernetes operation (like Jobs for hooks)") + f.Int64Var(&rollback.timeout, "timeout", 300, "time in seconds to wait for any individual Kubernetes operation (like Jobs for hooks)") f.BoolVar(&rollback.wait, "wait", false, "if set, will wait until all Pods, PVCs, Services, and minimum number of Pods of a Deployment are in a ready state before marking the release as successful. It will wait for as long as --timeout") return cmd diff --git a/vendor/k8s.io/helm/cmd/helm/rollback_test.go b/vendor/k8s.io/helm/cmd/helm/rollback_test.go index f0206824..f1479b2e 100644 --- a/vendor/k8s.io/helm/cmd/helm/rollback_test.go +++ b/vendor/k8s.io/helm/cmd/helm/rollback_test.go @@ -21,6 +21,8 @@ import ( "testing" "github.com/spf13/cobra" + + "k8s.io/helm/pkg/helm" ) func TestRollbackCmd(t *testing.T) { @@ -50,7 +52,7 @@ func TestRollbackCmd(t *testing.T) { }, } - cmd := func(c *fakeReleaseClient, out io.Writer) *cobra.Command { + cmd := func(c *helm.FakeClient, out io.Writer) *cobra.Command { return newRollbackCmd(c, out) } diff --git a/vendor/k8s.io/helm/cmd/helm/status_test.go b/vendor/k8s.io/helm/cmd/helm/status_test.go index 40729154..a1aaea5a 100644 --- a/vendor/k8s.io/helm/cmd/helm/status_test.go +++ b/vendor/k8s.io/helm/cmd/helm/status_test.go @@ -26,6 +26,7 @@ import ( "github.com/golang/protobuf/ptypes/timestamp" "github.com/spf13/cobra" + "k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/proto/hapi/release" "k8s.io/helm/pkg/timeconv" ) @@ -106,14 +107,14 @@ func TestStatusCmd(t *testing.T) { }, } - scmd := func(c *fakeReleaseClient, out io.Writer) *cobra.Command { + scmd := func(c *helm.FakeClient, out io.Writer) *cobra.Command { return newStatusCmd(c, out) } var buf bytes.Buffer for _, tt := range tests { - c := &fakeReleaseClient{ - rels: []*release.Release{tt.rel}, + c := &helm.FakeClient{ + Rels: []*release.Release{tt.rel}, } cmd := scmd(c, &buf) cmd.ParseFlags(tt.flags) diff --git a/vendor/k8s.io/helm/cmd/helm/upgrade.go b/vendor/k8s.io/helm/cmd/helm/upgrade.go index 7030740f..4b852198 100644 --- a/vendor/k8s.io/helm/cmd/helm/upgrade.go +++ b/vendor/k8s.io/helm/cmd/helm/upgrade.go @@ -19,16 +19,13 @@ package main import ( "fmt" "io" - "io/ioutil" "strings" - "github.com/ghodss/yaml" "github.com/spf13/cobra" "k8s.io/helm/pkg/chartutil" "k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/storage/driver" - "k8s.io/helm/pkg/strvals" ) const upgradeDesc = ` @@ -124,9 +121,9 @@ func newUpgradeCmd(client helm.Interface, out io.Writer) *cobra.Command { f.BoolVar(&upgrade.verify, "verify", false, "verify the provenance of the chart before upgrading") f.StringVar(&upgrade.keyring, "keyring", defaultKeyring(), "path to the keyring that contains public signing keys") f.BoolVarP(&upgrade.install, "install", "i", false, "if a release by this name doesn't already exist, run an install") - f.StringVar(&upgrade.namespace, "namespace", "default", "namespace to install the release into (only used if --install is set)") + f.StringVar(&upgrade.namespace, "namespace", "", "namespace to install the release into (only used if --install is set). Defaults to the current kube config namespace") f.StringVar(&upgrade.version, "version", "", "specify the exact chart version to use. If this is not specified, the latest version is used") - f.Int64Var(&upgrade.timeout, "timeout", 300, "time in seconds to wait for any individual kubernetes operation (like Jobs for hooks)") + f.Int64Var(&upgrade.timeout, "timeout", 300, "time in seconds to wait for any individual Kubernetes operation (like Jobs for hooks)") f.BoolVar(&upgrade.resetValues, "reset-values", false, "when upgrading, reset the values to the ones built into the chart") f.BoolVar(&upgrade.reuseValues, "reuse-values", false, "when upgrading, reuse the last release's values, and merge in any new values. If '--reset-values' is specified, this is ignored.") f.BoolVar(&upgrade.wait, "wait", false, "if set, will wait until all Pods, PVCs, Services, and minimum number of Pods of a Deployment are in a ready state before marking the release as successful. It will wait for as long as --timeout") @@ -176,7 +173,7 @@ func (u *upgradeCmd) run() error { } } - rawVals, err := u.vals() + rawVals, err := vals(u.valueFiles, u.values) if err != nil { return err } @@ -225,31 +222,3 @@ func (u *upgradeCmd) run() error { return nil } - -func (u *upgradeCmd) vals() ([]byte, error) { - base := map[string]interface{}{} - - // User specified a values files via -f/--values - for _, filePath := range u.valueFiles { - currentMap := map[string]interface{}{} - bytes, err := ioutil.ReadFile(filePath) - if err != nil { - return []byte{}, err - } - - if err := yaml.Unmarshal(bytes, ¤tMap); err != nil { - return []byte{}, fmt.Errorf("failed to parse %s: %s", filePath, err) - } - // Merge with the previous map - base = mergeValues(base, currentMap) - } - - // User specified a value via --set - for _, value := range u.values { - if err := strvals.ParseInto(value, base); err != nil { - return []byte{}, fmt.Errorf("failed parsing --set data: %s", err) - } - } - - return yaml.Marshal(base) -} diff --git a/vendor/k8s.io/helm/cmd/helm/upgrade_test.go b/vendor/k8s.io/helm/cmd/helm/upgrade_test.go index d9bff45b..1c5d1c85 100644 --- a/vendor/k8s.io/helm/cmd/helm/upgrade_test.go +++ b/vendor/k8s.io/helm/cmd/helm/upgrade_test.go @@ -26,6 +26,7 @@ import ( "github.com/spf13/cobra" "k8s.io/helm/pkg/chartutil" + "k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/proto/hapi/chart" ) @@ -152,7 +153,7 @@ func TestUpgradeCmd(t *testing.T) { }, } - cmd := func(c *fakeReleaseClient, out io.Writer) *cobra.Command { + cmd := func(c *helm.FakeClient, out io.Writer) *cobra.Command { return newUpgradeCmd(c, out) } diff --git a/vendor/k8s.io/helm/cmd/helm/version_test.go b/vendor/k8s.io/helm/cmd/helm/version_test.go index d22373b6..47520008 100644 --- a/vendor/k8s.io/helm/cmd/helm/version_test.go +++ b/vendor/k8s.io/helm/cmd/helm/version_test.go @@ -20,6 +20,7 @@ import ( "strings" "testing" + "k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/version" ) @@ -42,7 +43,7 @@ func TestVersion(t *testing.T) { settings.TillerHost = "fake-localhost" for _, tt := range tests { b := new(bytes.Buffer) - c := &fakeReleaseClient{} + c := &helm.FakeClient{} cmd := newVersionCmd(c, b) cmd.ParseFlags(tt.args) diff --git a/vendor/k8s.io/helm/docs/chart_best_practices/labels.md b/vendor/k8s.io/helm/docs/chart_best_practices/labels.md index d9e75c52..7c3ac51d 100644 --- a/vendor/k8s.io/helm/docs/chart_best_practices/labels.md +++ b/vendor/k8s.io/helm/docs/chart_best_practices/labels.md @@ -25,13 +25,8 @@ are recommended, and _should_ be placed onto a chart for global consistency. Tho Name|Status|Description -----|------|---------- -heritage | REC | This should always be set to `Tiller`. It is for finding all things managed by Tiller. +heritage | REC | This should always be set to `{{ .Release.Service }}`. It is for finding all things managed by Tiller. release | REC | This should be the `{{ .Release.Name }}`. -chart | REC | This should be the chart name and version: `{{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}`. -app | OPT | This should be the app name, reflecting the entire app. Often the chart's `{{ .Chart.Name }}` is used for this. This is used by many Kubernetes manifests, and is not Helm-specific. -component | OPT | This is a common label for marking the different roles that pieces may play in an application. For example, `component: frontend` - - - - - +chart | REC | This should be the chart name and version: `{{ .Chart.Name }}-{{ .Chart.Version \| replace "+" "_" }}`. +app | REC | This should be the app name, reflecting the entire app. Usually `{{ template "name" . }}` is used for this. This is used by many Kubernetes manifests, and is not Helm-specific. +component | OPT | This is a common label for marking the different roles that pieces may play in an application. For example, `component: frontend`. diff --git a/vendor/k8s.io/helm/docs/chart_template_guide/values_files.md b/vendor/k8s.io/helm/docs/chart_template_guide/values_files.md index 626aca3d..31b34175 100644 --- a/vendor/k8s.io/helm/docs/chart_template_guide/values_files.md +++ b/vendor/k8s.io/helm/docs/chart_template_guide/values_files.md @@ -98,4 +98,35 @@ data: While structuring data this way is possible, the recommendation is that you keep your values trees shallow, favoring flatness. When we look at assigning values to subcharts, we'll see how values are named using a tree structure. +## Deleting a default key + +If you need to delete a key from the default values, you may override the value of the key to be `null`, in which case Helm will remove the key from the overridden values merge. + +For example, the stable Drupal chart allows configuring the liveness probe, in case you configure a custom image. Here are the default values: +```yaml +livenessProbe: + httpGet: + path: /user/login + port: http + initialDelaySeconds: 120 +``` + +If you try to override the livenessProbe handler to `exec` instead of `httpGet` using `--set livenessProbe.exec.command=[cat,docroot/CHANGELOG.txt]`, Helm will coalesce the default and overridden keys together, resulting in the following YAML: +```yaml +livenessProbe: + httpGet: + path: /user/login + port: http + exec: + command: + - cat + - docroot/CHANGELOG.txt + initialDelaySeconds: 120 +``` + +However, Kubernetes would then fail because you can not declare more than one livenessProbe handler. To overcome this, you may instruct Helm to delete the `livenessProbe.httpGet` by setting it to null: +```sh +helm install stable/drupal --set image=my-registry/drupal:0.1.0 --set livenessProbe.exec.command=[cat,docroot/CHANGELOG.txt] --set livenessProbe.httpGet=null +``` + At this point, we've seen several built-in objects, and used them to inject information into a template. Now we will take a look at another aspect of the template engine: functions and pipelines. diff --git a/vendor/k8s.io/helm/docs/chart_tests.md b/vendor/k8s.io/helm/docs/chart_tests.md index 4311ffae..0d2ae3ee 100644 --- a/vendor/k8s.io/helm/docs/chart_tests.md +++ b/vendor/k8s.io/helm/docs/chart_tests.md @@ -2,7 +2,7 @@ A chart contains a number of Kubernetes resources and components that work together. As a chart author, you may want to write some tests that validate that your chart works as expected when it is installed. These tests also help the chart consumer understand what your chart is supposed to do. -A **test** in a helm chart lives under the `templates/` directory and is a pod definition that specifies a container with a given command to run. The container should exit successfully (exit 0) for a test to be considered a success. The pod definiton must contain one of the helm test hook annotations: `helm.sh/hooks: test-success` or `helm.sh/hooks: test-failure`. +A **test** in a helm chart lives under the `templates/` directory and is a pod definition that specifies a container with a given command to run. The container should exit successfully (exit 0) for a test to be considered a success. The pod definition must contain one of the helm test hook annotations: `helm.sh/hooks: test-success` or `helm.sh/hooks: test-failure`. Example tests: - Validate that your configuration from the values.yaml file was properly injected. @@ -27,26 +27,39 @@ Here is an example of a helm test pod definition in an example mariadb chart: ``` mariadb/ Chart.yaml - LICENSE README.md values.yaml charts/ templates/ - templates/mariadb-tests.yaml + templates/tests/test-mariadb-connection.yaml ``` -In `wordpress/templates/mariadb-tests.yaml`: +In `wordpress/templates/tests/test-mariadb-connection.yaml`: ``` apiVersion: v1 kind: Pod metadata: - name: "{{.Release.Name}}-credentials-test" + name: "{{ .Release.Name }}-credentials-test" annotations: "helm.sh/hook": test-success spec: containers: - - name: {{.Release.Name}}-credentials-test - image: bitnami/mariadb:{{.Values.imageTag}} - command: ["mysql", "--host={{.Release.Name}}-mariadb", "--user={{.Values.mariadbUser}}", "--password={{.Values.mariadbPassword}}"] + - name: {{ .Release.Name }}-credentials-test + image: {{ .Values.image }} + env: + - name: MARIADB_HOST + value: {{ template "mariadb.fullname" . }} + - name: MARIADB_PORT + value: "3306" + - name: WORDPRESS_DATABASE_NAME + value: {{ default "" .Values.mariadb.mariadbDatabase | quote }} + - name: WORDPRESS_DATABASE_USER + value: {{ default "" .Values.mariadb.mariadbUser | quote }} + - name: WORDPRESS_DATABASE_PASSWORD + valueFrom: + secretKeyRef: + name: {{ template "mariadb.fullname" . }} + key: mariadb-password + command: ["sh", "-c", "mysql --host=$MARIADB_HOST --port=$MARIADB_PORT --user=$WORDPRESS_DATABASE_USER --password=$WORDPRESS_DATABASE_PASSWORD"] restartPolicy: Never ``` diff --git a/vendor/k8s.io/helm/docs/charts.md b/vendor/k8s.io/helm/docs/charts.md index 071eb498..81c3d44f 100644 --- a/vendor/k8s.io/helm/docs/charts.md +++ b/vendor/k8s.io/helm/docs/charts.md @@ -25,6 +25,7 @@ wordpress/ Chart.yaml # A YAML file containing information about the chart LICENSE # OPTIONAL: A plain text file containing the license for the chart README.md # OPTIONAL: A human-readable README file + requirements.yaml # OPTIONAL: A YAML file listing dependencies for the chart values.yaml # The default configuration values for this chart charts/ # OPTIONAL: A directory containing any charts upon which this chart depends. templates/ # OPTIONAL: A directory of templates that, when combined with values, @@ -138,48 +139,20 @@ for greater detail. ## Chart Dependencies -In Helm, one chart may depend on any number of other charts. These -dependencies are expressed explicitly by copying the dependency charts -into the `charts/` directory. +In Helm, one chart may depend on any number of other charts. +These dependencies can be dynamically linked through the `requirements.yaml` +file or brought in to the `charts/` directory and managed manually. -A dependency can be either a chart archive (`foo-1.2.3.tgz`) or an -unpacked chart directory. But its name cannot start with `_` or `.`. -Such files are ignored by the chart loader. +Although manually managing your dependencies has a few advantages some teams need, +the preferred method of declaring dependencies is by using a +`requirements.yaml` file inside of your chart. **Note:** The `dependencies:` section of the `Chart.yaml` from Helm Classic has been completely removed. -For example, if the WordPress chart depends on the Apache chart, the -Apache chart (of the correct version) is supplied in the WordPress -chart's `charts/` directory: - -``` -wordpress: - Chart.yaml - requirements.yaml - # ... - charts/ - apache/ - Chart.yaml - # ... - mysql/ - Chart.yaml - # ... -``` - -The example above shows how the WordPress chart expresses its dependency -on Apache and MySQL by including those charts inside of its `charts/` -directory. - -**TIP:** _To drop a dependency into your `charts/` directory, use the -`helm fetch` command or use a `requirements.yaml` file_ ### Managing Dependencies with `requirements.yaml` -While Helm will allow you to manually manage your dependencies, the -preferred method of declaring dependencies is by using a -`requirements.yaml` file inside of your chart. - A `requirements.yaml` file is a simple file for listing your dependencies. @@ -240,31 +213,31 @@ a chart in dependencies using alias as name of new dependency. One can use `alias` in cases where they need to access a chart with other name(s). -```` +```yaml # parentchart/requirements.yaml dependencies: - - name: subchart - repository: http://localhost:10191 - version: 0.1.0 - alias: new-subchart-1 - - name: subchart - repository: http://localhost:10191 - version: 0.1.0 - alias: new-subchart-2 - - name: subchart - repository: http://localhost:10191 - version: 0.1.0 -```` + - name: subchart + repository: http://localhost:10191 + version: 0.1.0 + alias: new-subchart-1 + - name: subchart + repository: http://localhost:10191 + version: 0.1.0 + alias: new-subchart-2 + - name: subchart + repository: http://localhost:10191 + version: 0.1.0 +``` -In the above example we will get 3 depenendencies in all for `parentchart` +In the above example we will get 3 dependencies in all for `parentchart` ``` subchart new-subchart-1 new-subchart-2 ``` -Manual way of achieving this is copy/pasting same chart in -`charts/` directory multiple times with different name. +The manual way of achieving this is by copy/pasting the same chart in the +`charts/` directory multiple times with different names. #### Tags and Condition fields in requirements.yaml @@ -441,6 +414,41 @@ myimports: The parent's final values now contains the `myint` and `mybool` fields imported from subchart1. +### Managing Dependencies manually via the `charts/` directory + +If more control over dependencies is desired, these dependencies can +be expressed explicitly by copying the dependency charts into the +`charts/` directory. + +A dependency can be either a chart archive (`foo-1.2.3.tgz`) or an +unpacked chart directory. But its name cannot start with `_` or `.`. +Such files are ignored by the chart loader. + +For example, if the WordPress chart depends on the Apache chart, the +Apache chart (of the correct version) is supplied in the WordPress +chart's `charts/` directory: + +``` +wordpress: + Chart.yaml + requirements.yaml + # ... + charts/ + apache/ + Chart.yaml + # ... + mysql/ + Chart.yaml + # ... +``` + +The example above shows how the WordPress chart expresses its dependency +on Apache and MySQL by including those charts inside of its `charts/` +directory. + +**TIP:** _To drop a dependency into your `charts/` directory, use the +`helm fetch` command_ + ## Templates and Values Helm Chart templates are written in the @@ -561,7 +569,7 @@ that supplies the necessary values would look like this: ```yaml imageRegistry: "quay.io/deis" dockerTag: "latest" -pullPolicy: "alwaysPull" +pullPolicy: "Always" storage: "s3" ``` @@ -587,7 +595,7 @@ generated content will be: ```yaml imageRegistry: "quay.io/deis" dockerTag: "latest" -pullPolicy: "alwaysPull" +pullPolicy: "Always" storage: "gcs" ``` diff --git a/vendor/k8s.io/helm/docs/examples/alpine/Chart.yaml b/vendor/k8s.io/helm/docs/examples/alpine/Chart.yaml index e4c7ab7b..f4b660d4 100644 --- a/vendor/k8s.io/helm/docs/examples/alpine/Chart.yaml +++ b/vendor/k8s.io/helm/docs/examples/alpine/Chart.yaml @@ -1,7 +1,7 @@ name: alpine description: Deploy a basic Alpine Linux pod version: 0.1.0 -home: https://k8s.io/helm +home: https://github.com/kubernetes/helm sources: - https://github.com/kubernetes/helm appVersion: 3.3 diff --git a/vendor/k8s.io/helm/docs/examples/alpine/README.md b/vendor/k8s.io/helm/docs/examples/alpine/README.md index eb4fb957..3e354724 100644 --- a/vendor/k8s.io/helm/docs/examples/alpine/README.md +++ b/vendor/k8s.io/helm/docs/examples/alpine/README.md @@ -2,8 +2,6 @@ Run a single pod of Alpine Linux. -This example was generated using the command `helm create alpine`. - The `templates/` directory contains a very simple pod resource with a couple of parameters. diff --git a/vendor/k8s.io/helm/docs/examples/alpine/templates/_helpers.tpl b/vendor/k8s.io/helm/docs/examples/alpine/templates/_helpers.tpl new file mode 100644 index 00000000..f0d83d2e --- /dev/null +++ b/vendor/k8s.io/helm/docs/examples/alpine/templates/_helpers.tpl @@ -0,0 +1,16 @@ +{{/* vim: set filetype=mustache: */}} +{{/* +Expand the name of the chart. +*/}} +{{- define "name" -}} +{{- default .Chart.Name .Values.nameOverride | trunc 63 | trimSuffix "-" -}} +{{- end -}} + +{{/* +Create a default fully qualified app name. +We truncate at 63 chars because some Kubernetes name fields are limited to this (by the DNS naming spec). +*/}} +{{- define "fullname" -}} +{{- $name := default .Chart.Name .Values.nameOverride -}} +{{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" -}} +{{- end -}} diff --git a/vendor/k8s.io/helm/docs/examples/alpine/templates/alpine-pod.yaml b/vendor/k8s.io/helm/docs/examples/alpine/templates/alpine-pod.yaml index c15ab8ef..14995675 100644 --- a/vendor/k8s.io/helm/docs/examples/alpine/templates/alpine-pod.yaml +++ b/vendor/k8s.io/helm/docs/examples/alpine/templates/alpine-pod.yaml @@ -1,26 +1,23 @@ apiVersion: v1 kind: Pod metadata: - name: "{{.Release.Name}}-{{.Values.Name}}" + name: {{ template "fullname" . }} labels: # The "heritage" label is used to track which tool deployed a given chart. # It is useful for admins who want to see what releases a particular tool # is responsible for. - heritage: {{.Release.Service | quote }} + heritage: {{ .Release.Service }} # The "release" convention makes it easy to tie a release to all of the # Kubernetes resources that were created as part of that release. - release: {{.Release.Name | quote }} + release: {{ .Release.Name }} # This makes it easy to audit chart usage. - chart: "{{.Chart.Name}}-{{.Chart.Version}}" - annotations: - "helm.sh/created": {{.Release.Time.Seconds | quote }} + chart: {{ .Chart.Name }}-{{ .Chart.Version }} + app: {{ template "name" . }} spec: - # This shows how to use a simple value. This will look for a passed-in value - # called restartPolicy. If it is not found, it will use the default value. - # {{default "Never" .restartPolicy}} is a slightly optimized version of the - # more conventional syntax: {{.restartPolicy | default "Never"}} - restartPolicy: {{default "Never" .Values.restartPolicy}} + # This shows how to use a simple value. This will look for a passed-in value called restartPolicy. + restartPolicy: {{ .Values.restartPolicy }} containers: - name: waiter - image: "alpine:3.3" - command: ["/bin/sleep","9000"] + image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}" + imagePullPolicy: {{ .Values.image.pullPolicy }} + command: ["/bin/sleep", "9000"] diff --git a/vendor/k8s.io/helm/docs/examples/alpine/values.yaml b/vendor/k8s.io/helm/docs/examples/alpine/values.yaml index 879d760f..afe8cc6c 100644 --- a/vendor/k8s.io/helm/docs/examples/alpine/values.yaml +++ b/vendor/k8s.io/helm/docs/examples/alpine/values.yaml @@ -1,2 +1,6 @@ -# The pod name -Name: my-alpine +image: + repository: alpine + tag: 3.3 + pullPolicy: IfNotPresent + +restartPolicy: Never diff --git a/vendor/k8s.io/helm/docs/examples/nginx/Chart.yaml b/vendor/k8s.io/helm/docs/examples/nginx/Chart.yaml index 3f8b7332..6ca92998 100644 --- a/vendor/k8s.io/helm/docs/examples/nginx/Chart.yaml +++ b/vendor/k8s.io/helm/docs/examples/nginx/Chart.yaml @@ -6,9 +6,9 @@ keywords: - nginx - www - web -home: "https://github.com/kubernetes/helm" +home: https://github.com/kubernetes/helm sources: - - "https://hub.docker.com/_/nginx/" + - https://hub.docker.com/_/nginx/ maintainers: - name: technosophos email: mbutcher@deis.com diff --git a/vendor/k8s.io/helm/docs/examples/nginx/README.md b/vendor/k8s.io/helm/docs/examples/nginx/README.md index a156d70d..9b53e213 100644 --- a/vendor/k8s.io/helm/docs/examples/nginx/README.md +++ b/vendor/k8s.io/helm/docs/examples/nginx/README.md @@ -13,7 +13,7 @@ pattern: - A `Deployment` is used to create a Replica Set of nginx pods. ([templates/deployment.yaml](templates/deployment.yaml)) - A `Service` is used to create a gateway to the pods running in the - replica set ([templates/svc.yaml](templates/svc.yaml)) + replica set ([templates/svc.yaml](templates/service.yaml)) The [values.yaml](values.yaml) exposes a few of the configuration options in the charts, though there are some that are not exposed there (like diff --git a/vendor/k8s.io/helm/docs/examples/nginx/templates/_helpers.tpl b/vendor/k8s.io/helm/docs/examples/nginx/templates/_helpers.tpl index 24f76db7..f0d83d2e 100644 --- a/vendor/k8s.io/helm/docs/examples/nginx/templates/_helpers.tpl +++ b/vendor/k8s.io/helm/docs/examples/nginx/templates/_helpers.tpl @@ -2,15 +2,15 @@ {{/* Expand the name of the chart. */}} -{{define "name"}}{{default "nginx" .Values.nameOverride | trunc 63 | trimSuffix "-" }}{{end}} +{{- define "name" -}} +{{- default .Chart.Name .Values.nameOverride | trunc 63 | trimSuffix "-" -}} +{{- end -}} {{/* Create a default fully qualified app name. - -We truncate at 63 chars because some Kubernetes name fields are limited to this -(by the DNS naming spec). +We truncate at 63 chars because some Kubernetes name fields are limited to this (by the DNS naming spec). */}} -{{define "fullname"}} -{{- $name := default "nginx" .Values.nameOverride -}} -{{printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" -}} -{{end}} +{{- define "fullname" -}} +{{- $name := default .Chart.Name .Values.nameOverride -}} +{{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" -}} +{{- end -}} diff --git a/vendor/k8s.io/helm/docs/examples/nginx/templates/configmap.yaml b/vendor/k8s.io/helm/docs/examples/nginx/templates/configmap.yaml index ec4b9e5c..641e62ea 100644 --- a/vendor/k8s.io/helm/docs/examples/nginx/templates/configmap.yaml +++ b/vendor/k8s.io/helm/docs/examples/nginx/templates/configmap.yaml @@ -1,15 +1,14 @@ -# This is a simple example of using a config map to create a single page -# static site. +# This is a simple example of using a config map to create a single page static site. apiVersion: v1 kind: ConfigMap metadata: - name: {{template "fullname" .}} + name: {{ template "fullname" . }} labels: - release: {{ .Release.Name | quote }} - app: {{template "fullname" .}} - heritage: {{.Release.Service | quote }} + heritage: {{ .Release.Service }} + release: {{ .Release.Name }} + chart: {{ .Chart.Name }}-{{ .Chart.Version }} + app: {{ template "name" . }} data: - # When the config map is mounted as a volume, these will be created as - # files. - index.html: {{default "Hello" .Values.index | quote}} + # When the config map is mounted as a volume, these will be created as files. + index.html: {{ .Values.index | quote }} test.txt: test diff --git a/vendor/k8s.io/helm/docs/examples/nginx/templates/deployment.yaml b/vendor/k8s.io/helm/docs/examples/nginx/templates/deployment.yaml index e31bd542..ca929c27 100644 --- a/vendor/k8s.io/helm/docs/examples/nginx/templates/deployment.yaml +++ b/vendor/k8s.io/helm/docs/examples/nginx/templates/deployment.yaml @@ -4,39 +4,54 @@ metadata: # This uses a "fullname" template (see _helpers) # Basing names on .Release.Name means that the same chart can be installed # multiple times into the same namespace. - name: {{template "fullname" .}} + name: {{ template "fullname" . }} labels: # The "heritage" label is used to track which tool deployed a given chart. # It is useful for admins who want to see what releases a particular tool # is responsible for. - heritage: {{ .Release.Service | quote }} - # This makes it easy to search for all components of a release using kubectl. - release: {{ .Release.Name | quote }} + heritage: {{ .Release.Service }} + # The "release" convention makes it easy to tie a release to all of the + # Kubernetes resources that were created as part of that release. + release: {{ .Release.Name }} # This makes it easy to audit chart usage. - chart: "{{.Chart.Name}}-{{.Chart.Version}}" + chart: {{ .Chart.Name }}-{{ .Chart.Version }} + app: {{ template "name" . }} spec: - replicas: {{default 1 .Values.replicaCount}} + replicas: {{ .Values.replicaCount }} template: metadata: +{{- if .Values.podAnnotations }} + # Allows custom annotations to be specified + annotations: +{{ toYaml .Values.podAnnotations | indent 8 }} +{{- end }} labels: - app: {{template "fullname" .}} - release: {{.Release.Name | quote }} + app: {{ template "name" . }} + release: {{ .Release.Name }} spec: containers: - - name: nginx - # Making image configurable is not necessary. Making imageTag configurable - # is a nice option for the user. Especially in the strange cases like - # nginx where the base distro is determined by the tag. Using :latest - # is frowned upon, using :stable isn't that great either. - image: "{{default "nginx" .Values.image}}:{{default "stable-alpine" .Values.imageTag}}" - imagePullPolicy: {{default "IfNotPresent" .Values.pullPolicy}} - ports: - - containerPort: 80 - # This (and the volumes section below) mount the config map as a volume. - volumeMounts: - - mountPath: /usr/share/nginx/html - name: wwwdata-volume + - name: {{ template "name" . }} + image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}" + imagePullPolicy: {{ .Values.image.pullPolicy }} + ports: + - name: http + containerPort: 80 + protocol: TCP + # This (and the volumes section below) mount the config map as a volume. + volumeMounts: + - mountPath: /usr/share/nginx/html + name: wwwdata-volume + resources: +# Allow chart users to specify resources. Usually, no default should be set, so this is left to be a conscious +# choice to the chart users and avoids that charts don't run out of the box on, e. g., Minikube when high resource +# requests are specified by default. +{{ toYaml .Values.resources | indent 12 }} + {{- if .Values.nodeSelector }} + nodeSelector: + # Node selectors can be important on mixed Windows/Linux clusters. +{{ toYaml .Values.nodeSelector | indent 8 }} + {{- end }} volumes: - name: wwwdata-volume configMap: - name: {{template "fullname" .}} + name: {{ template "fullname" . }} diff --git a/vendor/k8s.io/helm/docs/examples/nginx/templates/post-install-job.yaml b/vendor/k8s.io/helm/docs/examples/nginx/templates/post-install-job.yaml index a2281a8f..06e7024f 100644 --- a/vendor/k8s.io/helm/docs/examples/nginx/templates/post-install-job.yaml +++ b/vendor/k8s.io/helm/docs/examples/nginx/templates/post-install-job.yaml @@ -1,11 +1,18 @@ apiVersion: batch/v1 kind: Job metadata: - name: "{{template "fullname" . }}" + name: {{ template "fullname" . }} labels: - heritage: {{.Release.Service | quote }} - release: {{.Release.Name | quote }} - chart: "{{.Chart.Name}}-{{.Chart.Version}}" + # The "heritage" label is used to track which tool deployed a given chart. + # It is useful for admins who want to see what releases a particular tool + # is responsible for. + heritage: {{ .Release.Service }} + # The "release" convention makes it easy to tie a release to all of the + # Kubernetes resources that were created as part of that release. + release: {{ .Release.Name }} + # This makes it easy to audit chart usage. + chart: {{ .Chart.Name }}-{{ .Chart.Version }} + app: {{ template "name" . }} annotations: # This is what defines this resource as a hook. Without this line, the # job is considered part of the release. @@ -13,19 +20,18 @@ metadata: spec: template: metadata: - name: "{{template "fullname" . }}" + name: {{ template "fullname" . }} labels: - heritage: {{.Release.Service | quote }} - release: {{.Release.Name | quote }} - chart: "{{.Chart.Name}}-{{.Chart.Version}}" + release: {{ .Release.Name }} + app: {{ template "name" . }} spec: # This shows how to use a simple value. This will look for a passed-in value # called restartPolicy. If it is not found, it will use the default value. - # {{default "Never" .restartPolicy}} is a slightly optimized version of the - # more conventional syntax: {{.restartPolicy | default "Never"}} - restartPolicy: Never + # {{ default "Never" .restartPolicy }} is a slightly optimized version of the + # more conventional syntax: {{ .restartPolicy | default "Never" }} + restartPolicy: {{ .Values.restartPolicy }} containers: - - name: post-install-job - image: "alpine:3.3" - # All we're going to do is sleep for a minute, then exit. - command: ["/bin/sleep","{{default "10" .Values.sleepyTime}}"] + - name: post-install-job + image: "alpine:3.3" + # All we're going to do is sleep for a while, then exit. + command: ["/bin/sleep", "{{ .Values.sleepyTime }}"] diff --git a/vendor/k8s.io/helm/docs/examples/nginx/templates/pre-install-secret.yaml b/vendor/k8s.io/helm/docs/examples/nginx/templates/pre-install-secret.yaml index c2ca3e1d..405f4e53 100644 --- a/vendor/k8s.io/helm/docs/examples/nginx/templates/pre-install-secret.yaml +++ b/vendor/k8s.io/helm/docs/examples/nginx/templates/pre-install-secret.yaml @@ -3,7 +3,12 @@ apiVersion: v1 kind: Secret metadata: - name: "{{.Release.Name}}-secret" + name: {{ template "fullname" . }} + labels: + heritage: {{ .Release.Service }} + release: {{ .Release.Name }} + chart: {{ .Chart.Name }}-{{ .Chart.Version }} + app: {{ template "name" . }} # This declares the resource to be a hook. By convention, we also name the # file "pre-install-XXX.yaml", but Helm itself doesn't care about file names. annotations: diff --git a/vendor/k8s.io/helm/docs/examples/nginx/templates/service-test.yaml b/vendor/k8s.io/helm/docs/examples/nginx/templates/service-test.yaml index 0accd4c2..107b19a7 100644 --- a/vendor/k8s.io/helm/docs/examples/nginx/templates/service-test.yaml +++ b/vendor/k8s.io/helm/docs/examples/nginx/templates/service-test.yaml @@ -1,7 +1,12 @@ apiVersion: v1 kind: Pod metadata: - name: "{{.Release.Name}}-service-test" + name: "{{ template "fullname" . }}-service-test" + labels: + heritage: {{ .Release.Service }} + release: {{ .Release.Name }} + chart: {{ .Chart.Name }}-{{ .Chart.Version }} + app: {{ template "name" . }} annotations: "helm.sh/hook": test-success spec: @@ -9,5 +14,5 @@ spec: - name: curl image: radial/busyboxplus:curl command: ['curl'] - args: [ '{{ template "fullname" .}}:{{default 80 .Values.httpPort}}' ] + args: ['{{ template "fullname" . }}:{{ .Values.service.port }}'] restartPolicy: Never diff --git a/vendor/k8s.io/helm/docs/examples/nginx/templates/service.yaml b/vendor/k8s.io/helm/docs/examples/nginx/templates/service.yaml new file mode 100644 index 00000000..bad29b14 --- /dev/null +++ b/vendor/k8s.io/helm/docs/examples/nginx/templates/service.yaml @@ -0,0 +1,39 @@ +apiVersion: v1 +kind: Service +metadata: +{{- if .Values.service.annotations }} + annotations: +{{ toYaml .Values.service.annotations | indent 4 }} +{{- end }} + labels: + app: {{ template "name" . }} + chart: {{ .Chart.Name }}-{{ .Chart.Version }} + heritage: {{ .Release.Service }} + release: {{ .Release.Name }} + name: {{ template "fullname" . }} +spec: +# Provides options for the service so chart users have the full choice + type: "{{ .Values.service.type }}" + clusterIP: "{{ .Values.service.clusterIP }}" +{{- if .Values.service.externalIPs }} + externalIPs: +{{ toYaml .Values.service.externalIPs | indent 4 }} +{{- end }} +{{- if .Values.service.loadBalancerIP }} + loadBalancerIP: "{{ .Values.service.loadBalancerIP }}" +{{- end }} +{{- if .Values.service.loadBalancerSourceRanges }} + loadBalancerSourceRanges: +{{ toYaml .Values.service.loadBalancerSourceRanges | indent 4 }} +{{- end }} + ports: + - name: http + port: {{ .Values.service.port }} + protocol: TCP + targetPort: http + {{- if (and (eq .Values.service.type "NodePort") (not (empty .Values.service.nodePort))) }} + nodePort: {{ .Values.service.nodePort }} + {{- end }} + selector: + app: {{ template "name" . }} + release: {{ .Release.Name }} diff --git a/vendor/k8s.io/helm/docs/examples/nginx/templates/svc.yaml b/vendor/k8s.io/helm/docs/examples/nginx/templates/svc.yaml deleted file mode 100644 index 98f7d0ec..00000000 --- a/vendor/k8s.io/helm/docs/examples/nginx/templates/svc.yaml +++ /dev/null @@ -1,18 +0,0 @@ -# This is a service gateway to the replica set created by the deployment. -# Take a look at the deployment.yaml for general notes about this chart. -apiVersion: v1 -kind: Service -metadata: - name: {{template "fullname" .}} - labels: - heritage: {{ .Release.Service | quote }} - release: {{ .Release.Name | quote }} - chart: "{{.Chart.Name}}-{{.Chart.Version}}" -spec: - ports: - - port: {{default 80 .Values.httpPort}} - targetPort: 80 - protocol: TCP - name: http - selector: - app: {{template "fullname" .}} diff --git a/vendor/k8s.io/helm/docs/examples/nginx/values.yaml b/vendor/k8s.io/helm/docs/examples/nginx/values.yaml index e0aff99b..b40208cc 100644 --- a/vendor/k8s.io/helm/docs/examples/nginx/values.yaml +++ b/vendor/k8s.io/helm/docs/examples/nginx/values.yaml @@ -2,14 +2,8 @@ # This is a YAML-formatted file. # Declare name/value pairs to be passed into your templates. -# See the list at https://hub.docker.com/r/library/nginx/tags/ -imageTag: "1.11.0" - -# The port (defined on the service) to access the HTTP server. -httpPort: 8888 - -# Number of nginx instances to run replicaCount: 1 +restartPolicy: Never # Evaluated by the post-install hook sleepyTime: "10" @@ -17,3 +11,24 @@ sleepyTime: "10" index: >-

    Hello

    This is a test

    + +image: + repository: nginx + tag: 1.11.0 + pullPolicy: IfNotPresent + +service: + annotations: {} + clusterIP: "" + externalIPs: [] + loadBalancerIP: "" + loadBalancerSourceRanges: [] + type: ClusterIP + port: 8888 + nodePort: "" + +podAnnotations: {} + +resources: {} + +nodeSelector: {} diff --git a/vendor/k8s.io/helm/docs/helm/helm.md b/vendor/k8s.io/helm/docs/helm/helm.md index 4567049d..2b15a3b1 100644 --- a/vendor/k8s.io/helm/docs/helm/helm.md +++ b/vendor/k8s.io/helm/docs/helm/helm.md @@ -34,9 +34,9 @@ Environment: ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO @@ -66,4 +66,4 @@ Environment: * [helm verify](helm_verify.md) - verify that a chart at the given path has been signed and is valid * [helm version](helm_version.md) - print the client/server version information -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_completion.md b/vendor/k8s.io/helm/docs/helm/helm_completion.md index 4b7c540a..60cc7497 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_completion.md +++ b/vendor/k8s.io/helm/docs/helm/helm_completion.md @@ -26,12 +26,12 @@ helm completion SHELL ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_create.md b/vendor/k8s.io/helm/docs/helm/helm_create.md index 8284be8f..73d435d6 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_create.md +++ b/vendor/k8s.io/helm/docs/helm/helm_create.md @@ -45,12 +45,12 @@ helm create NAME ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_delete.md b/vendor/k8s.io/helm/docs/helm/helm_delete.md index 0d15b9d0..91fc51c2 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_delete.md +++ b/vendor/k8s.io/helm/docs/helm/helm_delete.md @@ -23,7 +23,7 @@ helm delete [flags] RELEASE_NAME [...] --dry-run simulate a delete --no-hooks prevent hooks from running during deletion --purge remove the release from the store and make its name free for later use - --timeout int time in seconds to wait for any individual kubernetes operation (like Jobs for hooks) (default 300) + --timeout int time in seconds to wait for any individual Kubernetes operation (like Jobs for hooks) (default 300) --tls enable TLS for request --tls-ca-cert string path to TLS CA certificate file (default "$HELM_HOME/ca.pem") --tls-cert string path to TLS certificate file (default "$HELM_HOME/cert.pem") @@ -36,12 +36,12 @@ helm delete [flags] RELEASE_NAME [...] ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_dependency.md b/vendor/k8s.io/helm/docs/helm/helm_dependency.md index 629a27d3..d7259c2f 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_dependency.md +++ b/vendor/k8s.io/helm/docs/helm/helm_dependency.md @@ -36,8 +36,8 @@ The 'version' field should contain a semantic version or version range. The 'repository' URL should point to a Chart Repository. Helm expects that by appending '/index.yaml' to the URL, it should be able to retrieve the chart -repository's index. Note: 'repository' cannot be a repository alias. It must be -a URL. +repository's index. Note: 'repository' can be an alias. The alias must start +with 'alias:' or '@'. Starting from 2.2.0, repository can be defined as the path to the directory of the dependency charts stored locally. The path should start with a prefix of @@ -59,9 +59,9 @@ for this case. ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO @@ -70,4 +70,4 @@ for this case. * [helm dependency list](helm_dependency_list.md) - list the dependencies for the given chart * [helm dependency update](helm_dependency_update.md) - update charts/ based on the contents of requirements.yaml -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 11-Jul-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_dependency_build.md b/vendor/k8s.io/helm/docs/helm/helm_dependency_build.md index 9c5d6af7..d99eb0ea 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_dependency_build.md +++ b/vendor/k8s.io/helm/docs/helm/helm_dependency_build.md @@ -32,12 +32,12 @@ helm dependency build [flags] CHART ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm dependency](helm_dependency.md) - manage a chart's dependencies -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_dependency_list.md b/vendor/k8s.io/helm/docs/helm/helm_dependency_list.md index ec5e861f..74e4fb80 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_dependency_list.md +++ b/vendor/k8s.io/helm/docs/helm/helm_dependency_list.md @@ -24,12 +24,12 @@ helm dependency list [flags] CHART ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm dependency](helm_dependency.md) - manage a chart's dependencies -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_dependency_update.md b/vendor/k8s.io/helm/docs/helm/helm_dependency_update.md index 8fb8fd2d..2fa782c3 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_dependency_update.md +++ b/vendor/k8s.io/helm/docs/helm/helm_dependency_update.md @@ -37,12 +37,12 @@ helm dependency update [flags] CHART ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm dependency](helm_dependency.md) - manage a chart's dependencies -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_fetch.md b/vendor/k8s.io/helm/docs/helm/helm_fetch.md index a9578199..6556c74f 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_fetch.md +++ b/vendor/k8s.io/helm/docs/helm/helm_fetch.md @@ -46,12 +46,12 @@ helm fetch [flags] [chart URL | repo/chartname] [...] ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_get.md b/vendor/k8s.io/helm/docs/helm/helm_get.md index efa3c458..418566c7 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_get.md +++ b/vendor/k8s.io/helm/docs/helm/helm_get.md @@ -38,9 +38,9 @@ helm get [flags] RELEASE_NAME ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO @@ -49,4 +49,4 @@ helm get [flags] RELEASE_NAME * [helm get manifest](helm_get_manifest.md) - download the manifest for a named release * [helm get values](helm_get_values.md) - download the values file for a named release -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_get_hooks.md b/vendor/k8s.io/helm/docs/helm/helm_get_hooks.md index d2fad8b6..c90d5a5e 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_get_hooks.md +++ b/vendor/k8s.io/helm/docs/helm/helm_get_hooks.md @@ -26,12 +26,12 @@ helm get hooks [flags] RELEASE_NAME ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm get](helm_get.md) - download a named release -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_get_manifest.md b/vendor/k8s.io/helm/docs/helm/helm_get_manifest.md index 053ef652..294ae952 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_get_manifest.md +++ b/vendor/k8s.io/helm/docs/helm/helm_get_manifest.md @@ -28,12 +28,12 @@ helm get manifest [flags] RELEASE_NAME ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm get](helm_get.md) - download a named release -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_get_values.md b/vendor/k8s.io/helm/docs/helm/helm_get_values.md index 5cdcbd7d..7067d8ac 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_get_values.md +++ b/vendor/k8s.io/helm/docs/helm/helm_get_values.md @@ -25,12 +25,12 @@ helm get values [flags] RELEASE_NAME ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm get](helm_get.md) - download a named release -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_history.md b/vendor/k8s.io/helm/docs/helm/helm_history.md index 590c8a68..afd41151 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_history.md +++ b/vendor/k8s.io/helm/docs/helm/helm_history.md @@ -41,12 +41,12 @@ helm history [flags] RELEASE_NAME ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_home.md b/vendor/k8s.io/helm/docs/helm/helm_home.md index 683142f7..c5c4f50e 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_home.md +++ b/vendor/k8s.io/helm/docs/helm/helm_home.md @@ -19,12 +19,12 @@ helm home ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_init.md b/vendor/k8s.io/helm/docs/helm/helm_init.md index 2d498c55..034f7436 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_init.md +++ b/vendor/k8s.io/helm/docs/helm/helm_init.md @@ -6,14 +6,14 @@ initialize Helm on both client and server -This command installs Tiller (the helm server side component) onto your -Kubernetes Cluster and sets up local configuration in $HELM_HOME (default ~/.helm/) +This command installs Tiller (the Helm server-side component) onto your +Kubernetes Cluster and sets up local configuration in $HELM_HOME (default ~/.helm/). As with the rest of the Helm commands, 'helm init' discovers Kubernetes clusters by reading $KUBECONFIG (default '~/.kube/config') and using the default context. To set up just a local environment, use '--client-only'. That will configure -$HELM_HOME, but not attempt to connect to a remote cluster and install the Tiller +$HELM_HOME, but not attempt to connect to a Kubernetes cluster and install the Tiller deployment. When installing Tiller, 'helm init' will attempt to install the latest released @@ -33,21 +33,21 @@ helm init ### Options ``` - --canary-image use the canary tiller image - -c, --client-only if set does not install tiller + --canary-image use the canary Tiller image + -c, --client-only if set does not install Tiller --dry-run do not install local or remote --local-repo-url string URL for local repository (default "http://127.0.0.1:8879/charts") - --net-host install tiller with net=host + --net-host install Tiller with net=host --service-account string name of service account --skip-refresh do not refresh (download) the local repository cache --stable-repo-url string URL for stable repository (default "https://kubernetes-charts.storage.googleapis.com") - -i, --tiller-image string override tiller image - --tiller-tls install tiller with TLS enabled - --tiller-tls-cert string path to TLS certificate file to install with tiller - --tiller-tls-key string path to TLS key file to install with tiller - --tiller-tls-verify install tiller with TLS enabled and to verify remote certificates + -i, --tiller-image string override Tiller image + --tiller-tls install Tiller with TLS enabled + --tiller-tls-cert string path to TLS certificate file to install with Tiller + --tiller-tls-key string path to TLS key file to install with Tiller + --tiller-tls-verify install Tiller with TLS enabled and to verify remote certificates --tls-ca-cert string path to CA root certificate - --upgrade upgrade if tiller is already installed + --upgrade upgrade if Tiller is already installed ``` ### Options inherited from parent commands @@ -55,12 +55,12 @@ helm init ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 26-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_inspect.md b/vendor/k8s.io/helm/docs/helm/helm_inspect.md index 30f09a72..a740c3b2 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_inspect.md +++ b/vendor/k8s.io/helm/docs/helm/helm_inspect.md @@ -33,9 +33,9 @@ helm inspect [CHART] ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO @@ -43,4 +43,4 @@ helm inspect [CHART] * [helm inspect chart](helm_inspect_chart.md) - shows inspect chart * [helm inspect values](helm_inspect_values.md) - shows inspect values -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_inspect_chart.md b/vendor/k8s.io/helm/docs/helm/helm_inspect_chart.md index 5e49e282..e9d5bc08 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_inspect_chart.md +++ b/vendor/k8s.io/helm/docs/helm/helm_inspect_chart.md @@ -31,12 +31,12 @@ helm inspect chart [CHART] ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm inspect](helm_inspect.md) - inspect a chart -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_inspect_values.md b/vendor/k8s.io/helm/docs/helm/helm_inspect_values.md index f4921597..a151c404 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_inspect_values.md +++ b/vendor/k8s.io/helm/docs/helm/helm_inspect_values.md @@ -31,12 +31,12 @@ helm inspect values [CHART] ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm inspect](helm_inspect.md) - inspect a chart -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_install.md b/vendor/k8s.io/helm/docs/helm/helm_install.md index f8e0885f..8858f534 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_install.md +++ b/vendor/k8s.io/helm/docs/helm/helm_install.md @@ -76,12 +76,12 @@ helm install [CHART] --keyring string location of public keys used for verification (default "~/.gnupg/pubring.gpg") -n, --name string release name. If unspecified, it will autogenerate one for you --name-template string specify template used to name the release - --namespace string namespace to install the release into + --namespace string namespace to install the release into. Defaults to the current kube config namespace. --no-hooks prevent hooks from running during install --replace re-use the given name, even if that name is already used. This is unsafe in production --repo string chart repository url where to locate the requested chart --set stringArray set values on the command line (can specify multiple or separate values with commas: key1=val1,key2=val2) - --timeout int time in seconds to wait for any individual kubernetes operation (like Jobs for hooks) (default 300) + --timeout int time in seconds to wait for any individual Kubernetes operation (like Jobs for hooks) (default 300) --tls enable TLS for request --tls-ca-cert string path to TLS CA certificate file (default "$HELM_HOME/ca.pem") --tls-cert string path to TLS certificate file (default "$HELM_HOME/cert.pem") @@ -98,12 +98,12 @@ helm install [CHART] ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 15-Aug-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_lint.md b/vendor/k8s.io/helm/docs/helm/helm_lint.md index 61e6737c..618d5c5e 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_lint.md +++ b/vendor/k8s.io/helm/docs/helm/helm_lint.md @@ -29,12 +29,12 @@ helm lint [flags] PATH ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_list.md b/vendor/k8s.io/helm/docs/helm/helm_list.md index a69f5ba2..f3223375 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_list.md +++ b/vendor/k8s.io/helm/docs/helm/helm_list.md @@ -39,7 +39,7 @@ helm list [flags] [FILTER] ### Options ``` - --all show all releases, not just the ones marked DEPLOYED + -a, --all show all releases, not just the ones marked DEPLOYED -d, --date sort by release date --deleted show deleted releases --deleting show releases that are currently being deleted @@ -48,6 +48,7 @@ helm list [flags] [FILTER] -m, --max int maximum number of releases to fetch (default 256) --namespace string show releases within a specific namespace -o, --offset string next release name in the list, used to offset from start value + --pending show pending releases -r, --reverse reverse the sort order -q, --short output short (quiet) listing format --tls enable TLS for request @@ -62,12 +63,12 @@ helm list [flags] [FILTER] ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 12-Jul-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_package.md b/vendor/k8s.io/helm/docs/helm/helm_package.md index 595ec556..88374b73 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_package.md +++ b/vendor/k8s.io/helm/docs/helm/helm_package.md @@ -37,12 +37,12 @@ helm package [flags] [CHART_PATH] [...] ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 5-Jun-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_plugin.md b/vendor/k8s.io/helm/docs/helm/helm_plugin.md index b38f3e01..79653f5d 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_plugin.md +++ b/vendor/k8s.io/helm/docs/helm/helm_plugin.md @@ -14,9 +14,9 @@ Manage client-side Helm plugins. ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO @@ -26,4 +26,4 @@ Manage client-side Helm plugins. * [helm plugin remove](helm_plugin_remove.md) - remove one or more Helm plugins * [helm plugin update](helm_plugin_update.md) - update one or more Helm plugins -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_plugin_install.md b/vendor/k8s.io/helm/docs/helm/helm_plugin_install.md index 7b4f8904..635e68ff 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_plugin_install.md +++ b/vendor/k8s.io/helm/docs/helm/helm_plugin_install.md @@ -22,12 +22,12 @@ helm plugin install [options] ... ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm plugin](helm_plugin.md) - add, list, or remove Helm plugins -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_plugin_list.md b/vendor/k8s.io/helm/docs/helm/helm_plugin_list.md index 53f37b8d..823f4369 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_plugin_list.md +++ b/vendor/k8s.io/helm/docs/helm/helm_plugin_list.md @@ -16,12 +16,12 @@ helm plugin list ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm plugin](helm_plugin.md) - add, list, or remove Helm plugins -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_plugin_remove.md b/vendor/k8s.io/helm/docs/helm/helm_plugin_remove.md index 0559f395..8d02ee75 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_plugin_remove.md +++ b/vendor/k8s.io/helm/docs/helm/helm_plugin_remove.md @@ -16,12 +16,12 @@ helm plugin remove ... ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm plugin](helm_plugin.md) - add, list, or remove Helm plugins -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_plugin_update.md b/vendor/k8s.io/helm/docs/helm/helm_plugin_update.md index c0dac090..9817c052 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_plugin_update.md +++ b/vendor/k8s.io/helm/docs/helm/helm_plugin_update.md @@ -16,12 +16,12 @@ helm plugin update ... ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm plugin](helm_plugin.md) - add, list, or remove Helm plugins -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_repo.md b/vendor/k8s.io/helm/docs/helm/helm_repo.md index 3378a185..06cc1f4b 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_repo.md +++ b/vendor/k8s.io/helm/docs/helm/helm_repo.md @@ -18,9 +18,9 @@ Example usage: ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO @@ -31,4 +31,4 @@ Example usage: * [helm repo remove](helm_repo_remove.md) - remove a chart repository * [helm repo update](helm_repo_update.md) - update information of available charts locally from chart repositories -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_repo_add.md b/vendor/k8s.io/helm/docs/helm/helm_repo_add.md index f7f3e872..34e1c5b8 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_repo_add.md +++ b/vendor/k8s.io/helm/docs/helm/helm_repo_add.md @@ -25,12 +25,12 @@ helm repo add [flags] [NAME] [URL] ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm repo](helm_repo.md) - add, list, remove, update, and index chart repositories -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_repo_index.md b/vendor/k8s.io/helm/docs/helm/helm_repo_index.md index 79c8ee60..533e3884 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_repo_index.md +++ b/vendor/k8s.io/helm/docs/helm/helm_repo_index.md @@ -32,12 +32,12 @@ helm repo index [flags] [DIR] ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm repo](helm_repo.md) - add, list, remove, update, and index chart repositories -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_repo_list.md b/vendor/k8s.io/helm/docs/helm/helm_repo_list.md index 4f8f2e1d..f4ab740a 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_repo_list.md +++ b/vendor/k8s.io/helm/docs/helm/helm_repo_list.md @@ -16,12 +16,12 @@ helm repo list [flags] ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm repo](helm_repo.md) - add, list, remove, update, and index chart repositories -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_repo_remove.md b/vendor/k8s.io/helm/docs/helm/helm_repo_remove.md index 075b15fc..0198f961 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_repo_remove.md +++ b/vendor/k8s.io/helm/docs/helm/helm_repo_remove.md @@ -16,12 +16,12 @@ helm repo remove [flags] [NAME] ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm repo](helm_repo.md) - add, list, remove, update, and index chart repositories -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_repo_update.md b/vendor/k8s.io/helm/docs/helm/helm_repo_update.md index 3758f822..61cca84e 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_repo_update.md +++ b/vendor/k8s.io/helm/docs/helm/helm_repo_update.md @@ -22,12 +22,12 @@ helm repo update ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm repo](helm_repo.md) - add, list, remove, update, and index chart repositories -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_reset.md b/vendor/k8s.io/helm/docs/helm/helm_reset.md index bc3299d4..78218a4e 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_reset.md +++ b/vendor/k8s.io/helm/docs/helm/helm_reset.md @@ -6,7 +6,7 @@ uninstalls Tiller from a cluster -This command uninstalls Tiller (the helm server side component) from your +This command uninstalls Tiller (the Helm server-side component) from your Kubernetes Cluster and optionally deletes local configuration in $HELM_HOME (default ~/.helm/) @@ -18,7 +18,7 @@ helm reset ### Options ``` - -f, --force forces Tiller uninstall even if there are releases installed, or if tiller is not in ready state + -f, --force forces Tiller uninstall even if there are releases installed, or if Tiller is not in ready state --remove-helm-home if set deletes $HELM_HOME --tls enable TLS for request --tls-ca-cert string path to TLS CA certificate file (default "$HELM_HOME/ca.pem") @@ -32,12 +32,12 @@ helm reset ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 27-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_rollback.md b/vendor/k8s.io/helm/docs/helm/helm_rollback.md index 3a3ed1a2..53baef48 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_rollback.md +++ b/vendor/k8s.io/helm/docs/helm/helm_rollback.md @@ -24,7 +24,7 @@ helm rollback [flags] [RELEASE] [REVISION] --force force resource update through delete/recreate if needed --no-hooks prevent hooks from running during rollback --recreate-pods performs pods restart for the resource if applicable - --timeout int time in seconds to wait for any individual kubernetes operation (like Jobs for hooks) (default 300) + --timeout int time in seconds to wait for any individual Kubernetes operation (like Jobs for hooks) (default 300) --tls enable TLS for request --tls-ca-cert string path to TLS CA certificate file (default "$HELM_HOME/ca.pem") --tls-cert string path to TLS certificate file (default "$HELM_HOME/cert.pem") @@ -38,12 +38,12 @@ helm rollback [flags] [RELEASE] [REVISION] ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_search.md b/vendor/k8s.io/helm/docs/helm/helm_search.md index 48579c5b..8522e486 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_search.md +++ b/vendor/k8s.io/helm/docs/helm/helm_search.md @@ -29,12 +29,12 @@ helm search [keyword] ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_serve.md b/vendor/k8s.io/helm/docs/helm/helm_serve.md index 1a317e9e..98969410 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_serve.md +++ b/vendor/k8s.io/helm/docs/helm/helm_serve.md @@ -37,12 +37,12 @@ helm serve ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_status.md b/vendor/k8s.io/helm/docs/helm/helm_status.md index a737d7a6..82fa9fae 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_status.md +++ b/vendor/k8s.io/helm/docs/helm/helm_status.md @@ -36,12 +36,12 @@ helm status [flags] RELEASE_NAME ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_test.md b/vendor/k8s.io/helm/docs/helm/helm_test.md index 8d7b39a5..ae6f3e0c 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_test.md +++ b/vendor/k8s.io/helm/docs/helm/helm_test.md @@ -20,7 +20,7 @@ helm test [RELEASE] ``` --cleanup delete test pods upon completion - --timeout int time in seconds to wait for any individual kubernetes operation (like Jobs for hooks) (default 300) + --timeout int time in seconds to wait for any individual Kubernetes operation (like Jobs for hooks) (default 300) --tls enable TLS for request --tls-ca-cert string path to TLS CA certificate file (default "$HELM_HOME/ca.pem") --tls-cert string path to TLS certificate file (default "$HELM_HOME/cert.pem") @@ -33,12 +33,12 @@ helm test [RELEASE] ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_upgrade.md b/vendor/k8s.io/helm/docs/helm/helm_upgrade.md index 1fbefcba..fdf95854 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_upgrade.md +++ b/vendor/k8s.io/helm/docs/helm/helm_upgrade.md @@ -44,14 +44,14 @@ helm upgrade [RELEASE] [CHART] -i, --install if a release by this name doesn't already exist, run an install --key-file string identify HTTPS client using this SSL key file --keyring string path to the keyring that contains public signing keys (default "~/.gnupg/pubring.gpg") - --namespace string namespace to install the release into (only used if --install is set) (default "default") + --namespace string namespace to install the release into (only used if --install is set). Defaults to the current kube config namespace --no-hooks disable pre/post upgrade hooks --recreate-pods performs pods restart for the resource if applicable --repo string chart repository url where to locate the requested chart --reset-values when upgrading, reset the values to the ones built into the chart --reuse-values when upgrading, reuse the last release's values, and merge in any new values. If '--reset-values' is specified, this is ignored. --set stringArray set values on the command line (can specify multiple or separate values with commas: key1=val1,key2=val2) - --timeout int time in seconds to wait for any individual kubernetes operation (like Jobs for hooks) (default 300) + --timeout int time in seconds to wait for any individual Kubernetes operation (like Jobs for hooks) (default 300) --tls enable TLS for request --tls-ca-cert string path to TLS CA certificate file (default "$HELM_HOME/ca.pem") --tls-cert string path to TLS certificate file (default "$HELM_HOME/cert.pem") @@ -68,12 +68,12 @@ helm upgrade [RELEASE] [CHART] ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 15-Aug-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_verify.md b/vendor/k8s.io/helm/docs/helm/helm_verify.md index 10ddab05..cd967c52 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_verify.md +++ b/vendor/k8s.io/helm/docs/helm/helm_verify.md @@ -31,12 +31,12 @@ helm verify [flags] PATH ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/helm/helm_version.md b/vendor/k8s.io/helm/docs/helm/helm_version.md index 16e2f5b9..3b55fafa 100644 --- a/vendor/k8s.io/helm/docs/helm/helm_version.md +++ b/vendor/k8s.io/helm/docs/helm/helm_version.md @@ -45,12 +45,12 @@ helm version ``` --debug enable verbose output --home string location of your Helm config. Overrides $HELM_HOME (default "$HOME/.helm") - --host string address of tiller. Overrides $HELM_HOST + --host string address of Tiller. Overrides $HELM_HOST --kube-context string name of the kubeconfig context to use - --tiller-namespace string namespace of tiller (default "kube-system") + --tiller-namespace string namespace of Tiller (default "kube-system") ``` ### SEE ALSO * [helm](helm.md) - The Helm package manager for Kubernetes. -###### Auto generated by spf13/cobra on 29-May-2017 +###### Auto generated by spf13/cobra on 23-Jun-2017 diff --git a/vendor/k8s.io/helm/docs/install.md b/vendor/k8s.io/helm/docs/install.md index b935fa4f..ed0bd4ea 100755 --- a/vendor/k8s.io/helm/docs/install.md +++ b/vendor/k8s.io/helm/docs/install.md @@ -117,7 +117,7 @@ the client and server version. (If it shows only the client version, `helm` cannot yet connect to the server. Use `kubectl` to see if any `tiller` pods are running.) -If Helm will look for Tiller in the `kube-system` namespace unless +Helm will look for Tiller in the `kube-system` namespace unless `--tiller-namespace` or `TILLER_NAMESPACE` is set. ### Installing Tiller Canary Builds diff --git a/vendor/k8s.io/helm/docs/plugins.md b/vendor/k8s.io/helm/docs/plugins.md index 72e78c25..1bee8bd5 100644 --- a/vendor/k8s.io/helm/docs/plugins.md +++ b/vendor/k8s.io/helm/docs/plugins.md @@ -65,7 +65,7 @@ Here is a plugin YAML for a plugin that adds support for Keybase operations: ``` name: "keybase" version: "0.1.0" -usage: "Integreate Keybase.io tools with Helm" +usage: "Integrate Keybase.io tools with Helm" description: |- This plugin provides Keybase services to Helm. ignoreFlags: false diff --git a/vendor/k8s.io/helm/docs/provenance.md b/vendor/k8s.io/helm/docs/provenance.md index 6a6faac3..1f136151 100644 --- a/vendor/k8s.io/helm/docs/provenance.md +++ b/vendor/k8s.io/helm/docs/provenance.md @@ -263,9 +263,8 @@ in using the provenance system: - Keybase also has fabulous documentation available - While we haven't tested it, Keybase's "secure website" feature could be used to serve Helm charts. -- The [https://github.com/kubernetes/charts](official Kubernetes Charts - project) is trying to solve this problem for the official chart - repository. +- The [official Kubernetes Charts project](https://github.com/kubernetes/charts) + is trying to solve this problem for the official chart repository. - There is a long issue there [detailing the current thoughts](https://github.com/kubernetes/charts/issues/23). - The basic idea is that an official "chart reviewer" signs charts with her or his key, and the resulting provenance file is then uploaded diff --git a/vendor/k8s.io/helm/docs/related.md b/vendor/k8s.io/helm/docs/related.md index 4787bc7c..22ac3638 100644 --- a/vendor/k8s.io/helm/docs/related.md +++ b/vendor/k8s.io/helm/docs/related.md @@ -35,6 +35,7 @@ or [pull request](https://github.com/kubernetes/helm/pulls). - [helm-nuke](https://github.com/adamreese/helm-nuke) - Plugin to destroy all releases - [App Registry](https://github.com/app-registry/helm-plugin) - Plugin to manage charts via the [App Registry specification](https://github.com/app-registry/spec) - [helm-secrets](https://github.com/futuresimple/helm-secrets) - Plugin to manage and store secrets safely +- [helm-edit](https://github.com/mstrzele/helm-edit) - Plugin for editing release's values We also encourage GitHub authors to use the [helm-plugin](https://github.com/search?q=topic%3Ahelm-plugin&type=Repositories) tag on their plugin repositories. @@ -43,6 +44,7 @@ tag on their plugin repositories. Tools layered on top of Helm or Tiller. +- [Wheel](https://github.com/appscode/wheel) - Ajax friendly Helm Tiller Proxy using [grpc-gateway](https://github.com/grpc-ecosystem/grpc-gateway) - [Quay App Registry](https://coreos.com/blog/quay-application-registry-for-kubernetes.html) - Open Kubernetes application registry, including a Helm access client - [Chartify](https://github.com/appscode/chartify) - Generate Helm charts from existing Kubernetes resources. - [VIM-Kubernetes](https://github.com/andrewstuart/vim-kubernetes) - VIM plugin for Kubernetes and Helm diff --git a/vendor/k8s.io/helm/docs/service_accounts.md b/vendor/k8s.io/helm/docs/service_accounts.md new file mode 100644 index 00000000..612074d0 --- /dev/null +++ b/vendor/k8s.io/helm/docs/service_accounts.md @@ -0,0 +1,112 @@ +# Tiller and Service Accounts + +In Kubernetes, granting a role to an application-specific service account is a best practice to ensure that your application is operating in the scope that you have specified. Read more about service account permissions [in the official Kubernetes docs](https://kubernetes.io/docs/admin/authorization/rbac/#service-account-permissions). Bitnami also has a fantastic guide for [configuring RBAC in your cluster](https://docs.bitnami.com/kubernetes/how-to/configure-rbac-in-your-kubernetes-cluster/) that takes you through RBAC basics. + +You can add a service account to Tiller using the `--service-account ` flag while you're configuring helm. As a prerequisite, you'll have to create a role binding which specifies a [role](https://kubernetes.io/docs/admin/authorization/rbac/#role-and-clusterrole) and a [service account](https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/) name that have been set up in advance. + +Once you have satisfied the pre-requisite and have a service account with the correct permissions, you'll run a command like this: `helm init --service-account ` + +## Example: Service account with cluster-admin role + +```console +$ kubectl create serviceaccount tiller --namespace kube-system +``` + +In `rbac-config.yaml`: +```yaml +apiVersion: v1 +kind: ServiceAccount +metadata: + name: tiller + namespace: kube-system +--- +apiVersion: rbac.authorization.k8s.io/v1beta1 +kind: ClusterRoleBinding +metadata: + name: tiller +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: ClusterRole + name: cluster-admin +subjects: + - kind: ServiceAccount + name: tiller + namespace: kube-system +``` + +_Note: The cluster-admin role is created by default in a Kubernetes cluster, so you don't have to define it explicitly._ + +```console +$ kubectl create -f rbac-config.yaml +$ helm init --service-account tiller +``` + +## Example: Service account restricted to a namespace +In the example above, we gave Tiller admin access to the entire cluster. You are not at all required to give Tiller cluster-admin access for it to work. Instead of specifying a ClusterRole or a ClusterRoleBinding, you can specify a Role and RoleBinding to limit Tiller's scope to a particular namespace. + +```console +$ kubectl create namespace tiller-world +namespace "tiller-world" created +$ kubectl create serviceaccount tiller --namespace tiller-world +serviceaccount "tiller" created +``` + +Define a Role like in `role-tiller.yaml`: +```yaml +kind: Role +apiVersion: rbac.authorization.k8s.io/v1beta1 +metadata: + namespace: tiller-world + name: tiller-manager +rules: +- apiGroups: ["", "extensions", "apps"] + resources: ["deployments", "replicasets", "pods", "configmaps", "secrets", "namespaces"] + verbs: ["get", "list", "watch", "create", "update", "patch", "delete"] # You can also use ["*"] +``` + +```console +$ kubectl create -f role-tiller.yaml +role "tiller-manager" created +``` + +In `rolebinding-tiller.yaml`, +```yaml +kind: RoleBinding +apiVersion: rbac.authorization.k8s.io/v1beta1 +metadata: + name: tiller-binding + namespace: tiller-world +subjects: +- kind: ServiceAccount + name: tiller + namespace: tiller-world +roleRef: + kind: Role + name: tiller-manager + apiGroup: rbac.authorization.k8s.io +``` + +```console +$ kubectl create -f rolebinding-tiller.yaml +rolebinding "tiller-binding" created +``` + +```console +$ helm init --service-account tiller --tiller-namespace tiller-world +$HELM_HOME has been configured at /Users/awesome-user/.helm. + +Tiller (the helm server side component) has been installed into your Kubernetes Cluster. +Happy Helming! + +$ helm install nginx --tiller-namespace tiller-world --namespace tiller-world +NAME: wayfaring-yak +LAST DEPLOYED: Mon Aug 7 16:00:16 2017 +NAMESPACE: tiller-world +STATUS: DEPLOYED + +RESOURCES: +==> v1/Pod +NAME READY STATUS RESTARTS AGE +wayfaring-yak-alpine 0/1 ContainerCreating 0 0s +``` + diff --git a/vendor/k8s.io/helm/docs/using_helm.md b/vendor/k8s.io/helm/docs/using_helm.md index 777661ea..77e4cffc 100755 --- a/vendor/k8s.io/helm/docs/using_helm.md +++ b/vendor/k8s.io/helm/docs/using_helm.md @@ -296,7 +296,7 @@ nodeSelector: kubernetes.io/role: master ``` -Deeply nested datastructures can be difficult to express using `--set`. Chart +Deeply nested data structures can be difficult to express using `--set`. Chart designers are encouraged to consider the `--set` usage when designing the format of a `values.yaml` file. @@ -494,7 +494,7 @@ accepts chart source code, and (after audit) packages those for you. In some cases you may wish to scope Tiller or deploy multiple Tillers to a single cluster. Here are some best practices when operating in those circumstances. 1. Tiller can be [installed](install.md) into any namespace. By default, it is installed into kube-system. You can run multiple Tillers provided they each run in their own namespace. -2. Limiting Tiller to only be able to install into specific namespaces and/or resource types is controlled by Kubernetes [RBAC](https://kubernetes.io/docs/admin/authorization/rbac/) roles and rolebindings. +2. Limiting Tiller to only be able to install into specific namespaces and/or resource types is controlled by Kubernetes [RBAC](https://kubernetes.io/docs/admin/authorization/rbac/) roles and rolebindings. You can add a service account to Tiller when configuring Helm via `helm init --service-acount `. You can find more information about that [here](service_accounts.md). 3. Release names are unique PER TILLER INSTANCE. 4. Charts should only contain resources that exist in a single namespace. 5. It is not recommended to have multiple Tillers configured to manage resources in the same namespace. diff --git a/vendor/k8s.io/helm/glide.lock b/vendor/k8s.io/helm/glide.lock index efefa3de..8651e188 100644 --- a/vendor/k8s.io/helm/glide.lock +++ b/vendor/k8s.io/helm/glide.lock @@ -1,21 +1,14 @@ -hash: f705b8873fe2e7fb0cf436e2485edf218f558ae726015e6d59490d53464ae536 -updated: 2017-05-17T12:47:01.838888143-06:00 +hash: 54e64255ab9112d0183766264214969a8add57903fbe9e96034f9640b9c9cd82 +updated: 2017-07-10T10:52:19.616678852-04:00 imports: -- name: bitbucket.org/ww/goautoneg - version: 75cd24fc2f2c2a2088577d12123ddee5f54e0675 - name: cloud.google.com/go version: 3b1ae45394a234c385be014e9a488f2bb6eef821 - subpackages: - - compute/metadata - - internal - name: github.com/aokoli/goutils version: 9c37978a95bd5c709a15883b6242714ea6709e64 - name: github.com/asaskevich/govalidator version: 7664702784775e51966f0885f5cd27435916517b -- name: github.com/Azure/go-ansiterm - version: 70b2c90b260171e829f1ebd7c17f600c11858dbe - subpackages: - - winterm +- name: github.com/Azure/go-autorest + version: d7c034a8af24eda120dd6460bfcd6d9ed14e43ca - name: github.com/beorn7/perks version: 3ac7bf7a47d159a033b107610db8a1b6575507a4 subpackages: @@ -24,22 +17,8 @@ imports: version: b26d9c308763d68093482582cea63d69be07a0f0 - name: github.com/chai2010/gettext-go version: bf70f2a70fb1b1f36d90d671a72795984eab0fcb -- name: github.com/coreos/go-oidc - version: be73733bb8cc830d0205609b95d125215f8e9c70 - subpackages: - - http - - jose - - key - - oauth2 - - oidc -- name: github.com/coreos/pkg - version: fa29b1d70f0beaddd4c7021607cc3c3be8ce94b8 - subpackages: - - health - - httputil - - timeutil - name: github.com/cpuguy83/go-md2man - version: a65d4d2de4d5f7c74868dfa9b202a3c8be315aaa + version: 71acacd42f85e5e82f70a55327789582a5200a90 subpackages: - md2man - name: github.com/davecgh/go-spew @@ -53,18 +32,6 @@ imports: subpackages: - digest - reference -- name: github.com/docker/docker - version: b9f10c951893f9a00865890a5232e85d770c1087 - subpackages: - - pkg/jsonlog - - pkg/jsonmessage - - pkg/longpath - - pkg/mount - - pkg/stdcopy - - pkg/symlink - - pkg/system - - pkg/term - - pkg/term/windows - name: github.com/docker/engine-api version: dea108d3aa0c67d7162a3fd8aa65f38a430019fd subpackages: @@ -91,13 +58,12 @@ imports: version: e30f1e79f3cd72542f2026ceec18d3bd67ab859c - name: github.com/docker/spdystream version: 449fdfce4d962303d702fec724ef0ad181c92528 - subpackages: - - spdy - name: github.com/emicklei/go-restful - version: 09691a3b6378b740595c1002f40c34dd5f218a22 + version: ff4f55a206334ef123e4f79bbf348980da81ca46 subpackages: - log - - swagger +- name: github.com/emicklei/go-restful-swagger12 + version: dcef7f55730566d41eae5db10e7d6981829720f6 - name: github.com/evanphx/json-patch version: ba18e35c5c1b36ef6334cad706eb681153d2d379 - name: github.com/exponent-io/jsonpath @@ -106,14 +72,24 @@ imports: version: 2de1f203e7d5e386a6833233882782932729f27e - name: github.com/facebookgo/symwalk version: 42004b9f322246749dd73ad71008b1f3160c0052 +- name: github.com/fatih/camelcase + version: f6a740d52f961c60348ebb109adde9f4635d7540 - name: github.com/ghodss/yaml version: 73d445a93680fa1a78ae23a5839bad48f32ba1ee +- name: github.com/go-openapi/analysis + version: b44dc874b601d9e4e2f6e19140e794ba24bead3b +- name: github.com/go-openapi/errors + version: d24ebc2075bad502fac3a8ae27aa6dd58e1952dc - name: github.com/go-openapi/jsonpointer version: 46af16f9f7b149af66e5d1bd010e3574dc06de98 - name: github.com/go-openapi/jsonreference version: 13c6e3589ad90f49bd3e3bbe2c2cb3d7a4142272 +- name: github.com/go-openapi/loads + version: 18441dfa706d924a39a030ee2c3b1d8d81917b38 - name: github.com/go-openapi/spec version: 6aced65f8501fe1217321abf0749d354824ba2ff +- name: github.com/go-openapi/strfmt + version: d65c7fdb29eca313476e529628176fe17e58c488 - name: github.com/go-openapi/swag version: 1d0bd113de87027671077d3c71eb3ac5d7dbba72 - name: github.com/gobwas/glob @@ -129,8 +105,31 @@ imports: - name: github.com/gogo/protobuf version: c0656edd0d9eab7c66d1eb0c568f9039345796f7 subpackages: + - gogoproto + - plugin/compare + - plugin/defaultcheck + - plugin/description + - plugin/embedcheck + - plugin/enumstringer + - plugin/equal + - plugin/face + - plugin/gostring + - plugin/marshalto + - plugin/oneofcheck + - plugin/populate + - plugin/size + - plugin/stringer + - plugin/testgen + - plugin/union + - plugin/unmarshal - proto + - protoc-gen-gogo/descriptor + - protoc-gen-gogo/generator + - protoc-gen-gogo/grpc + - protoc-gen-gogo/plugin - sortkeys + - vanity + - vanity/command - name: github.com/golang/glog version: 44145f04b68cf362d9c4df2182967c2275eaefed - name: github.com/golang/groupcache @@ -144,14 +143,16 @@ imports: - ptypes/any - ptypes/timestamp - name: github.com/google/gofuzz - version: 44d81051d367757e1c7c6a5a86423ece9afcf63c + version: bbcb9da2d746f8bdbd6a936686a0a6067ada0ec5 - name: github.com/gosuri/uitable version: 36ee7e946282a3fb1cfecd476ddc9b35d8847e42 subpackages: - util/strutil - util/wordwrap - name: github.com/grpc-ecosystem/go-grpc-prometheus - version: 34abd90a014618f61222a1b0a7b7eb834a2d0dc3 + version: 0c1b191dbfe51efdabe3c14b9f6f3b96429e0722 +- name: github.com/hashicorp/golang-lru + version: a0d98a5f288019575c6d1f4bb1573fef2d1fcdc4 - name: github.com/howeyc/gopass version: 3ca23474a7c7203e0a0a070fd33508f6efdb9b3d - name: github.com/huandu/xstrings @@ -160,10 +161,8 @@ imports: version: 6633656539c1639d9d78127b7d47c622b5d7b6dc - name: github.com/inconshreveable/mousetrap version: 76626ae9c91c4f2a10f34cad8ce83ea42c93bb75 -- name: github.com/jonboulle/clockwork - version: 72f9bd7c4e0c2a40055ab3d0f09654f730cce982 - name: github.com/juju/ratelimit - version: 77ed1c8a01217656d2080ad51981f6e99adaa177 + version: 5b9ff866471762aa2ab2dced63c9fb6f53921342 - name: github.com/mailru/easyjson version: d5b7844b561a7bc640052f1b935f7b800330d7e0 subpackages: @@ -171,7 +170,7 @@ imports: - jlexer - jwriter - name: github.com/Masterminds/semver - version: 3f0ab6d4ab4bed1c61caf056b63a6e62190c7801 + version: 517734cc7d6470c0d07130e40fd40bdeb9bcd3fd - name: github.com/Masterminds/sprig version: 9526be0327b26ad31aa70296a7b10704883976d5 - name: github.com/Masterminds/vcs @@ -182,8 +181,8 @@ imports: version: fc2b8d3a73c4867e51861bbdd5ae3c1f0869dd6a subpackages: - pbutil -- name: github.com/mitchellh/go-wordwrap - version: ad45545899c7b13c020ea92b2072220eefad42b8 +- name: github.com/mitchellh/mapstructure + version: 740c764bc6149d3f1806231418adb9f52c11bcbf - name: github.com/naoina/go-stringutil version: 6b638e95a32d0c1131db0e7fe83775cbea4a0d0b - name: github.com/pborman/uuid @@ -198,12 +197,15 @@ imports: subpackages: - go - name: github.com/prometheus/common - version: ffe929a3f4c4faeaa10f2b9535c2b1be3ad15650 + version: 13ba4ddd0caa9c28ca7b7bffe1dfa9ed8d5ef207 subpackages: - expfmt + - internal/bitbucket.org/ww/goautoneg - model - name: github.com/prometheus/procfs - version: 454a56f35412459b5e684fd5ec0f9211b94f002a + version: 65c1f6f8f0fc1e2185eb9863a3bc751496404259 + subpackages: + - xfs - name: github.com/PuerkitoBio/purell version: 8a290539e2e8629dbc4e6bad948158f790ec31f4 - name: github.com/PuerkitoBio/urlesc @@ -214,8 +216,6 @@ imports: version: 879c5887cd475cd7864858769793b2ceb0d44feb - name: github.com/shurcooL/sanitized_anchor_name version: 10ef21a441db47d8b13ebcc5fd2310f636973c77 -- name: github.com/Sirupsen/logrus - version: 51fe59aca108dc5680109e7b2051cbdcfa5a253c - name: github.com/spf13/cobra version: f62e98d28ab7ad31d707ba837a966378465c7b57 subpackages: @@ -223,11 +223,12 @@ imports: - name: github.com/spf13/pflag version: 9ff6c6923cfffbcd502984b8e0c80539a94968b7 - name: github.com/technosophos/moniker - version: 9f956786b91d9786ca11aa5be6104542fa911546 + version: ab470f5e105a44d0c87ea21bacd6a335c4816d83 - name: github.com/ugorji/go version: ded73eae5db7e7a0ef6f55aace87a2873c5d2b74 subpackages: - codec + - codec/codecgen - name: golang.org/x/crypto version: d172538b2cfce0c13cee31e647d0367aa8cd2486 subpackages: @@ -243,24 +244,17 @@ imports: - scrypt - ssh/terminal - name: golang.org/x/net - version: e90d6d0afc4c315a0d87a568ae68577cc15149a0 + version: f2499483f923065a842d38eb4c7f1927e6fc6e6d subpackages: - context - - context/ctxhttp - http2 - http2/hpack - idna - internal/timeseries - lex/httplex - trace - - websocket - name: golang.org/x/oauth2 version: 3c3a985cb79f52a3190fbc056984415ca6763d01 - subpackages: - - google - - internal - - jws - - jwt - name: golang.org/x/sys version: 8f0908ab3b2457e2e15403d3697c9ef5cb4b57a9 subpackages: @@ -283,18 +277,6 @@ imports: - unicode/bidi - unicode/norm - width -- name: google.golang.org/appengine - version: 4f7eeb5305a4ba1966344836ba4af9996b7b4e05 - subpackages: - - internal - - internal/app_identity - - internal/base - - internal/datastore - - internal/log - - internal/modules - - internal/remote_api - - internal/urlfetch - - urlfetch - name: google.golang.org/grpc version: 8050b9cbc271307e5a716a9d782803d09b0d6f2d subpackages: @@ -311,170 +293,54 @@ imports: - transport - name: gopkg.in/inf.v0 version: 3887ee99ecf07df5b447e9b00d9c0b2adaa9f3e4 +- name: gopkg.in/mgo.v2 + version: 3f83fa5005286a7fe593b055f0d7771a7dce4655 + subpackages: + - bson - name: gopkg.in/yaml.v2 version: 53feefa2559fb8dfa8d81baad31be332c97d6c77 -- name: k8s.io/apimachinery - version: fbd6803372f831e58b86c78d07421637a64ad768 +- name: k8s.io/api + version: 4fe9229aaa9d704f8a2a21cdcd50de2bbb6e1b57 subpackages: - - pkg/api/equality - - pkg/api/errors - - pkg/api/meta - - pkg/api/resource - - pkg/api/validation - - pkg/apimachinery - - pkg/apimachinery/announced - - pkg/apimachinery/registered - - pkg/apis/meta/v1 - - pkg/apis/meta/v1/unstructured - - pkg/apis/meta/v1/validation - - pkg/conversion - - pkg/conversion/queryparams - - pkg/fields - - pkg/labels - - pkg/openapi - - pkg/runtime - - pkg/runtime/schema - - pkg/runtime/serializer - - pkg/runtime/serializer/json - - pkg/runtime/serializer/protobuf - - pkg/runtime/serializer/recognizer - - pkg/runtime/serializer/streaming - - pkg/runtime/serializer/versioning - - pkg/selection - - pkg/types - - pkg/util/diff - - pkg/util/errors - - pkg/util/framer - - pkg/util/httpstream - - pkg/util/httpstream/spdy - - pkg/util/intstr - - pkg/util/json - - pkg/util/mergepatch - - pkg/util/net - - pkg/util/rand - - pkg/util/runtime - - pkg/util/sets - - pkg/util/strategicpatch - - pkg/util/uuid - - pkg/util/validation - - pkg/util/validation/field - - pkg/util/wait - - pkg/util/yaml - - pkg/version - - pkg/watch - - third_party/forked/golang/json - - third_party/forked/golang/netutil - - third_party/forked/golang/reflect + - admissionregistration/v1alpha1 + - apps/v1beta1 + - authentication/v1 + - authentication/v1beta1 + - authorization/v1 + - authorization/v1beta1 + - autoscaling/v1 + - autoscaling/v2alpha1 + - batch/v1 + - batch/v2alpha1 + - certificates/v1beta1 + - core/v1 + - extensions/v1beta1 + - networking/v1 + - policy/v1beta1 + - rbac/v1alpha1 + - rbac/v1beta1 + - settings/v1alpha1 + - storage/v1 + - storage/v1beta1 - name: k8s.io/apiserver - version: 2308857ad3b8b18abf74ff734853973eda9da94d + version: 087d1a2efeb6296f04bb0f54e7af9890052aa6d7 subpackages: + - pkg/admission + - pkg/apis/apiserver + - pkg/apis/apiserver/install + - pkg/apis/apiserver/v1alpha1 + - pkg/apis/audit - pkg/authentication/authenticator - pkg/authentication/serviceaccount - pkg/authentication/user + - pkg/endpoints/request - pkg/features - - pkg/server/httplog - pkg/util/feature - pkg/util/flag - - pkg/util/wsstream -- name: k8s.io/client-go - version: 5b0e11b577b35539f05523c47e94ed96a17f992b - subpackages: - - discovery - - discovery/fake - - dynamic - - kubernetes - - kubernetes/scheme - - kubernetes/typed/apps/v1beta1 - - kubernetes/typed/authentication/v1 - - kubernetes/typed/authentication/v1beta1 - - kubernetes/typed/authorization/v1 - - kubernetes/typed/authorization/v1beta1 - - kubernetes/typed/autoscaling/v1 - - kubernetes/typed/autoscaling/v2alpha1 - - kubernetes/typed/batch/v1 - - kubernetes/typed/batch/v2alpha1 - - kubernetes/typed/certificates/v1beta1 - - kubernetes/typed/core/v1 - - kubernetes/typed/extensions/v1beta1 - - kubernetes/typed/policy/v1beta1 - - kubernetes/typed/rbac/v1alpha1 - - kubernetes/typed/rbac/v1beta1 - - kubernetes/typed/settings/v1alpha1 - - kubernetes/typed/storage/v1 - - kubernetes/typed/storage/v1beta1 - - pkg/api - - pkg/api/helper - - pkg/api/install - - pkg/api/v1 - - pkg/apis/apps - - pkg/apis/apps/install - - pkg/apis/apps/v1beta1 - - pkg/apis/authentication - - pkg/apis/authentication/install - - pkg/apis/authentication/v1 - - pkg/apis/authentication/v1beta1 - - pkg/apis/authorization - - pkg/apis/authorization/install - - pkg/apis/authorization/v1 - - pkg/apis/authorization/v1beta1 - - pkg/apis/autoscaling - - pkg/apis/autoscaling/install - - pkg/apis/autoscaling/v1 - - pkg/apis/autoscaling/v2alpha1 - - pkg/apis/batch - - pkg/apis/batch/install - - pkg/apis/batch/v1 - - pkg/apis/batch/v2alpha1 - - pkg/apis/certificates - - pkg/apis/certificates/install - - pkg/apis/certificates/v1beta1 - - pkg/apis/extensions - - pkg/apis/extensions/install - - pkg/apis/extensions/v1beta1 - - pkg/apis/policy - - pkg/apis/policy/install - - pkg/apis/policy/v1beta1 - - pkg/apis/rbac - - pkg/apis/rbac/install - - pkg/apis/rbac/v1alpha1 - - pkg/apis/rbac/v1beta1 - - pkg/apis/settings - - pkg/apis/settings/install - - pkg/apis/settings/v1alpha1 - - pkg/apis/storage - - pkg/apis/storage/install - - pkg/apis/storage/v1 - - pkg/apis/storage/v1beta1 - - pkg/util - - pkg/util/parsers - - pkg/version - - plugin/pkg/client/auth - - plugin/pkg/client/auth/gcp - - plugin/pkg/client/auth/oidc - - rest - - rest/fake - - rest/watch - - testing - - third_party/forked/golang/template - - tools/auth - - tools/cache - - tools/clientcmd - - tools/clientcmd/api - - tools/clientcmd/api/latest - - tools/clientcmd/api/v1 - - tools/metrics - - tools/portforward - - tools/record - - transport - - util/cert - - util/clock - - util/flowcontrol - - util/homedir - - util/integer - - util/jsonpath - name: k8s.io/kubernetes - version: 0480917b552be33e2dba47386e51decb1a211df6 + version: d3ada0119e776222f11ec7945e6d860061339aad subpackages: + - cmd/kubeadm/app/apis/kubeadm - federation/apis/federation - federation/apis/federation/install - federation/apis/federation/v1beta1 @@ -486,15 +352,28 @@ imports: - federation/client/clientset_generated/federation_internalclientset/typed/extensions/internalversion - federation/client/clientset_generated/federation_internalclientset/typed/federation/internalversion - pkg/api - - pkg/api/annotations - pkg/api/events + - pkg/api/helper + - pkg/api/helper/qos - pkg/api/install - pkg/api/pod + - pkg/api/ref + - pkg/api/resource - pkg/api/service - pkg/api/testapi - pkg/api/util - pkg/api/v1 + - pkg/api/v1/helper + - pkg/api/v1/helper/qos + - pkg/api/v1/pod + - pkg/api/v1/ref - pkg/api/validation + - pkg/apis/admission + - pkg/apis/admission/install + - pkg/apis/admission/v1alpha1 + - pkg/apis/admissionregistration + - pkg/apis/admissionregistration/install + - pkg/apis/admissionregistration/v1alpha1 - pkg/apis/apps - pkg/apis/apps/install - pkg/apis/apps/v1beta1 @@ -526,6 +405,9 @@ imports: - pkg/apis/imagepolicy - pkg/apis/imagepolicy/install - pkg/apis/imagepolicy/v1alpha1 + - pkg/apis/networking + - pkg/apis/networking/install + - pkg/apis/networking/v1 - pkg/apis/policy - pkg/apis/policy/install - pkg/apis/policy/v1beta1 @@ -544,6 +426,7 @@ imports: - pkg/capabilities - pkg/client/clientset_generated/clientset - pkg/client/clientset_generated/clientset/scheme + - pkg/client/clientset_generated/clientset/typed/admissionregistration/v1alpha1 - pkg/client/clientset_generated/clientset/typed/apps/v1beta1 - pkg/client/clientset_generated/clientset/typed/authentication/v1 - pkg/client/clientset_generated/clientset/typed/authentication/v1beta1 @@ -556,6 +439,7 @@ imports: - pkg/client/clientset_generated/clientset/typed/certificates/v1beta1 - pkg/client/clientset_generated/clientset/typed/core/v1 - pkg/client/clientset_generated/clientset/typed/extensions/v1beta1 + - pkg/client/clientset_generated/clientset/typed/networking/v1 - pkg/client/clientset_generated/clientset/typed/policy/v1beta1 - pkg/client/clientset_generated/clientset/typed/rbac/v1alpha1 - pkg/client/clientset_generated/clientset/typed/rbac/v1beta1 @@ -565,6 +449,8 @@ imports: - pkg/client/clientset_generated/internalclientset - pkg/client/clientset_generated/internalclientset/fake - pkg/client/clientset_generated/internalclientset/scheme + - pkg/client/clientset_generated/internalclientset/typed/admissionregistration/internalversion + - pkg/client/clientset_generated/internalclientset/typed/admissionregistration/internalversion/fake - pkg/client/clientset_generated/internalclientset/typed/apps/internalversion - pkg/client/clientset_generated/internalclientset/typed/apps/internalversion/fake - pkg/client/clientset_generated/internalclientset/typed/authentication/internalversion @@ -581,6 +467,8 @@ imports: - pkg/client/clientset_generated/internalclientset/typed/core/internalversion/fake - pkg/client/clientset_generated/internalclientset/typed/extensions/internalversion - pkg/client/clientset_generated/internalclientset/typed/extensions/internalversion/fake + - pkg/client/clientset_generated/internalclientset/typed/networking/internalversion + - pkg/client/clientset_generated/internalclientset/typed/networking/internalversion/fake - pkg/client/clientset_generated/internalclientset/typed/policy/internalversion - pkg/client/clientset_generated/internalclientset/typed/policy/internalversion/fake - pkg/client/clientset_generated/internalclientset/typed/rbac/internalversion @@ -589,12 +477,19 @@ imports: - pkg/client/clientset_generated/internalclientset/typed/settings/internalversion/fake - pkg/client/clientset_generated/internalclientset/typed/storage/internalversion - pkg/client/clientset_generated/internalclientset/typed/storage/internalversion/fake + - pkg/client/informers/informers_generated/externalversions/apps/v1beta1 + - pkg/client/informers/informers_generated/externalversions/core/v1 + - pkg/client/informers/informers_generated/externalversions/extensions/v1beta1 + - pkg/client/informers/informers_generated/externalversions/internalinterfaces + - pkg/client/leaderelection/resourcelock + - pkg/client/listers/apps/v1beta1 - pkg/client/listers/core/v1 - pkg/client/listers/extensions/v1beta1 - pkg/client/retry - pkg/client/unversioned - - pkg/client/unversioned/remotecommand - pkg/controller + - pkg/controller/daemon + - pkg/controller/daemon/util - pkg/controller/deployment/util - pkg/credentialprovider - pkg/features @@ -602,27 +497,46 @@ imports: - pkg/kubectl - pkg/kubectl/cmd/testing - pkg/kubectl/cmd/util + - pkg/kubectl/cmd/util/openapi + - pkg/kubectl/plugins - pkg/kubectl/resource + - pkg/kubectl/util + - pkg/kubelet/apis - pkg/kubelet/qos - - pkg/kubelet/server/remotecommand - pkg/kubelet/types - pkg/master/ports - pkg/printers - pkg/printers/internalversion + - pkg/registry/rbac/validation - pkg/security/apparmor - pkg/serviceaccount - pkg/util - pkg/util/exec - pkg/util/hash - - pkg/util/interrupt - pkg/util/labels + - pkg/util/metrics + - pkg/util/mount - pkg/util/net/sets - pkg/util/node - pkg/util/parsers - pkg/util/slice - - pkg/util/term - pkg/version + - pkg/volume/util - pkg/watch/json + - plugin/pkg/scheduler/algorithm + - plugin/pkg/scheduler/algorithm/predicates + - plugin/pkg/scheduler/algorithm/priorities/util + - plugin/pkg/scheduler/api + - plugin/pkg/scheduler/schedulercache + - plugin/pkg/scheduler/util +- name: k8s.io/metrics + version: 8efbc8e22d00b9c600afec5f1c14073fd2412fce + subpackages: + - pkg/apis/metrics + - pkg/apis/metrics/v1alpha1 + - pkg/client/clientset_generated/clientset + - pkg/client/clientset_generated/clientset/scheme + - pkg/client/clientset_generated/clientset/typed/metrics/v1alpha1 - name: vbom.ml/util version: db5cfe13f5cc80a4990d98e2e1b0707a4d1a5394 repo: https://github.com/fvbommel/util.git diff --git a/vendor/k8s.io/helm/glide.yaml b/vendor/k8s.io/helm/glide.yaml index 7b298a29..922c4ff0 100644 --- a/vendor/k8s.io/helm/glide.yaml +++ b/vendor/k8s.io/helm/glide.yaml @@ -1,7 +1,6 @@ package: k8s.io/helm import: - package: golang.org/x/net - version: e90d6d0afc4c315a0d87a568ae68577cc15149a0 subpackages: - context - package: github.com/spf13/cobra @@ -18,7 +17,7 @@ import: version: ^2.12 - package: github.com/ghodss/yaml - package: github.com/Masterminds/semver - version: ~1.2.3 + version: ~1.3.1 - package: github.com/technosophos/moniker - package: github.com/golang/protobuf version: 2bba0603135d7d7f5cb73b2125beeda19c09f4ef @@ -28,10 +27,8 @@ import: - ptypes/timestamp - package: google.golang.org/grpc version: 1.2.1 -- package: k8s.io/apimachinery -- package: k8s.io/client-go - package: k8s.io/kubernetes - version: ~1.6.0 + version: ~1.7.0 - package: github.com/gosuri/uitable - package: github.com/asaskevich/govalidator version: ^4.0.0 @@ -49,12 +46,42 @@ import: version: ~0.1.0 - package: github.com/chai2010/gettext-go - package: github.com/prometheus/client_golang - version: v0.8.0 + version: 0.8.0 - package: vbom.ml/util repo: https://github.com/fvbommel/util.git vcs: git - package: github.com/docker/distribution - version: ~v2.4.0 + version: ~2.4.0 + +# hacks for kubernetes v1.7 +- package: cloud.google.com/go +- package: github.com/Azure/go-autorest + version: d7c034a8af24eda120dd6460bfcd6d9ed14e43ca +- package: github.com/dgrijalva/jwt-go +- package: github.com/docker/spdystream +- package: github.com/go-openapi/analysis + version: b44dc874b601d9e4e2f6e19140e794ba24bead3b +- package: github.com/go-openapi/errors + version: d24ebc2075bad502fac3a8ae27aa6dd58e1952dc +- package: github.com/go-openapi/loads + version: 18441dfa706d924a39a030ee2c3b1d8d81917b38 +- package: github.com/go-openapi/spec + version: 6aced65f8501fe1217321abf0749d354824ba2ff +- package: github.com/google/gofuzz +- package: github.com/hashicorp/golang-lru +- package: github.com/howeyc/gopass +- package: github.com/juju/ratelimit + version: 5b9ff866471762aa2ab2dced63c9fb6f53921342 +- package: github.com/pborman/uuid +- package: golang.org/x/oauth2 +- package: gopkg.in/inf.v0 +- package: github.com/go-openapi/strfmt +- package: github.com/mitchellh/mapstructure +- package: gopkg.in/mgo.v2/bson +ignore: + - k8s.io/client-go + - k8s.io/apimachinery + testImports: - package: github.com/stretchr/testify version: ^1.1.4 diff --git a/vendor/k8s.io/helm/pkg/chartutil/create.go b/vendor/k8s.io/helm/pkg/chartutil/create.go index e0e0429d..317737b2 100644 --- a/vendor/k8s.io/helm/pkg/chartutil/create.go +++ b/vendor/k8s.io/helm/pkg/chartutil/create.go @@ -63,7 +63,7 @@ service: internalPort: 80 ingress: enabled: false - # Used to create Ingress record (should used with service.type: ClusterIP). + # Used to create an Ingress record. hosts: - chart-example.local annotations: @@ -75,14 +75,14 @@ ingress: # hosts: # - chart-example.local resources: {} - # We usually recommend not to specify default resources and to leave this as a conscious - # choice for the user. This also increases chances charts run on environments with little - # resources, such as Minikube. If you do want to specify resources, uncomment the following + # We usually recommend not to specify default resources and to leave this as a conscious + # choice for the user. This also increases chances charts run on environments with little + # resources, such as Minikube. If you do want to specify resources, uncomment the following # lines, adjust them as necessary, and remove the curly braces after 'resources:'. # limits: # cpu: 100m # memory: 128Mi - #requests: + # requests: # cpu: 100m # memory: 128Mi ` @@ -205,8 +205,10 @@ spec: ` const defaultNotes = `1. Get the application URL by running these commands: -{{- if .Values.ingress.hostname }} - http://{{- .Values.ingress.hostname }} +{{- if .Values.ingress.enabled }} +{{- range .Values.ingress.hosts }} + http://{{ . }} +{{- end }} {{- else if contains "NodePort" .Values.service.type }} export NODE_PORT=$(kubectl get --namespace {{ .Release.Namespace }} -o jsonpath="{.spec.ports[0].nodePort}" services {{ template "fullname" . }}) export NODE_IP=$(kubectl get nodes --namespace {{ .Release.Namespace }} -o jsonpath="{.items[0].status.addresses[0].address}") diff --git a/vendor/k8s.io/helm/pkg/chartutil/files.go b/vendor/k8s.io/helm/pkg/chartutil/files.go index 470ed711..6ce619e8 100644 --- a/vendor/k8s.io/helm/pkg/chartutil/files.go +++ b/vendor/k8s.io/helm/pkg/chartutil/files.go @@ -94,8 +94,8 @@ func (f Files) Glob(pattern string) Files { } // AsConfig turns a Files group and flattens it to a YAML map suitable for -// including in the `data` section of a kubernetes ConfigMap definition. -// Duplicate keys will be overwritten, so be aware that your filenames +// including in the 'data' section of a Kubernetes ConfigMap definition. +// Duplicate keys will be overwritten, so be aware that your file names // (regardless of path) should be unique. // // This is designed to be called from a template, and will return empty string @@ -103,7 +103,7 @@ func (f Files) Glob(pattern string) Files { // object is nil. // // The output will not be indented, so you will want to pipe this to the -// `indent` template function. +// 'indent' template function. // // data: // {{ .Files.Glob("config/**").AsConfig() | indent 4 }} @@ -122,9 +122,9 @@ func (f Files) AsConfig() string { return ToYaml(m) } -// AsSecrets returns the value of a Files object as base64 suitable for -// including in the `data` section of a kubernetes Secret definition. -// Duplicate keys will be overwritten, so be aware that your filenames +// AsSecrets returns the base64-encoded value of a Files object suitable for +// including in the 'data' section of a Kubernetes Secret definition. +// Duplicate keys will be overwritten, so be aware that your file names // (regardless of path) should be unique. // // This is designed to be called from a template, and will return empty string @@ -132,7 +132,7 @@ func (f Files) AsConfig() string { // object is nil. // // The output will not be indented, so you will want to pipe this to the -// `indent` template function. +// 'indent' template function. // // data: // {{ .Files.Glob("secrets/*").AsSecrets() }} diff --git a/vendor/k8s.io/helm/pkg/chartutil/testdata/moby/values.yaml b/vendor/k8s.io/helm/pkg/chartutil/testdata/moby/values.yaml index 1972c084..54e1ce46 100644 --- a/vendor/k8s.io/helm/pkg/chartutil/testdata/moby/values.yaml +++ b/vendor/k8s.io/helm/pkg/chartutil/testdata/moby/values.yaml @@ -2,3 +2,8 @@ scope: moby name: moby override: bad top: nope +bottom: exists +right: exists +left: exists +front: exists +back: exists diff --git a/vendor/k8s.io/helm/pkg/chartutil/values.go b/vendor/k8s.io/helm/pkg/chartutil/values.go index cc60860c..66a2658d 100644 --- a/vendor/k8s.io/helm/pkg/chartutil/values.go +++ b/vendor/k8s.io/helm/pkg/chartutil/values.go @@ -17,6 +17,7 @@ limitations under the License. package chartutil import ( + "errors" "fmt" "io" "io/ioutil" @@ -278,19 +279,26 @@ func coalesceValues(c *chart.Chart, v map[string]interface{}) (map[string]interf } for key, val := range nv { - if _, ok := v[key]; !ok { + if value, ok := v[key]; ok { + if value == nil { + // When the YAML value is null, we remove the value's key. + // This allows Helm's various sources of values (value files or --set) to + // remove incompatible keys from any previous chart, file, or set values. + delete(v, key) + } else if dest, ok := value.(map[string]interface{}); ok { + // if v[key] is a table, merge nv's val table into v[key]. + src, ok := val.(map[string]interface{}) + if !ok { + log.Printf("warning: skipped value for %s: Not a table.", key) + continue + } + // Because v has higher precedence than nv, dest values override src + // values. + coalesceTables(dest, src) + } + } else { // If the key is not in v, copy it from nv. v[key] = val - } else if dest, ok := v[key].(map[string]interface{}); ok { - // if v[key] is a table, merge nv's val table into v[key]. - src, ok := val.(map[string]interface{}) - if !ok { - log.Printf("warning: skipped value for %s: Not a table.", key) - continue - } - // Because v has higher precedence than nv, dest values override src - // values. - coalesceTables(dest, src) } } return v, nil @@ -380,10 +388,16 @@ func istable(v interface{}) bool { return ok } -// PathValue takes a yaml path with . notation and returns the value if exists +// PathValue takes a path that traverses a YAML structure and returns the value at the end of that path. +// The path starts at the root of the YAML structure and is comprised of YAML keys separated by periods. +// Given the following YAML data the value at path "chapter.one.title" is "Loomings". +// +// chapter: +// one: +// title: "Loomings" func (v Values) PathValue(ypath string) (interface{}, error) { if len(ypath) == 0 { - return nil, fmt.Errorf("yaml path string cannot be zero length") + return nil, errors.New("YAML path string cannot be zero length") } yps := strings.Split(ypath, ".") if len(yps) == 1 { diff --git a/vendor/k8s.io/helm/pkg/chartutil/values_test.go b/vendor/k8s.io/helm/pkg/chartutil/values_test.go index 465eee8a..d9b03c21 100644 --- a/vendor/k8s.io/helm/pkg/chartutil/values_test.go +++ b/vendor/k8s.io/helm/pkg/chartutil/values_test.go @@ -275,8 +275,14 @@ func ttpl(tpl string, v map[string]interface{}) (string, error) { return b.String(), nil } +// ref: http://www.yaml.org/spec/1.2/spec.html#id2803362 var testCoalesceValuesYaml = ` top: yup +bottom: null +right: Null +left: NULL +front: ~ +back: "" global: name: Ishmael @@ -316,6 +322,7 @@ func TestCoalesceValues(t *testing.T) { expect string }{ {"{{.top}}", "yup"}, + {"{{.back}}", ""}, {"{{.name}}", "moby"}, {"{{.global.name}}", "Ishmael"}, {"{{.global.subject}}", "Queequeg"}, @@ -343,6 +350,13 @@ func TestCoalesceValues(t *testing.T) { t.Errorf("Expected %q to expand to %q, got %q", tt.tpl, tt.expect, o) } } + + nullKeys := []string{"bottom", "right", "left", "front"} + for _, nullKey := range nullKeys { + if _, ok := v[nullKey]; ok { + t.Errorf("Expected key %q to be removed, still present", nullKey) + } + } } func TestCoalesceTables(t *testing.T) { @@ -434,10 +448,12 @@ chapter: if _, err := d.PathValue("chapter.doesntexist.one"); err == nil { t.Errorf("Non-existent key in middle of path should return error: %s\n%v", err, d) } + if _, err := d.PathValue(""); err == nil { + t.Error("Asking for the value from an empty path should yield an error") + } if v, err := d.PathValue("title"); err == nil { if v != "Moby Dick" { t.Errorf("Failed to return values for root key title") } } - } diff --git a/vendor/k8s.io/helm/pkg/downloader/manager.go b/vendor/k8s.io/helm/pkg/downloader/manager.go index 388010fb..7c2ad622 100644 --- a/vendor/k8s.io/helm/pkg/downloader/manager.go +++ b/vendor/k8s.io/helm/pkg/downloader/manager.go @@ -206,6 +206,7 @@ func (m *Manager) downloadAll(deps []*chartutil.Dependency) error { } destPath := filepath.Join(m.ChartPath, "charts") + tmpPath := filepath.Join(m.ChartPath, "tmpcharts") // Create 'charts' directory if it doesn't already exist. if fi, err := os.Stat(destPath); err != nil { @@ -216,14 +217,16 @@ func (m *Manager) downloadAll(deps []*chartutil.Dependency) error { return fmt.Errorf("%q is not a directory", destPath) } - fmt.Fprintln(m.Out, "Deleting outdated charts") - for _, dep := range deps { - if err := m.safeDeleteDep(dep.Name, destPath); err != nil { - return err - } + if err := os.Rename(destPath, tmpPath); err != nil { + return fmt.Errorf("Unable to move current charts to tmp dir: %v", err) + } + + if err := os.MkdirAll(destPath, 0755); err != nil { + return err } fmt.Fprintf(m.Out, "Saving %d charts\n", len(deps)) + var saveError error for _, dep := range deps { if strings.HasPrefix(dep.Repository, "file://") { if m.Debug { @@ -231,7 +234,8 @@ func (m *Manager) downloadAll(deps []*chartutil.Dependency) error { } ver, err := tarFromLocalDir(m.ChartPath, dep.Name, dep.Repository, dep.Version) if err != nil { - return err + saveError = err + break } dep.Version = ver continue @@ -243,13 +247,45 @@ func (m *Manager) downloadAll(deps []*chartutil.Dependency) error { // https://github.com/kubernetes/helm/issues/1439 churl, err := findChartURL(dep.Name, dep.Version, dep.Repository, repos) if err != nil { - return fmt.Errorf("could not find %s: %s", churl, err) + saveError = fmt.Errorf("could not find %s: %s", churl, err) + break } if _, _, err := dl.DownloadTo(churl, "", destPath); err != nil { - return fmt.Errorf("could not download %s: %s", churl, err) + saveError = fmt.Errorf("could not download %s: %s", churl, err) + break } } + + if saveError == nil { + fmt.Fprintln(m.Out, "Deleting outdated charts") + for _, dep := range deps { + if err := m.safeDeleteDep(dep.Name, tmpPath); err != nil { + return err + } + } + if err := move(tmpPath, destPath); err != nil { + return err + } + if err := os.RemoveAll(tmpPath); err != nil { + return fmt.Errorf("Failed to remove %v: %v", tmpPath, err) + } + } else { + fmt.Fprintln(m.Out, "Save error occurred: ", saveError) + fmt.Fprintln(m.Out, "Deleting newly downloaded charts, restoring pre-update state") + for _, dep := range deps { + if err := m.safeDeleteDep(dep.Name, destPath); err != nil { + return err + } + } + if err := os.RemoveAll(destPath); err != nil { + return fmt.Errorf("Failed to remove %v: %v", destPath, err) + } + if err := os.Rename(tmpPath, destPath); err != nil { + return fmt.Errorf("Unable to move current charts to tmp dir: %v", err) + } + return saveError + } return nil } @@ -577,3 +613,17 @@ func tarFromLocalDir(chartpath string, name string, repo string, version string) return "", fmt.Errorf("can't get a valid version for dependency %s", name) } + +// move files from tmppath to destpath +func move(tmpPath, destPath string) error { + files, _ := ioutil.ReadDir(tmpPath) + for _, file := range files { + filename := file.Name() + tmpfile := filepath.Join(tmpPath, filename) + destfile := filepath.Join(destPath, filename) + if err := os.Rename(tmpfile, destfile); err != nil { + return fmt.Errorf("Unable to move local charts to charts dir: %v", err) + } + } + return nil +} diff --git a/vendor/k8s.io/helm/pkg/getter/httpgetter.go b/vendor/k8s.io/helm/pkg/getter/httpgetter.go index 1dfffb6d..9afa31f6 100644 --- a/vendor/k8s.io/helm/pkg/getter/httpgetter.go +++ b/vendor/k8s.io/helm/pkg/getter/httpgetter.go @@ -50,7 +50,7 @@ func (g *httpGetter) Get(href string) (*bytes.Buffer, error) { // newHTTPGetter constructs a valid http/https client as Getter func newHTTPGetter(URL, CertFile, KeyFile, CAFile string) (Getter, error) { var client httpGetter - if CertFile != "" && KeyFile != "" && CAFile != "" { + if CertFile != "" && KeyFile != "" { tlsConf, err := tlsutil.NewClientTLS(CertFile, KeyFile, CAFile) if err != nil { return nil, fmt.Errorf("can't create TLS config for client: %s", err.Error()) diff --git a/vendor/k8s.io/helm/pkg/helm/client.go b/vendor/k8s.io/helm/pkg/helm/client.go index 7e41b89b..dbaf01d9 100644 --- a/vendor/k8s.io/helm/pkg/helm/client.go +++ b/vendor/k8s.io/helm/pkg/helm/client.go @@ -29,7 +29,7 @@ import ( rls "k8s.io/helm/pkg/proto/hapi/services" ) -// Client manages client side of the helm-tiller protocol +// Client manages client side of the Helm-Tiller protocol. type Client struct { opts options } @@ -40,7 +40,7 @@ func NewClient(opts ...Option) *Client { return c.Option(opts...) } -// Option configures the helm client with the provided options +// Option configures the Helm client with the provided options. func (h *Client) Option(opts ...Option) *Client { for _, opt := range opts { opt(&h.opts) @@ -64,7 +64,7 @@ func (h *Client) ListReleases(opts ...ReleaseListOption) (*rls.ListReleasesRespo return h.list(ctx, req) } -// InstallRelease loads a chart from chstr, installs it and returns the release response. +// InstallRelease loads a chart from chstr, installs it, and returns the release response. func (h *Client) InstallRelease(chstr, ns string, opts ...InstallOption) (*rls.InstallReleaseResponse, error) { // load the chart to install chart, err := chartutil.Load(chstr) @@ -135,7 +135,7 @@ func (h *Client) DeleteRelease(rlsName string, opts ...DeleteOption) (*rls.Unins return h.delete(ctx, req) } -// UpdateRelease loads a chart from chstr and updates a release to a new/different chart +// UpdateRelease loads a chart from chstr and updates a release to a new/different chart. func (h *Client) UpdateRelease(rlsName string, chstr string, opts ...UpdateOption) (*rls.UpdateReleaseResponse, error) { // load the chart to update chart, err := chartutil.Load(chstr) @@ -146,7 +146,7 @@ func (h *Client) UpdateRelease(rlsName string, chstr string, opts ...UpdateOptio return h.UpdateReleaseFromChart(rlsName, chart, opts...) } -// UpdateReleaseFromChart updates a release to a new/different chart +// UpdateReleaseFromChart updates a release to a new/different chart. func (h *Client) UpdateReleaseFromChart(rlsName string, chart *chart.Chart, opts ...UpdateOption) (*rls.UpdateReleaseResponse, error) { // apply the update options @@ -181,7 +181,7 @@ func (h *Client) UpdateReleaseFromChart(rlsName string, chart *chart.Chart, opts return h.update(ctx, req) } -// GetVersion returns the server version +// GetVersion returns the server version. func (h *Client) GetVersion(opts ...VersionOption) (*rls.GetVersionResponse, error) { for _, opt := range opts { opt(&h.opts) @@ -197,7 +197,7 @@ func (h *Client) GetVersion(opts ...VersionOption) (*rls.GetVersionResponse, err return h.version(ctx, req) } -// RollbackRelease rolls back a release to the previous version +// RollbackRelease rolls back a release to the previous version. func (h *Client) RollbackRelease(rlsName string, opts ...RollbackOption) (*rls.RollbackReleaseResponse, error) { for _, opt := range opts { opt(&h.opts) @@ -270,7 +270,7 @@ func (h *Client) ReleaseHistory(rlsName string, opts ...HistoryOption) (*rls.Get return h.history(ctx, req) } -// RunReleaseTest executes a pre-defined test on a release +// RunReleaseTest executes a pre-defined test on a release. func (h *Client) RunReleaseTest(rlsName string, opts ...ReleaseTestOption) (<-chan *rls.TestReleaseResponse, <-chan error) { for _, opt := range opts { opt(&h.opts) @@ -283,7 +283,7 @@ func (h *Client) RunReleaseTest(rlsName string, opts ...ReleaseTestOption) (<-ch return h.test(ctx, req) } -// connect returns a grpc connection to tiller or error. The grpc dial options +// connect returns a gRPC connection to Tiller or error. The gRPC dial options // are constructed here. func (h *Client) connect(ctx context.Context) (conn *grpc.ClientConn, err error) { opts := []grpc.DialOption{ diff --git a/vendor/k8s.io/helm/pkg/helm/fake.go b/vendor/k8s.io/helm/pkg/helm/fake.go new file mode 100644 index 00000000..c6677767 --- /dev/null +++ b/vendor/k8s.io/helm/pkg/helm/fake.go @@ -0,0 +1,147 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package helm // import "k8s.io/helm/pkg/helm" + +import ( + "fmt" + "sync" + + "k8s.io/helm/pkg/proto/hapi/chart" + "k8s.io/helm/pkg/proto/hapi/release" + rls "k8s.io/helm/pkg/proto/hapi/services" + "k8s.io/helm/pkg/proto/hapi/version" +) + +// FakeClient implements Interface +type FakeClient struct { + Rels []*release.Release + Responses map[string]release.TestRun_Status + Err error +} + +var _ Interface = &FakeClient{} +var _ Interface = (*FakeClient)(nil) + +// ListReleases lists the current releases +func (c *FakeClient) ListReleases(opts ...ReleaseListOption) (*rls.ListReleasesResponse, error) { + resp := &rls.ListReleasesResponse{ + Count: int64(len(c.Rels)), + Releases: c.Rels, + } + return resp, c.Err +} + +// InstallRelease returns a response with the first Release on the fake release client +func (c *FakeClient) InstallRelease(chStr, ns string, opts ...InstallOption) (*rls.InstallReleaseResponse, error) { + return &rls.InstallReleaseResponse{ + Release: c.Rels[0], + }, nil +} + +// InstallReleaseFromChart returns a response with the first Release on the fake release client +func (c *FakeClient) InstallReleaseFromChart(chart *chart.Chart, ns string, opts ...InstallOption) (*rls.InstallReleaseResponse, error) { + return &rls.InstallReleaseResponse{ + Release: c.Rels[0], + }, nil +} + +// DeleteRelease returns nil, nil +func (c *FakeClient) DeleteRelease(rlsName string, opts ...DeleteOption) (*rls.UninstallReleaseResponse, error) { + return nil, nil +} + +// UpdateRelease returns nil, nil +func (c *FakeClient) UpdateRelease(rlsName string, chStr string, opts ...UpdateOption) (*rls.UpdateReleaseResponse, error) { + return nil, nil +} + +// GetVersion returns a fake version +func (c *FakeClient) GetVersion(opts ...VersionOption) (*rls.GetVersionResponse, error) { + return &rls.GetVersionResponse{ + Version: &version.Version{ + SemVer: "1.2.3-fakeclient+testonly", + }, + }, nil +} + +// UpdateReleaseFromChart returns nil, nil +func (c *FakeClient) UpdateReleaseFromChart(rlsName string, chart *chart.Chart, opts ...UpdateOption) (*rls.UpdateReleaseResponse, error) { + return nil, nil +} + +// RollbackRelease returns nil, nil +func (c *FakeClient) RollbackRelease(rlsName string, opts ...RollbackOption) (*rls.RollbackReleaseResponse, error) { + return nil, nil +} + +// ReleaseStatus returns a release status response with info from the first release in the fake +// release client +func (c *FakeClient) ReleaseStatus(rlsName string, opts ...StatusOption) (*rls.GetReleaseStatusResponse, error) { + if c.Rels[0] != nil { + return &rls.GetReleaseStatusResponse{ + Name: c.Rels[0].Name, + Info: c.Rels[0].Info, + Namespace: c.Rels[0].Namespace, + }, nil + } + return nil, fmt.Errorf("No such release: %s", rlsName) +} + +// ReleaseContent returns the configuration for the first release in the fake release client +func (c *FakeClient) ReleaseContent(rlsName string, opts ...ContentOption) (resp *rls.GetReleaseContentResponse, err error) { + if len(c.Rels) > 0 { + resp = &rls.GetReleaseContentResponse{ + Release: c.Rels[0], + } + } + return resp, c.Err +} + +// ReleaseHistory returns a release's revision history. +func (c *FakeClient) ReleaseHistory(rlsName string, opts ...HistoryOption) (*rls.GetHistoryResponse, error) { + return &rls.GetHistoryResponse{Releases: c.Rels}, c.Err +} + +// RunReleaseTest executes a pre-defined tests on a release +func (c *FakeClient) RunReleaseTest(rlsName string, opts ...ReleaseTestOption) (<-chan *rls.TestReleaseResponse, <-chan error) { + + results := make(chan *rls.TestReleaseResponse) + errc := make(chan error, 1) + + go func() { + var wg sync.WaitGroup + for m, s := range c.Responses { + wg.Add(1) + + go func(msg string, status release.TestRun_Status) { + defer wg.Done() + results <- &rls.TestReleaseResponse{Msg: msg, Status: status} + }(m, s) + } + + wg.Wait() + close(results) + close(errc) + }() + + return results, errc +} + +// Option returns the fake release client +func (c *FakeClient) Option(opt ...Option) Interface { + return c +} diff --git a/vendor/k8s.io/helm/pkg/helm/helm_test.go b/vendor/k8s.io/helm/pkg/helm/helm_test.go index bcaeec2f..b680750c 100644 --- a/vendor/k8s.io/helm/pkg/helm/helm_test.go +++ b/vendor/k8s.io/helm/pkg/helm/helm_test.go @@ -31,13 +31,13 @@ import ( tpb "k8s.io/helm/pkg/proto/hapi/services" ) -// path to example charts relative to pkg/helm. +// Path to example charts relative to pkg/helm. const chartsDir = "../../docs/examples/" -// sentinel error to indicate to the helm client to not send the request to tiller. +// Sentinel error to indicate to the Helm client to not send the request to Tiller. var errSkip = errors.New("test: skip") -// Verify ReleaseListOption's are applied to a ListReleasesRequest correctly. +// Verify each ReleaseListOption is applied to a ListReleasesRequest correctly. func TestListReleases_VerifyOptions(t *testing.T) { // Options testdata var limit = 2 @@ -75,7 +75,7 @@ func TestListReleases_VerifyOptions(t *testing.T) { ReleaseListNamespace(namespace), } - // BeforeCall option to intercept helm client ListReleasesRequest + // BeforeCall option to intercept Helm client ListReleasesRequest b4c := BeforeCall(func(_ context.Context, msg proto.Message) error { switch act := msg.(type) { case *tpb.ListReleasesRequest: @@ -92,7 +92,7 @@ func TestListReleases_VerifyOptions(t *testing.T) { } } -// Verify InstallOption's are applied to an InstallReleaseRequest correctly. +// Verify each InstallOption is applied to an InstallReleaseRequest correctly. func TestInstallRelease_VerifyOptions(t *testing.T) { // Options testdata var disableHooks = true @@ -124,7 +124,7 @@ func TestInstallRelease_VerifyOptions(t *testing.T) { InstallDisableHooks(disableHooks), } - // BeforeCall option to intercept helm client InstallReleaseRequest + // BeforeCall option to intercept Helm client InstallReleaseRequest b4c := BeforeCall(func(_ context.Context, msg proto.Message) error { switch act := msg.(type) { case *tpb.InstallReleaseRequest: @@ -141,7 +141,7 @@ func TestInstallRelease_VerifyOptions(t *testing.T) { } } -// Verify DeleteOptions's are applied to an UninstallReleaseRequest correctly. +// Verify each DeleteOptions is applied to an UninstallReleaseRequest correctly. func TestDeleteRelease_VerifyOptions(t *testing.T) { // Options testdata var releaseName = "test" @@ -161,7 +161,7 @@ func TestDeleteRelease_VerifyOptions(t *testing.T) { DeleteDisableHooks(disableHooks), } - // BeforeCall option to intercept helm client DeleteReleaseRequest + // BeforeCall option to intercept Helm client DeleteReleaseRequest b4c := BeforeCall(func(_ context.Context, msg proto.Message) error { switch act := msg.(type) { case *tpb.UninstallReleaseRequest: @@ -178,7 +178,7 @@ func TestDeleteRelease_VerifyOptions(t *testing.T) { } } -// Verify UpdateOption's are applied to an UpdateReleaseRequest correctly. +// Verify each UpdateOption is applied to an UpdateReleaseRequest correctly. func TestUpdateRelease_VerifyOptions(t *testing.T) { // Options testdata var chartName = "alpine" @@ -204,7 +204,7 @@ func TestUpdateRelease_VerifyOptions(t *testing.T) { UpgradeDisableHooks(disableHooks), } - // BeforeCall option to intercept helm client UpdateReleaseRequest + // BeforeCall option to intercept Helm client UpdateReleaseRequest b4c := BeforeCall(func(_ context.Context, msg proto.Message) error { switch act := msg.(type) { case *tpb.UpdateReleaseRequest: @@ -221,7 +221,7 @@ func TestUpdateRelease_VerifyOptions(t *testing.T) { } } -// Verify RollbackOption's are applied to a RollbackReleaseRequest correctly. +// Verify each RollbackOption is applied to a RollbackReleaseRequest correctly. func TestRollbackRelease_VerifyOptions(t *testing.T) { // Options testdata var disableHooks = true @@ -244,7 +244,7 @@ func TestRollbackRelease_VerifyOptions(t *testing.T) { RollbackDisableHooks(disableHooks), } - // BeforeCall option to intercept helm client RollbackReleaseRequest + // BeforeCall option to intercept Helm client RollbackReleaseRequest b4c := BeforeCall(func(_ context.Context, msg proto.Message) error { switch act := msg.(type) { case *tpb.RollbackReleaseRequest: @@ -261,7 +261,7 @@ func TestRollbackRelease_VerifyOptions(t *testing.T) { } } -// Verify StatusOption's are applied to a GetReleaseStatusRequest correctly. +// Verify each StatusOption is applied to a GetReleaseStatusRequest correctly. func TestReleaseStatus_VerifyOptions(t *testing.T) { // Options testdata var releaseName = "test" @@ -273,7 +273,7 @@ func TestReleaseStatus_VerifyOptions(t *testing.T) { Version: revision, } - // BeforeCall option to intercept helm client GetReleaseStatusRequest + // BeforeCall option to intercept Helm client GetReleaseStatusRequest b4c := BeforeCall(func(_ context.Context, msg proto.Message) error { switch act := msg.(type) { case *tpb.GetReleaseStatusRequest: @@ -290,7 +290,7 @@ func TestReleaseStatus_VerifyOptions(t *testing.T) { } } -// Verify ContentOption's are applied to a GetReleaseContentRequest correctly. +// Verify each ContentOption is applied to a GetReleaseContentRequest correctly. func TestReleaseContent_VerifyOptions(t *testing.T) { // Options testdata var releaseName = "test" @@ -302,7 +302,7 @@ func TestReleaseContent_VerifyOptions(t *testing.T) { Version: revision, } - // BeforeCall option to intercept helm client GetReleaseContentRequest + // BeforeCall option to intercept Helm client GetReleaseContentRequest b4c := BeforeCall(func(_ context.Context, msg proto.Message) error { switch act := msg.(type) { case *tpb.GetReleaseContentRequest: diff --git a/vendor/k8s.io/helm/pkg/helm/portforwarder/portforwarder.go b/vendor/k8s.io/helm/pkg/helm/portforwarder/portforwarder.go index 77c9bc9a..617da7a1 100644 --- a/vendor/k8s.io/helm/pkg/helm/portforwarder/portforwarder.go +++ b/vendor/k8s.io/helm/pkg/helm/portforwarder/portforwarder.go @@ -29,6 +29,10 @@ import ( "k8s.io/helm/pkg/kube" ) +var ( + tillerPodLabels labels.Set = labels.Set{"app": "helm", "name": "tiller"} +) + // New creates a new and initialized tunnel. func New(namespace string, client kubernetes.Interface, config *rest.Config) (*kube.Tunnel, error) { podName, err := getTillerPodName(client.CoreV1(), namespace) @@ -41,8 +45,7 @@ func New(namespace string, client kubernetes.Interface, config *rest.Config) (*k } func getTillerPodName(client corev1.PodsGetter, namespace string) (string, error) { - // TODO use a const for labels - selector := labels.Set{"app": "helm", "name": "tiller"}.AsSelector() + selector := tillerPodLabels.AsSelector() pod, err := getFirstRunningPod(client, namespace, selector) if err != nil { return "", err diff --git a/vendor/k8s.io/helm/pkg/helm/portforwarder/portforwarder_test.go b/vendor/k8s.io/helm/pkg/helm/portforwarder/portforwarder_test.go index 96455445..f98e1f01 100644 --- a/vendor/k8s.io/helm/pkg/helm/portforwarder/portforwarder_test.go +++ b/vendor/k8s.io/helm/pkg/helm/portforwarder/portforwarder_test.go @@ -29,7 +29,7 @@ func mockTillerPod() v1.Pod { ObjectMeta: metav1.ObjectMeta{ Name: "orca", Namespace: v1.NamespaceDefault, - Labels: map[string]string{"app": "helm", "name": "tiller"}, + Labels: tillerPodLabels, }, Status: v1.PodStatus{ Phase: v1.PodRunning, diff --git a/vendor/k8s.io/helm/pkg/kube/client.go b/vendor/k8s.io/helm/pkg/kube/client.go index 04e28e81..c0a9a42b 100644 --- a/vendor/k8s.io/helm/pkg/kube/client.go +++ b/vendor/k8s.io/helm/pkg/kube/client.go @@ -39,6 +39,7 @@ import ( "k8s.io/apimachinery/pkg/watch" "k8s.io/client-go/tools/clientcmd" "k8s.io/kubernetes/pkg/api" + "k8s.io/kubernetes/pkg/api/helper" "k8s.io/kubernetes/pkg/api/v1" apps "k8s.io/kubernetes/pkg/apis/apps/v1beta1" batchinternal "k8s.io/kubernetes/pkg/apis/batch" @@ -63,7 +64,7 @@ type Client struct { Log func(string, ...interface{}) } -// New create a new Client +// New creates a new Client. func New(config clientcmd.ClientConfig) *Client { return &Client{ Factory: cmdutil.NewFactory(config), @@ -75,9 +76,9 @@ func New(config clientcmd.ClientConfig) *Client { // ResourceActorFunc performs an action on a single resource. type ResourceActorFunc func(*resource.Info) error -// Create creates kubernetes resources from an io.reader +// Create creates Kubernetes resources from an io.reader. // -// Namespace will set the namespace +// Namespace will set the namespace. func (c *Client) Create(namespace string, reader io.Reader, timeout int64, shouldWait bool) error { client, err := c.ClientSet() if err != nil { @@ -106,7 +107,7 @@ func (c *Client) newBuilder(namespace string, reader io.Reader) *resource.Result if err != nil { c.Log("warning: failed to load schema: %s", err) } - return c.NewBuilder(). + return c.NewBuilder(true). ContinueOnError(). Schema(schema). NamespaceParam(namespace). @@ -123,14 +124,12 @@ func (c *Client) BuildUnstructured(namespace string, reader io.Reader) (Result, c.Log("warning: failed to load schema: %s", err) } - mapper, typer, err := c.UnstructuredObject() - if err != nil { - c.Log("failed to load mapper: %s", err) - return nil, err - } var result Result - result, err = resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(c.UnstructuredClientForMapping), unstructured.UnstructuredJSONScheme). - ContinueOnError(). + b, err := c.NewUnstructuredBuilder(true) + if err != nil { + return result, err + } + result, err = b.ContinueOnError(). Schema(schema). NamespaceParam(namespace). DefaultNamespace(). @@ -147,12 +146,12 @@ func (c *Client) Build(namespace string, reader io.Reader) (Result, error) { return result, scrubValidationError(err) } -// Get gets kubernetes resources as pretty printed string +// Get gets Kubernetes resources as pretty-printed string. // -// Namespace will set the namespace +// Namespace will set the namespace. func (c *Client) Get(namespace string, reader io.Reader) (string, error) { // Since we don't know what order the objects come in, let's group them by the types, so - // that when we print them, they come looking good (headers apply to subgroups, etc.) + // that when we print them, they come out looking good (headers apply to subgroups, etc.). objs := make(map[string][]runtime.Object) infos, err := c.BuildUnstructured(namespace, reader) if err != nil { @@ -181,7 +180,7 @@ func (c *Client) Get(namespace string, reader io.Reader) (string, error) { // Ok, now we have all the objects grouped by types (say, by v1/Pod, v1/Service, etc.), so // spin through them and print them. Printer is cool since it prints the header only when // an object type changes, so we can just rely on that. Problem is it doesn't seem to keep - // track of tab widths + // track of tab widths. buf := new(bytes.Buffer) p, _ := c.Printer(nil, printers.PrintOptions{}) for t, ot := range objs { @@ -208,11 +207,11 @@ func (c *Client) Get(namespace string, reader io.Reader) (string, error) { } // Update reads in the current configuration and a target configuration from io.reader -// and creates resources that don't already exists, updates resources that have been modified -// in the target configuration and deletes resources from the current configuration that are -// not present in the target configuration +// and creates resources that don't already exists, updates resources that have been modified +// in the target configuration and deletes resources from the current configuration that are +// not present in the target configuration. // -// Namespace will set the namespaces +// Namespace will set the namespaces. func (c *Client) Update(namespace string, originalReader, targetReader io.Reader, force bool, recreate bool, timeout int64, shouldWait bool) error { original, err := c.BuildUnstructured(namespace, originalReader) if err != nil { @@ -281,9 +280,9 @@ func (c *Client) Update(namespace string, originalReader, targetReader io.Reader return nil } -// Delete deletes kubernetes resources from an io.reader +// Delete deletes Kubernetes resources from an io.reader. // -// Namespace will set the namespace +// Namespace will set the namespace. func (c *Client) Delete(namespace string, reader io.Reader) error { infos, err := c.BuildUnstructured(namespace, reader) if err != nil { @@ -376,7 +375,7 @@ func createPatch(mapping *meta.RESTMapping, target, current runtime.Object) ([]b return nil, types.StrategicMergePatchType, fmt.Errorf("serializing target configuration: %s", err) } - if api.Semantic.DeepEqual(oldData, newData) { + if helper.Semantic.DeepEqual(oldData, newData) { return nil, types.StrategicMergePatchType, nil } @@ -577,7 +576,7 @@ func (c *Client) waitForJob(e watch.Event, name string) (bool, error) { return false, nil } -// scrubValidationError removes kubectl info from the message +// scrubValidationError removes kubectl info from the message. func scrubValidationError(err error) error { if err == nil { return nil @@ -591,7 +590,7 @@ func scrubValidationError(err error) error { } // WaitAndGetCompletedPodPhase waits up to a timeout until a pod enters a completed phase -// and returns said phase (PodSucceeded or PodFailed qualify) +// and returns said phase (PodSucceeded or PodFailed qualify). func (c *Client) WaitAndGetCompletedPodPhase(namespace string, reader io.Reader, timeout time.Duration) (api.PodPhase, error) { infos, err := c.Build(namespace, reader) if err != nil { diff --git a/vendor/k8s.io/helm/pkg/kube/client_test.go b/vendor/k8s.io/helm/pkg/kube/client_test.go index 647a5065..889a12f7 100644 --- a/vendor/k8s.io/helm/pkg/kube/client_test.go +++ b/vendor/k8s.io/helm/pkg/kube/client_test.go @@ -174,7 +174,7 @@ func TestUpdate(t *testing.T) { t.Fatalf("could not dump request: %s", err) } req.Body.Close() - expected := `{"spec":{"containers":[{"name":"app:v4","ports":[{"containerPort":443,"name":"https"},{"$patch":"delete","containerPort":80}]}]}}` + expected := `{"spec":{"$setElementOrder/containers":[{"name":"app:v4"}],"containers":[{"$setElementOrder/ports":[{"containerPort":443}],"name":"app:v4","ports":[{"containerPort":443,"name":"https"},{"$patch":"delete","containerPort":80}]}]}}` if string(data) != expected { t.Errorf("expected patch\n%s\ngot\n%s", expected, string(data)) } diff --git a/vendor/k8s.io/helm/pkg/kube/config.go b/vendor/k8s.io/helm/pkg/kube/config.go index 27b22b44..b6560486 100644 --- a/vendor/k8s.io/helm/pkg/kube/config.go +++ b/vendor/k8s.io/helm/pkg/kube/config.go @@ -18,7 +18,7 @@ package kube // import "k8s.io/helm/pkg/kube" import "k8s.io/client-go/tools/clientcmd" -// GetConfig returns a kubernetes client config for a given context. +// GetConfig returns a Kubernetes client config for a given context. func GetConfig(context string) clientcmd.ClientConfig { rules := clientcmd.NewDefaultClientConfigLoadingRules() rules.DefaultClientConfig = &clientcmd.DefaultClientConfig diff --git a/vendor/k8s.io/helm/pkg/kube/tunnel.go b/vendor/k8s.io/helm/pkg/kube/tunnel.go index 156fab75..9c8f31e6 100644 --- a/vendor/k8s.io/helm/pkg/kube/tunnel.go +++ b/vendor/k8s.io/helm/pkg/kube/tunnel.go @@ -25,7 +25,7 @@ import ( "k8s.io/client-go/rest" "k8s.io/client-go/tools/portforward" - "k8s.io/kubernetes/pkg/client/unversioned/remotecommand" + "k8s.io/client-go/tools/remotecommand" ) // Tunnel describes a ssh-like tunnel to a kubernetes pod diff --git a/vendor/k8s.io/helm/pkg/kube/wait.go b/vendor/k8s.io/helm/pkg/kube/wait.go index d917d79e..30173167 100644 --- a/vendor/k8s.io/helm/pkg/kube/wait.go +++ b/vendor/k8s.io/helm/pkg/kube/wait.go @@ -25,6 +25,8 @@ import ( "k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/util/wait" "k8s.io/kubernetes/pkg/api/v1" + "k8s.io/kubernetes/pkg/api/v1/helper" + podutil "k8s.io/kubernetes/pkg/api/v1/pod" apps "k8s.io/kubernetes/pkg/apis/apps/v1beta1" extensions "k8s.io/kubernetes/pkg/apis/extensions/v1beta1" "k8s.io/kubernetes/pkg/client/clientset_generated/clientset" @@ -128,7 +130,7 @@ func (c *Client) waitForResources(timeout time.Duration, created Result) error { func podsReady(pods []v1.Pod) bool { for _, pod := range pods { - if !v1.IsPodReady(&pod) { + if !podutil.IsPodReady(&pod) { return false } } @@ -143,7 +145,7 @@ func servicesReady(svc []v1.Service) bool { } // Make sure the service is not explicitly set to "None" before checking the IP - if s.Spec.ClusterIP != v1.ClusterIPNone && !v1.IsServiceIPSet(&s) { + if s.Spec.ClusterIP != v1.ClusterIPNone && !helper.IsServiceIPSet(&s) { return false } // This checks if the service has a LoadBalancer and that balancer has an Ingress defined diff --git a/vendor/k8s.io/helm/pkg/proto/hapi/chart/chart.pb.go b/vendor/k8s.io/helm/pkg/proto/hapi/chart/chart.pb.go index dbb188e9..a884ed55 100644 --- a/vendor/k8s.io/helm/pkg/proto/hapi/chart/chart.pb.go +++ b/vendor/k8s.io/helm/pkg/proto/hapi/chart/chart.pb.go @@ -1,6 +1,5 @@ -// Code generated by protoc-gen-go. +// Code generated by protoc-gen-go. DO NOT EDIT. // source: hapi/chart/chart.proto -// DO NOT EDIT! /* Package chart is a generated protocol buffer package. diff --git a/vendor/k8s.io/helm/pkg/proto/hapi/chart/config.pb.go b/vendor/k8s.io/helm/pkg/proto/hapi/chart/config.pb.go index 4a8b36d8..30c65270 100644 --- a/vendor/k8s.io/helm/pkg/proto/hapi/chart/config.pb.go +++ b/vendor/k8s.io/helm/pkg/proto/hapi/chart/config.pb.go @@ -1,6 +1,5 @@ -// Code generated by protoc-gen-go. +// Code generated by protoc-gen-go. DO NOT EDIT. // source: hapi/chart/config.proto -// DO NOT EDIT! package chart diff --git a/vendor/k8s.io/helm/pkg/proto/hapi/chart/metadata.pb.go b/vendor/k8s.io/helm/pkg/proto/hapi/chart/metadata.pb.go index 82abb04f..320ebf73 100644 --- a/vendor/k8s.io/helm/pkg/proto/hapi/chart/metadata.pb.go +++ b/vendor/k8s.io/helm/pkg/proto/hapi/chart/metadata.pb.go @@ -1,6 +1,5 @@ -// Code generated by protoc-gen-go. +// Code generated by protoc-gen-go. DO NOT EDIT. // source: hapi/chart/metadata.proto -// DO NOT EDIT! package chart diff --git a/vendor/k8s.io/helm/pkg/proto/hapi/chart/template.pb.go b/vendor/k8s.io/helm/pkg/proto/hapi/chart/template.pb.go index 416269d1..439aec5a 100644 --- a/vendor/k8s.io/helm/pkg/proto/hapi/chart/template.pb.go +++ b/vendor/k8s.io/helm/pkg/proto/hapi/chart/template.pb.go @@ -1,6 +1,5 @@ -// Code generated by protoc-gen-go. +// Code generated by protoc-gen-go. DO NOT EDIT. // source: hapi/chart/template.proto -// DO NOT EDIT! package chart diff --git a/vendor/k8s.io/helm/pkg/proto/hapi/release/hook.pb.go b/vendor/k8s.io/helm/pkg/proto/hapi/release/hook.pb.go index 1724842e..f7d5419c 100644 --- a/vendor/k8s.io/helm/pkg/proto/hapi/release/hook.pb.go +++ b/vendor/k8s.io/helm/pkg/proto/hapi/release/hook.pb.go @@ -1,6 +1,5 @@ -// Code generated by protoc-gen-go. +// Code generated by protoc-gen-go. DO NOT EDIT. // source: hapi/release/hook.proto -// DO NOT EDIT! /* Package release is a generated protocol buffer package. diff --git a/vendor/k8s.io/helm/pkg/proto/hapi/release/info.pb.go b/vendor/k8s.io/helm/pkg/proto/hapi/release/info.pb.go index 9485ad05..7a7ccdd7 100644 --- a/vendor/k8s.io/helm/pkg/proto/hapi/release/info.pb.go +++ b/vendor/k8s.io/helm/pkg/proto/hapi/release/info.pb.go @@ -1,6 +1,5 @@ -// Code generated by protoc-gen-go. +// Code generated by protoc-gen-go. DO NOT EDIT. // source: hapi/release/info.proto -// DO NOT EDIT! package release diff --git a/vendor/k8s.io/helm/pkg/proto/hapi/release/release.pb.go b/vendor/k8s.io/helm/pkg/proto/hapi/release/release.pb.go index 47b321b5..511b543d 100644 --- a/vendor/k8s.io/helm/pkg/proto/hapi/release/release.pb.go +++ b/vendor/k8s.io/helm/pkg/proto/hapi/release/release.pb.go @@ -1,6 +1,5 @@ -// Code generated by protoc-gen-go. +// Code generated by protoc-gen-go. DO NOT EDIT. // source: hapi/release/release.proto -// DO NOT EDIT! package release diff --git a/vendor/k8s.io/helm/pkg/proto/hapi/release/status.pb.go b/vendor/k8s.io/helm/pkg/proto/hapi/release/status.pb.go index 0098207a..28489264 100644 --- a/vendor/k8s.io/helm/pkg/proto/hapi/release/status.pb.go +++ b/vendor/k8s.io/helm/pkg/proto/hapi/release/status.pb.go @@ -1,6 +1,5 @@ -// Code generated by protoc-gen-go. +// Code generated by protoc-gen-go. DO NOT EDIT. // source: hapi/release/status.proto -// DO NOT EDIT! package release @@ -29,6 +28,12 @@ const ( Status_FAILED Status_Code = 4 // Status_DELETING indicates that a delete operation is underway. Status_DELETING Status_Code = 5 + // Status_PENDING_INSTALL indicates that an install operation is underway. + Status_PENDING_INSTALL Status_Code = 6 + // Status_PENDING_UPGRADE indicates that an upgrade operation is underway. + Status_PENDING_UPGRADE Status_Code = 7 + // Status_PENDING_ROLLBACK indicates that an rollback operation is underway. + Status_PENDING_ROLLBACK Status_Code = 8 ) var Status_Code_name = map[int32]string{ @@ -38,14 +43,20 @@ var Status_Code_name = map[int32]string{ 3: "SUPERSEDED", 4: "FAILED", 5: "DELETING", + 6: "PENDING_INSTALL", + 7: "PENDING_UPGRADE", + 8: "PENDING_ROLLBACK", } var Status_Code_value = map[string]int32{ - "UNKNOWN": 0, - "DEPLOYED": 1, - "DELETED": 2, - "SUPERSEDED": 3, - "FAILED": 4, - "DELETING": 5, + "UNKNOWN": 0, + "DEPLOYED": 1, + "DELETED": 2, + "SUPERSEDED": 3, + "FAILED": 4, + "DELETING": 5, + "PENDING_INSTALL": 6, + "PENDING_UPGRADE": 7, + "PENDING_ROLLBACK": 8, } func (x Status_Code) String() string { @@ -105,24 +116,26 @@ func init() { func init() { proto.RegisterFile("hapi/release/status.proto", fileDescriptor3) } var fileDescriptor3 = []byte{ - // 291 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0xdf, 0x6a, 0xc2, 0x30, - 0x14, 0xc6, 0x57, 0xad, 0x3a, 0x8f, 0x22, 0x21, 0x1b, 0xac, 0xca, 0x06, 0xc5, 0xab, 0xde, 0xac, - 0x05, 0xf7, 0x04, 0xdb, 0x12, 0x87, 0xac, 0x54, 0x69, 0x2b, 0xfb, 0x73, 0x53, 0xaa, 0x9e, 0x39, - 0xa1, 0x34, 0xd2, 0x24, 0x17, 0x7b, 0x88, 0xbd, 0xf3, 0x68, 0x2b, 0x74, 0x5e, 0x7e, 0xf9, 0xfd, - 0x4e, 0xce, 0xc7, 0x81, 0xf1, 0x77, 0x7a, 0x3c, 0x78, 0x05, 0x66, 0x98, 0x4a, 0xf4, 0xa4, 0x4a, - 0x95, 0x96, 0xee, 0xb1, 0x10, 0x4a, 0xd0, 0x61, 0x89, 0xdc, 0x13, 0x9a, 0xdc, 0x9d, 0x89, 0x0a, - 0xa5, 0x4a, 0xa4, 0x3e, 0x28, 0xac, 0xe5, 0xc9, 0x78, 0x2f, 0xc4, 0x3e, 0x43, 0xaf, 0x4a, 0x1b, - 0xfd, 0xe5, 0xa5, 0xf9, 0x4f, 0x8d, 0xa6, 0xbf, 0x2d, 0xe8, 0x46, 0xd5, 0xc7, 0xf4, 0x1e, 0xcc, - 0xad, 0xd8, 0xa1, 0x65, 0xd8, 0x86, 0x33, 0x9a, 0x8d, 0xdd, 0xff, 0x1b, 0xdc, 0xda, 0x71, 0x9f, - 0xc5, 0x0e, 0xc3, 0x4a, 0xa3, 0xb7, 0xd0, 0x2f, 0x50, 0x0a, 0x5d, 0x6c, 0x51, 0x5a, 0x6d, 0xdb, - 0x70, 0xfa, 0x61, 0xf3, 0x40, 0xaf, 0xa1, 0x93, 0x0b, 0x85, 0xd2, 0x32, 0x2b, 0x52, 0x07, 0x3a, - 0x87, 0xab, 0x2c, 0x95, 0x2a, 0x69, 0x1a, 0x26, 0x85, 0xce, 0xad, 0x8e, 0x6d, 0x38, 0x83, 0xd9, - 0xcd, 0xf9, 0xc6, 0x18, 0xa5, 0x8a, 0x4a, 0x25, 0x24, 0xe5, 0x4c, 0x13, 0x75, 0x3e, 0x7d, 0x07, - 0xb3, 0x6c, 0x42, 0x07, 0xd0, 0x5b, 0x07, 0xaf, 0xc1, 0xf2, 0x2d, 0x20, 0x17, 0x74, 0x08, 0x97, - 0x8c, 0xaf, 0xfc, 0xe5, 0x07, 0x67, 0xc4, 0x28, 0x11, 0xe3, 0x3e, 0x8f, 0x39, 0x23, 0x2d, 0x3a, - 0x02, 0x88, 0xd6, 0x2b, 0x1e, 0x46, 0x9c, 0x71, 0x46, 0xda, 0x14, 0xa0, 0x3b, 0x7f, 0x5c, 0xf8, - 0x9c, 0x11, 0xb3, 0x1e, 0xf3, 0x79, 0xbc, 0x08, 0x5e, 0x48, 0xe7, 0xa9, 0xff, 0xd9, 0x3b, 0x15, - 0xd8, 0x74, 0xab, 0x0b, 0x3d, 0xfc, 0x05, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x11, 0x21, 0x30, 0x86, - 0x01, 0x00, 0x00, + // 333 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0xd1, 0x6e, 0xa2, 0x40, + 0x14, 0x86, 0x17, 0x45, 0xd4, 0xa3, 0x71, 0x27, 0xa3, 0xc9, 0xa2, 0xd9, 0x4d, 0x8c, 0x57, 0xde, + 0x2c, 0x24, 0xf6, 0x09, 0xd0, 0x19, 0x0d, 0x71, 0x82, 0x04, 0x30, 0x4d, 0x7b, 0x43, 0x50, 0xa7, + 0xd6, 0xc4, 0x30, 0x86, 0x19, 0x2e, 0xfa, 0x26, 0x7d, 0xaa, 0x3e, 0x53, 0x03, 0xd8, 0xa8, 0x97, + 0xff, 0xff, 0x7d, 0x87, 0x73, 0x18, 0x18, 0xbe, 0x27, 0x97, 0x93, 0x9d, 0xf1, 0x33, 0x4f, 0x24, + 0xb7, 0xa5, 0x4a, 0x54, 0x2e, 0xad, 0x4b, 0x26, 0x94, 0xc0, 0xdd, 0x02, 0x59, 0x57, 0x34, 0xfa, + 0xf7, 0x20, 0x2a, 0x2e, 0x55, 0x2c, 0xf3, 0x93, 0xe2, 0x95, 0x3c, 0x1a, 0x1e, 0x85, 0x38, 0x9e, + 0xb9, 0x5d, 0xa6, 0x5d, 0xfe, 0x66, 0x27, 0xe9, 0x47, 0x85, 0x26, 0x5f, 0x35, 0x30, 0xc2, 0xf2, + 0xc3, 0xf8, 0x3f, 0xe8, 0x7b, 0x71, 0xe0, 0xa6, 0x36, 0xd6, 0xa6, 0xbd, 0xd9, 0xd0, 0xba, 0xdf, + 0x60, 0x55, 0x8e, 0xb5, 0x10, 0x07, 0x1e, 0x94, 0x1a, 0xfe, 0x0b, 0xed, 0x8c, 0x4b, 0x91, 0x67, + 0x7b, 0x2e, 0xcd, 0xfa, 0x58, 0x9b, 0xb6, 0x83, 0x5b, 0x81, 0x07, 0xd0, 0x48, 0x85, 0xe2, 0xd2, + 0xd4, 0x4b, 0x52, 0x05, 0xbc, 0x84, 0xfe, 0x39, 0x91, 0x2a, 0xbe, 0x5d, 0x18, 0x67, 0x79, 0x6a, + 0x36, 0xc6, 0xda, 0xb4, 0x33, 0xfb, 0xf3, 0xb8, 0x31, 0xe2, 0x52, 0x85, 0x85, 0x12, 0xa0, 0x62, + 0xe6, 0x16, 0xf3, 0x74, 0xf2, 0xa9, 0x81, 0x5e, 0x9c, 0x82, 0x3b, 0xd0, 0xdc, 0x7a, 0x6b, 0x6f, + 0xf3, 0xec, 0xa1, 0x5f, 0xb8, 0x0b, 0x2d, 0x42, 0x7d, 0xb6, 0x79, 0xa1, 0x04, 0x69, 0x05, 0x22, + 0x94, 0xd1, 0x88, 0x12, 0x54, 0xc3, 0x3d, 0x80, 0x70, 0xeb, 0xd3, 0x20, 0xa4, 0x84, 0x12, 0x54, + 0xc7, 0x00, 0xc6, 0xd2, 0x71, 0x19, 0x25, 0x48, 0xaf, 0xc6, 0x18, 0x8d, 0x5c, 0x6f, 0x85, 0x1a, + 0xb8, 0x0f, 0xbf, 0x7d, 0xea, 0x11, 0xd7, 0x5b, 0xc5, 0xae, 0x17, 0x46, 0x0e, 0x63, 0xc8, 0xb8, + 0x2f, 0xb7, 0xfe, 0x2a, 0x70, 0x08, 0x45, 0x4d, 0x3c, 0x00, 0xf4, 0x53, 0x06, 0x1b, 0xc6, 0xe6, + 0xce, 0x62, 0x8d, 0x5a, 0xf3, 0xf6, 0x6b, 0xf3, 0xfa, 0x07, 0x3b, 0xa3, 0x7c, 0xe2, 0xa7, 0xef, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x09, 0x48, 0x18, 0xba, 0xc7, 0x01, 0x00, 0x00, } diff --git a/vendor/k8s.io/helm/pkg/proto/hapi/release/test_run.pb.go b/vendor/k8s.io/helm/pkg/proto/hapi/release/test_run.pb.go index bd3c0ab2..4d39d17c 100644 --- a/vendor/k8s.io/helm/pkg/proto/hapi/release/test_run.pb.go +++ b/vendor/k8s.io/helm/pkg/proto/hapi/release/test_run.pb.go @@ -1,6 +1,5 @@ -// Code generated by protoc-gen-go. +// Code generated by protoc-gen-go. DO NOT EDIT. // source: hapi/release/test_run.proto -// DO NOT EDIT! package release diff --git a/vendor/k8s.io/helm/pkg/proto/hapi/release/test_suite.pb.go b/vendor/k8s.io/helm/pkg/proto/hapi/release/test_suite.pb.go index f168bf1d..b7fa2614 100644 --- a/vendor/k8s.io/helm/pkg/proto/hapi/release/test_suite.pb.go +++ b/vendor/k8s.io/helm/pkg/proto/hapi/release/test_suite.pb.go @@ -1,6 +1,5 @@ -// Code generated by protoc-gen-go. +// Code generated by protoc-gen-go. DO NOT EDIT. // source: hapi/release/test_suite.proto -// DO NOT EDIT! package release diff --git a/vendor/k8s.io/helm/pkg/proto/hapi/rudder/rudder.pb.go b/vendor/k8s.io/helm/pkg/proto/hapi/rudder/rudder.pb.go index 3f64ba71..6e26d71e 100644 --- a/vendor/k8s.io/helm/pkg/proto/hapi/rudder/rudder.pb.go +++ b/vendor/k8s.io/helm/pkg/proto/hapi/rudder/rudder.pb.go @@ -1,6 +1,5 @@ -// Code generated by protoc-gen-go. +// Code generated by protoc-gen-go. DO NOT EDIT. // source: hapi/rudder/rudder.proto -// DO NOT EDIT! /* Package rudder is a generated protocol buffer package. diff --git a/vendor/k8s.io/helm/pkg/proto/hapi/services/tiller.pb.go b/vendor/k8s.io/helm/pkg/proto/hapi/services/tiller.pb.go index d629320c..023749c4 100644 --- a/vendor/k8s.io/helm/pkg/proto/hapi/services/tiller.pb.go +++ b/vendor/k8s.io/helm/pkg/proto/hapi/services/tiller.pb.go @@ -1,6 +1,5 @@ -// Code generated by protoc-gen-go. +// Code generated by protoc-gen-go. DO NOT EDIT. // source: hapi/services/tiller.proto -// DO NOT EDIT! /* Package services is a generated protocol buffer package. diff --git a/vendor/k8s.io/helm/pkg/proto/hapi/version/version.pb.go b/vendor/k8s.io/helm/pkg/proto/hapi/version/version.pb.go index e3d8a709..13c8568f 100644 --- a/vendor/k8s.io/helm/pkg/proto/hapi/version/version.pb.go +++ b/vendor/k8s.io/helm/pkg/proto/hapi/version/version.pb.go @@ -1,6 +1,5 @@ -// Code generated by protoc-gen-go. +// Code generated by protoc-gen-go. DO NOT EDIT. // source: hapi/version/version.proto -// DO NOT EDIT! /* Package version is a generated protocol buffer package. diff --git a/vendor/k8s.io/helm/pkg/repo/chartrepo.go b/vendor/k8s.io/helm/pkg/repo/chartrepo.go index 9c833654..97506e60 100644 --- a/vendor/k8s.io/helm/pkg/repo/chartrepo.go +++ b/vendor/k8s.io/helm/pkg/repo/chartrepo.go @@ -60,7 +60,7 @@ func NewChartRepository(cfg *Entry, getters getter.Providers) (*ChartRepository, if err != nil { return nil, fmt.Errorf("Could not find protocol handler for: %s", u.Scheme) } - client, _ := getterConstructor(cfg.URL, cfg.CertFile, cfg.KeyFile, cfg.CAFile) + client, err := getterConstructor(cfg.URL, cfg.CertFile, cfg.KeyFile, cfg.CAFile) if err != nil { return nil, fmt.Errorf("Could not construct protocol handler for: %s", u.Scheme) } diff --git a/vendor/k8s.io/helm/pkg/storage/driver/driver.go b/vendor/k8s.io/helm/pkg/storage/driver/driver.go index 87bab8a2..e01d35d6 100644 --- a/vendor/k8s.io/helm/pkg/storage/driver/driver.go +++ b/vendor/k8s.io/helm/pkg/storage/driver/driver.go @@ -69,9 +69,9 @@ type Queryor interface { Query(labels map[string]string) ([]*rspb.Release, error) } -// Driver is the interface composed of Creator, Updator, Deletor, Queryor +// Driver is the interface composed of Creator, Updator, Deletor, and Queryor // interfaces. It defines the behavior for storing, updating, deleted, -// and retrieving tiller releases from some underlying storage mechanism, +// and retrieving Tiller releases from some underlying storage mechanism, // e.g. memory, configmaps. type Driver interface { Creator diff --git a/vendor/k8s.io/helm/pkg/strvals/parser.go b/vendor/k8s.io/helm/pkg/strvals/parser.go index 842f36c2..8e97b4d4 100644 --- a/vendor/k8s.io/helm/pkg/strvals/parser.go +++ b/vendor/k8s.io/helm/pkg/strvals/parser.go @@ -308,8 +308,11 @@ func typedVal(v []rune) interface{} { return false } - if iv, err := strconv.ParseInt(val, 10, 64); err == nil { - return iv + // If this value does not start with zero, try parsing it to an int + if len(val) != 0 && val[0] != '0' { + if iv, err := strconv.ParseInt(val, 10, 64); err == nil { + return iv + } } return val diff --git a/vendor/k8s.io/helm/pkg/strvals/parser_test.go b/vendor/k8s.io/helm/pkg/strvals/parser_test.go index 061de0a1..a3f6e420 100644 --- a/vendor/k8s.io/helm/pkg/strvals/parser_test.go +++ b/vendor/k8s.io/helm/pkg/strvals/parser_test.go @@ -93,6 +93,10 @@ func TestParseSet(t *testing.T) { str: "name1=,name2=value2", expect: map[string]interface{}{"name1": "", "name2": "value2"}, }, + { + str: "leading_zeros=00009", + expect: map[string]interface{}{"leading_zeros": "00009"}, + }, { str: "name1,name2=", err: true, diff --git a/vendor/k8s.io/helm/pkg/tiller/environment/environment.go b/vendor/k8s.io/helm/pkg/tiller/environment/environment.go index f5238d22..b4c6b2b6 100644 --- a/vendor/k8s.io/helm/pkg/tiller/environment/environment.go +++ b/vendor/k8s.io/helm/pkg/tiller/environment/environment.go @@ -129,9 +129,9 @@ type KubeClient interface { WatchUntilReady(namespace string, reader io.Reader, timeout int64, shouldWait bool) error // Update updates one or more resources or creates the resource - // if it doesn't exist + // if it doesn't exist. // - // namespace must contain a valid existing namespace + // namespace must contain a valid existing namespace. // // reader must contain a YAML stream (one or more YAML documents separated // by "\n---\n"). @@ -141,7 +141,7 @@ type KubeClient interface { BuildUnstructured(namespace string, reader io.Reader) (kube.Result, error) // WaitAndGetCompletedPodPhase waits up to a timeout until a pod enters a completed phase - // and returns said phase (PodSucceeded or PodFailed qualify) + // and returns said phase (PodSucceeded or PodFailed qualify). WaitAndGetCompletedPodPhase(namespace string, reader io.Reader, timeout time.Duration) (api.PodPhase, error) } @@ -193,7 +193,7 @@ func (p *PrintingKubeClient) BuildUnstructured(ns string, reader io.Reader) (kub return []*resource.Info{}, nil } -// WaitAndGetCompletedPodPhase implements KubeClient WaitAndGetCompletedPodPhase +// WaitAndGetCompletedPodPhase implements KubeClient WaitAndGetCompletedPodPhase. func (p *PrintingKubeClient) WaitAndGetCompletedPodPhase(namespace string, reader io.Reader, timeout time.Duration) (api.PodPhase, error) { _, err := io.Copy(p.Out, reader) return api.PodUnknown, err diff --git a/vendor/k8s.io/helm/pkg/tiller/hooks_test.go b/vendor/k8s.io/helm/pkg/tiller/hooks_test.go index eabdc7ea..7a7d2a2b 100644 --- a/vendor/k8s.io/helm/pkg/tiller/hooks_test.go +++ b/vendor/k8s.io/helm/pkg/tiller/hooks_test.go @@ -197,17 +197,18 @@ metadata: sorted := []manifest{} for _, s := range data { manifests := util.SplitManifests(s.manifest) - mCount := 0 - for _, m := range manifests { - name := s.name[mCount] + for _, m := range manifests { var sh util.SimpleHead err := yaml.Unmarshal([]byte(m), &sh) if err != nil { // This is expected for manifests that are corrupt or empty. t.Log(err) + continue } + name := sh.Metadata.Name + //only keep track of non-hook manifests if err == nil && s.hooks[name] == nil { another := manifest{ @@ -217,8 +218,6 @@ metadata: } sorted = append(sorted, another) } - - mCount++ } } diff --git a/vendor/k8s.io/helm/pkg/tiller/kind_sorter.go b/vendor/k8s.io/helm/pkg/tiller/kind_sorter.go index f08d1356..e0549e2f 100644 --- a/vendor/k8s.io/helm/pkg/tiller/kind_sorter.go +++ b/vendor/k8s.io/helm/pkg/tiller/kind_sorter.go @@ -49,12 +49,14 @@ var InstallOrder SortOrder = []string{ "Job", "CronJob", "Ingress", + "APIService", } // UninstallOrder is the order in which manifests should be uninstalled (by Kind). // // Those occurring earlier in the list get uninstalled before those occurring later in the list. var UninstallOrder SortOrder = []string{ + "APIService", "Ingress", "Service", "CronJob", @@ -112,14 +114,19 @@ func (k *kindSorter) Swap(i, j int) { k.manifests[i], k.manifests[j] = k.manifes func (k *kindSorter) Less(i, j int) bool { a := k.manifests[i] b := k.manifests[j] - first, ok := k.ordering[a.head.Kind] - if !ok { - // Unknown is always last + first, aok := k.ordering[a.head.Kind] + second, bok := k.ordering[b.head.Kind] + if first == second { + // same kind (including unknown) so sub sort alphanumeric + return a.name < b.name + } + // unknown kind is last + if !aok { return false } - second, ok := k.ordering[b.head.Kind] - if !ok { + if !bok { return true } + // sort different kinds return first < second } diff --git a/vendor/k8s.io/helm/pkg/tiller/kind_sorter_test.go b/vendor/k8s.io/helm/pkg/tiller/kind_sorter_test.go index 4fe4b09e..a707176b 100644 --- a/vendor/k8s.io/helm/pkg/tiller/kind_sorter_test.go +++ b/vendor/k8s.io/helm/pkg/tiller/kind_sorter_test.go @@ -26,119 +26,101 @@ import ( func TestKindSorter(t *testing.T) { manifests := []manifest{ { - name: "i", - content: "", - head: &util.SimpleHead{Kind: "ClusterRole"}, + name: "i", + head: &util.SimpleHead{Kind: "ClusterRole"}, }, { - name: "j", - content: "", - head: &util.SimpleHead{Kind: "ClusterRoleBinding"}, + name: "j", + head: &util.SimpleHead{Kind: "ClusterRoleBinding"}, }, { - name: "e", - content: "", - head: &util.SimpleHead{Kind: "ConfigMap"}, + name: "e", + head: &util.SimpleHead{Kind: "ConfigMap"}, }, { - name: "u", - content: "", - head: &util.SimpleHead{Kind: "CronJob"}, + name: "u", + head: &util.SimpleHead{Kind: "CronJob"}, }, { - name: "n", - content: "", - head: &util.SimpleHead{Kind: "DaemonSet"}, + name: "n", + head: &util.SimpleHead{Kind: "DaemonSet"}, }, { - name: "r", - content: "", - head: &util.SimpleHead{Kind: "Deployment"}, + name: "r", + head: &util.SimpleHead{Kind: "Deployment"}, }, { - name: "!", - content: "", - head: &util.SimpleHead{Kind: "HonkyTonkSet"}, + name: "!", + head: &util.SimpleHead{Kind: "HonkyTonkSet"}, }, { - name: "v", - content: "", - head: &util.SimpleHead{Kind: "Ingress"}, + name: "v", + head: &util.SimpleHead{Kind: "Ingress"}, }, { - name: "t", - content: "", - head: &util.SimpleHead{Kind: "Job"}, + name: "t", + head: &util.SimpleHead{Kind: "Job"}, }, { - name: "c", - content: "", - head: &util.SimpleHead{Kind: "LimitRange"}, + name: "c", + head: &util.SimpleHead{Kind: "LimitRange"}, }, { - name: "a", - content: "", - head: &util.SimpleHead{Kind: "Namespace"}, + name: "a", + head: &util.SimpleHead{Kind: "Namespace"}, }, { - name: "f", - content: "", - head: &util.SimpleHead{Kind: "PersistentVolume"}, + name: "f", + head: &util.SimpleHead{Kind: "PersistentVolume"}, }, { - name: "g", - content: "", - head: &util.SimpleHead{Kind: "PersistentVolumeClaim"}, + name: "g", + head: &util.SimpleHead{Kind: "PersistentVolumeClaim"}, }, { - name: "o", - content: "", - head: &util.SimpleHead{Kind: "Pod"}, + name: "o", + head: &util.SimpleHead{Kind: "Pod"}, }, { - name: "q", - content: "", - head: &util.SimpleHead{Kind: "ReplicaSet"}, + name: "q", + head: &util.SimpleHead{Kind: "ReplicaSet"}, }, { - name: "p", - content: "", - head: &util.SimpleHead{Kind: "ReplicationController"}, + name: "p", + head: &util.SimpleHead{Kind: "ReplicationController"}, }, { - name: "b", - content: "", - head: &util.SimpleHead{Kind: "ResourceQuota"}, + name: "b", + head: &util.SimpleHead{Kind: "ResourceQuota"}, }, { - name: "k", - content: "", - head: &util.SimpleHead{Kind: "Role"}, + name: "k", + head: &util.SimpleHead{Kind: "Role"}, }, { - name: "l", - content: "", - head: &util.SimpleHead{Kind: "RoleBinding"}, + name: "l", + head: &util.SimpleHead{Kind: "RoleBinding"}, }, { - name: "d", - content: "", - head: &util.SimpleHead{Kind: "Secret"}, + name: "d", + head: &util.SimpleHead{Kind: "Secret"}, }, { - name: "m", - content: "", - head: &util.SimpleHead{Kind: "Service"}, + name: "m", + head: &util.SimpleHead{Kind: "Service"}, }, { - name: "h", - content: "", - head: &util.SimpleHead{Kind: "ServiceAccount"}, + name: "h", + head: &util.SimpleHead{Kind: "ServiceAccount"}, }, { - name: "s", + name: "s", + head: &util.SimpleHead{Kind: "StatefulSet"}, + }, + { + name: "w", content: "", - head: &util.SimpleHead{Kind: "StatefulSet"}, + head: &util.SimpleHead{Kind: "APIService"}, }, } @@ -147,8 +129,8 @@ func TestKindSorter(t *testing.T) { order SortOrder expected string }{ - {"install", InstallOrder, "abcdefghijklmnopqrstuv!"}, - {"uninstall", UninstallOrder, "vmutsrqponlkjihgfedcba!"}, + {"install", InstallOrder, "abcdefghijklmnopqrstuvw!"}, + {"uninstall", UninstallOrder, "wvmutsrqponlkjihgfedcba!"}, } { var buf bytes.Buffer t.Run(test.description, func(t *testing.T) { @@ -165,3 +147,64 @@ func TestKindSorter(t *testing.T) { }) } } + +// TestKindSorterSubSort verifies manifests of same kind are also sorted alphanumeric +func TestKindSorterSubSort(t *testing.T) { + manifests := []manifest{ + { + name: "a", + head: &util.SimpleHead{Kind: "ClusterRole"}, + }, + { + name: "A", + head: &util.SimpleHead{Kind: "ClusterRole"}, + }, + { + name: "0", + head: &util.SimpleHead{Kind: "ConfigMap"}, + }, + { + name: "1", + head: &util.SimpleHead{Kind: "ConfigMap"}, + }, + { + name: "z", + head: &util.SimpleHead{Kind: "ClusterRoleBinding"}, + }, + { + name: "!", + head: &util.SimpleHead{Kind: "ClusterRoleBinding"}, + }, + { + name: "u3", + head: &util.SimpleHead{Kind: "Unknown"}, + }, + { + name: "u1", + head: &util.SimpleHead{Kind: "Unknown"}, + }, + { + name: "u2", + head: &util.SimpleHead{Kind: "Unknown"}, + }, + } + for _, test := range []struct { + description string + order SortOrder + expected string + }{ + // expectation is sorted by kind (unknown is last) and then sub sorted alphabetically within each group + {"cm,clusterRole,clusterRoleBinding,Unknown", InstallOrder, "01Aa!zu1u2u3"}, + } { + var buf bytes.Buffer + t.Run(test.description, func(t *testing.T) { + defer buf.Reset() + for _, r := range sortByKind(manifests, test.order) { + buf.WriteString(r.name) + } + if got := buf.String(); got != test.expected { + t.Errorf("Expected %q, got %q", test.expected, got) + } + }) + } +} diff --git a/vendor/k8s.io/helm/pkg/tiller/release_content.go b/vendor/k8s.io/helm/pkg/tiller/release_content.go index e9f6f05c..fd783d6b 100644 --- a/vendor/k8s.io/helm/pkg/tiller/release_content.go +++ b/vendor/k8s.io/helm/pkg/tiller/release_content.go @@ -24,8 +24,9 @@ import ( // GetReleaseContent gets all of the stored information for the given release. func (s *ReleaseServer) GetReleaseContent(c ctx.Context, req *services.GetReleaseContentRequest) (*services.GetReleaseContentResponse, error) { - if !ValidName.MatchString(req.Name) { - return nil, errMissingRelease + if err := validateReleaseName(req.Name); err != nil { + s.Log("releaseContent: Release name is invalid: %s", req.Name) + return nil, err } if req.Version <= 0 { diff --git a/vendor/k8s.io/helm/pkg/tiller/release_history.go b/vendor/k8s.io/helm/pkg/tiller/release_history.go index 09131fad..0dd52597 100644 --- a/vendor/k8s.io/helm/pkg/tiller/release_history.go +++ b/vendor/k8s.io/helm/pkg/tiller/release_history.go @@ -25,6 +25,11 @@ import ( // GetHistory gets the history for a given release. func (s *ReleaseServer) GetHistory(ctx context.Context, req *tpb.GetHistoryRequest) (*tpb.GetHistoryResponse, error) { + if err := validateReleaseName(req.Name); err != nil { + s.Log("getHistory: Release name is invalid: %s", req.Name) + return nil, err + } + s.Log("getting history for release %s", req.Name) h, err := s.env.Releases.History(req.Name) if err != nil { diff --git a/vendor/k8s.io/helm/pkg/tiller/release_install.go b/vendor/k8s.io/helm/pkg/tiller/release_install.go index 97921884..8e7fd3ac 100644 --- a/vendor/k8s.io/helm/pkg/tiller/release_install.go +++ b/vendor/k8s.io/helm/pkg/tiller/release_install.go @@ -116,7 +116,7 @@ func (s *ReleaseServer) prepareRelease(req *services.InstallReleaseRequest) (*re Info: &release.Info{ FirstDeployed: ts, LastDeployed: ts, - Status: &release.Status{Code: release.Status_UNKNOWN}, + Status: &release.Status{Code: release.Status_PENDING_INSTALL}, Description: "Initial install underway", // Will be overwritten. }, Manifest: manifestDoc.String(), @@ -172,6 +172,7 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install Recreate: false, Timeout: req.Timeout, } + s.recordRelease(r, false) if err := s.ReleaseModule.Update(old, r, updateReq, s.env); err != nil { msg := fmt.Sprintf("Release replace %q failed: %s", r.Name, err) s.Log("warning: %s", msg) @@ -179,19 +180,20 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install r.Info.Status.Code = release.Status_FAILED r.Info.Description = msg s.recordRelease(old, true) - s.recordRelease(r, false) + s.recordRelease(r, true) return res, err } default: // nothing to replace, create as normal // regular manifests + s.recordRelease(r, false) if err := s.ReleaseModule.Create(r, req, s.env); err != nil { msg := fmt.Sprintf("Release %q failed: %s", r.Name, err) s.Log("warning: %s", msg) r.Info.Status.Code = release.Status_FAILED r.Info.Description = msg - s.recordRelease(r, false) + s.recordRelease(r, true) return res, fmt.Errorf("release %s failed: %s", r.Name, err) } } @@ -203,7 +205,7 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install s.Log("warning: %s", msg) r.Info.Status.Code = release.Status_FAILED r.Info.Description = msg - s.recordRelease(r, false) + s.recordRelease(r, true) return res, err } } @@ -217,7 +219,7 @@ func (s *ReleaseServer) performRelease(r *release.Release, req *services.Install // // One possible strategy would be to do a timed retry to see if we can get // this stored in the future. - s.recordRelease(r, false) + s.recordRelease(r, true) return res, nil } diff --git a/vendor/k8s.io/helm/pkg/tiller/release_modules.go b/vendor/k8s.io/helm/pkg/tiller/release_modules.go index 2f2a3c6f..73b95e60 100644 --- a/vendor/k8s.io/helm/pkg/tiller/release_modules.go +++ b/vendor/k8s.io/helm/pkg/tiller/release_modules.go @@ -124,6 +124,9 @@ func (m *RemoteReleaseModule) Rollback(current, target *release.Release, req *se func (m *RemoteReleaseModule) Status(r *release.Release, req *services.GetReleaseStatusRequest, env *environment.Environment) (string, error) { statusRequest := &rudderAPI.ReleaseStatusRequest{Release: r} resp, err := rudder.ReleaseStatus(statusRequest) + if resp == nil { + return "", err + } return resp.Info.Status.Resources, err } @@ -131,10 +134,17 @@ func (m *RemoteReleaseModule) Status(r *release.Release, req *services.GetReleas func (m *RemoteReleaseModule) Delete(r *release.Release, req *services.UninstallReleaseRequest, env *environment.Environment) (string, []error) { deleteRequest := &rudderAPI.DeleteReleaseRequest{Release: r} resp, err := rudder.DeleteRelease(deleteRequest) + + errs := make([]error, 0) + result := "" + if err != nil { - return resp.Release.Manifest, []error{err} + errs = append(errs, err) } - return resp.Release.Manifest, []error{} + if resp != nil { + result = resp.Release.Manifest + } + return result, errs } // DeleteRelease is a helper that allows Rudder to delete a release without exposing most of Tiller inner functions diff --git a/vendor/k8s.io/helm/pkg/tiller/release_rollback.go b/vendor/k8s.io/helm/pkg/tiller/release_rollback.go index 7cb117fd..e8b6435b 100644 --- a/vendor/k8s.io/helm/pkg/tiller/release_rollback.go +++ b/vendor/k8s.io/helm/pkg/tiller/release_rollback.go @@ -35,6 +35,12 @@ func (s *ReleaseServer) RollbackRelease(c ctx.Context, req *services.RollbackRel return nil, err } + if !req.DryRun { + s.Log("creating rolled back release for %s", req.Name) + if err := s.env.Releases.Create(targetRelease); err != nil { + return nil, err + } + } s.Log("performing rollback of %s", req.Name) res, err := s.performRollback(currentRelease, targetRelease, req) if err != nil { @@ -42,8 +48,8 @@ func (s *ReleaseServer) RollbackRelease(c ctx.Context, req *services.RollbackRel } if !req.DryRun { - s.Log("creating rolled back release %s", req.Name) - if err := s.env.Releases.Create(targetRelease); err != nil { + s.Log("updating status for rolled back release for %s", req.Name) + if err := s.env.Releases.Update(targetRelease); err != nil { return res, err } } @@ -54,10 +60,12 @@ func (s *ReleaseServer) RollbackRelease(c ctx.Context, req *services.RollbackRel // prepareRollback finds the previous release and prepares a new release object with // the previous release's configuration func (s *ReleaseServer) prepareRollback(req *services.RollbackReleaseRequest) (*release.Release, *release.Release, error) { - switch { - case !ValidName.MatchString(req.Name): - return nil, nil, errMissingRelease - case req.Version < 0: + if err := validateReleaseName(req.Name); err != nil { + s.Log("prepareRollback: Release name is invalid: %s", req.Name) + return nil, nil, err + } + + if req.Version < 0 { return nil, nil, errInvalidRevision } @@ -88,7 +96,7 @@ func (s *ReleaseServer) prepareRollback(req *services.RollbackReleaseRequest) (* FirstDeployed: crls.Info.FirstDeployed, LastDeployed: timeconv.Now(), Status: &release.Status{ - Code: release.Status_UNKNOWN, + Code: release.Status_PENDING_ROLLBACK, Notes: prls.Info.Status.Notes, }, // Because we lose the reference to rbv elsewhere, we set the diff --git a/vendor/k8s.io/helm/pkg/tiller/release_server.go b/vendor/k8s.io/helm/pkg/tiller/release_server.go index 07ea872d..db7c0b56 100644 --- a/vendor/k8s.io/helm/pkg/tiller/release_server.go +++ b/vendor/k8s.io/helm/pkg/tiller/release_server.go @@ -59,6 +59,8 @@ var ( errMissingRelease = errors.New("no release provided") // errInvalidRevision indicates that an invalid release revision number was provided. errInvalidRevision = errors.New("invalid release revision") + //errInvalidName indicates that an invalid release name was provided + errInvalidName = errors.New("invalid release name, must match regex ^(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])+$ and the length must not longer than 53") ) // ListDefaultLimit is the default limit for number of items returned in a list. @@ -359,3 +361,15 @@ func validateManifest(c environment.KubeClient, ns string, manifest []byte) erro _, err := c.BuildUnstructured(ns, r) return err } + +func validateReleaseName(releaseName string) error { + if releaseName == "" { + return errMissingRelease + } + + if !ValidName.MatchString(releaseName) || (len(releaseName) > releaseNameMaxLen) { + return errInvalidName + } + + return nil +} diff --git a/vendor/k8s.io/helm/pkg/tiller/release_server_test.go b/vendor/k8s.io/helm/pkg/tiller/release_server_test.go index 8425a58f..b7b14a4f 100644 --- a/vendor/k8s.io/helm/pkg/tiller/release_server_test.go +++ b/vendor/k8s.io/helm/pkg/tiller/release_server_test.go @@ -183,22 +183,23 @@ func upgradeReleaseVersion(rel *release.Release) *release.Release { } func TestValidName(t *testing.T) { - for name, valid := range map[string]bool{ - "nina pinta santa-maria": false, - "nina-pinta-santa-maria": true, - "-nina": false, - "pinta-": false, - "santa-maria": true, - "niña": false, - "...": false, - "pinta...": false, - "santa...maria": true, - "": false, - " ": false, - ".nina.": false, - "nina.pinta": true, + for name, valid := range map[string]error{ + "nina pinta santa-maria": errInvalidName, + "nina-pinta-santa-maria": nil, + "-nina": errInvalidName, + "pinta-": errInvalidName, + "santa-maria": nil, + "niña": errInvalidName, + "...": errInvalidName, + "pinta...": errInvalidName, + "santa...maria": nil, + "": errMissingRelease, + " ": errInvalidName, + ".nina.": errInvalidName, + "nina.pinta": nil, + "abcdefghi-abcdefghi-abcdefghi-abcdefghi-abcdefghi-abcd": errInvalidName, } { - if valid != ValidName.MatchString(name) { + if valid != validateReleaseName(name) { t.Errorf("Expected %q to be %t", name, valid) } } diff --git a/vendor/k8s.io/helm/pkg/tiller/release_status.go b/vendor/k8s.io/helm/pkg/tiller/release_status.go index b39bdab9..e0d75877 100644 --- a/vendor/k8s.io/helm/pkg/tiller/release_status.go +++ b/vendor/k8s.io/helm/pkg/tiller/release_status.go @@ -28,8 +28,9 @@ import ( // GetReleaseStatus gets the status information for a named release. func (s *ReleaseServer) GetReleaseStatus(c ctx.Context, req *services.GetReleaseStatusRequest) (*services.GetReleaseStatusResponse, error) { - if !ValidName.MatchString(req.Name) { - return nil, errMissingRelease + if err := validateReleaseName(req.Name); err != nil { + s.Log("getStatus: Release name is invalid: %s", req.Name) + return nil, err } var rel *release.Release diff --git a/vendor/k8s.io/helm/pkg/tiller/release_testing.go b/vendor/k8s.io/helm/pkg/tiller/release_testing.go index 4f9a38a9..a44b67e6 100644 --- a/vendor/k8s.io/helm/pkg/tiller/release_testing.go +++ b/vendor/k8s.io/helm/pkg/tiller/release_testing.go @@ -25,8 +25,9 @@ import ( // RunReleaseTest runs pre-defined tests stored as hooks on a given release func (s *ReleaseServer) RunReleaseTest(req *services.TestReleaseRequest, stream services.ReleaseService_RunReleaseTestServer) error { - if !ValidName.MatchString(req.Name) { - return errMissingRelease + if err := validateReleaseName(req.Name); err != nil { + s.Log("releaseTest: Release name is invalid: %s", req.Name) + return err } // finds the non-deleted release with the given name diff --git a/vendor/k8s.io/helm/pkg/tiller/release_uninstall.go b/vendor/k8s.io/helm/pkg/tiller/release_uninstall.go index 704901eb..423b6e7e 100644 --- a/vendor/k8s.io/helm/pkg/tiller/release_uninstall.go +++ b/vendor/k8s.io/helm/pkg/tiller/release_uninstall.go @@ -31,13 +31,9 @@ import ( // UninstallRelease deletes all of the resources associated with this release, and marks the release DELETED. func (s *ReleaseServer) UninstallRelease(c ctx.Context, req *services.UninstallReleaseRequest) (*services.UninstallReleaseResponse, error) { - if !ValidName.MatchString(req.Name) { - s.Log("uninstall: Release not found: %s", req.Name) - return nil, errMissingRelease - } - - if len(req.Name) > releaseNameMaxLen { - return nil, fmt.Errorf("release name %q exceeds max length of %d", req.Name, releaseNameMaxLen) + if err := validateReleaseName(req.Name); err != nil { + s.Log("uninstallRelease: Release name is invalid: %s", req.Name) + return nil, err } rels, err := s.env.Releases.History(req.Name) diff --git a/vendor/k8s.io/helm/pkg/tiller/release_update.go b/vendor/k8s.io/helm/pkg/tiller/release_update.go index c0b55f99..58a8a18c 100644 --- a/vendor/k8s.io/helm/pkg/tiller/release_update.go +++ b/vendor/k8s.io/helm/pkg/tiller/release_update.go @@ -30,12 +30,23 @@ import ( // UpdateRelease takes an existing release and new information, and upgrades the release. func (s *ReleaseServer) UpdateRelease(c ctx.Context, req *services.UpdateReleaseRequest) (*services.UpdateReleaseResponse, error) { + if err := validateReleaseName(req.Name); err != nil { + s.Log("updateRelease: Release name is invalid: %s", req.Name) + return nil, err + } s.Log("preparing update for %s", req.Name) currentRelease, updatedRelease, err := s.prepareUpdate(req) if err != nil { return nil, err } + if !req.DryRun { + s.Log("creating updated release for %s", req.Name) + if err := s.env.Releases.Create(updatedRelease); err != nil { + return nil, err + } + } + s.Log("performing update for %s", req.Name) res, err := s.performUpdate(currentRelease, updatedRelease, req) if err != nil { @@ -43,8 +54,8 @@ func (s *ReleaseServer) UpdateRelease(c ctx.Context, req *services.UpdateRelease } if !req.DryRun { - s.Log("creating updated release for %s", req.Name) - if err := s.env.Releases.Create(updatedRelease); err != nil { + s.Log("updating status for updated release for %s", req.Name) + if err := s.env.Releases.Update(updatedRelease); err != nil { return res, err } } @@ -54,10 +65,6 @@ func (s *ReleaseServer) UpdateRelease(c ctx.Context, req *services.UpdateRelease // prepareUpdate builds an updated release for an update operation. func (s *ReleaseServer) prepareUpdate(req *services.UpdateReleaseRequest) (*release.Release, *release.Release, error) { - if !ValidName.MatchString(req.Name) { - return nil, nil, errMissingRelease - } - if req.Chart == nil { return nil, nil, errMissingChart } @@ -109,7 +116,7 @@ func (s *ReleaseServer) prepareUpdate(req *services.UpdateReleaseRequest) (*rele Info: &release.Info{ FirstDeployed: currentRelease.Info.FirstDeployed, LastDeployed: ts, - Status: &release.Status{Code: release.Status_UNKNOWN}, + Status: &release.Status{Code: release.Status_PENDING_UPGRADE}, Description: "Preparing upgrade", // This should be overwritten later. }, Version: revision, diff --git a/vendor/k8s.io/helm/pkg/tlsutil/cfg.go b/vendor/k8s.io/helm/pkg/tlsutil/cfg.go index ee909351..9ce3109e 100644 --- a/vendor/k8s.io/helm/pkg/tlsutil/cfg.go +++ b/vendor/k8s.io/helm/pkg/tlsutil/cfg.go @@ -27,7 +27,7 @@ import ( type Options struct { CaCertFile string // If either the KeyFile or CertFile is empty, ClientConfig() will not load them, - // preventing helm from authenticating to Tiller. They are required to be non-empty + // preventing Helm from authenticating to Tiller. They are required to be non-empty // when calling ServerConfig, otherwise an error is returned. KeyFile string CertFile string diff --git a/vendor/k8s.io/helm/pkg/tlsutil/tls.go b/vendor/k8s.io/helm/pkg/tlsutil/tls.go index 05a67121..422bddac 100644 --- a/vendor/k8s.io/helm/pkg/tlsutil/tls.go +++ b/vendor/k8s.io/helm/pkg/tlsutil/tls.go @@ -29,14 +29,17 @@ func NewClientTLS(certFile, keyFile, caFile string) (*tls.Config, error) { if err != nil { return nil, err } - cp, err := CertPoolFromFile(caFile) - if err != nil { - return nil, err - } - return &tls.Config{ + config := tls.Config{ Certificates: []tls.Certificate{*cert}, - RootCAs: cp, - }, nil + } + if caFile != "" { + cp, err := CertPoolFromFile(caFile) + if err != nil { + return nil, err + } + config.RootCAs = cp + } + return &config, nil } // CertPoolFromFile returns an x509.CertPool containing the certificates diff --git a/vendor/k8s.io/helm/pkg/version/version.go b/vendor/k8s.io/helm/pkg/version/version.go index f82fdc23..71b6af46 100644 --- a/vendor/k8s.io/helm/pkg/version/version.go +++ b/vendor/k8s.io/helm/pkg/version/version.go @@ -26,7 +26,7 @@ var ( // Increment major number for new feature additions and behavioral changes. // Increment minor number for bug fixes and performance enhancements. // Increment patch number for critical fixes to existing releases. - Version = "v2.5" + Version = "v2.6" // BuildMetadata is extra build time data BuildMetadata = "unreleased" diff --git a/vendor/k8s.io/helm/scripts/get b/vendor/k8s.io/helm/scripts/get index 02884d7f..748b0015 100755 --- a/vendor/k8s.io/helm/scripts/get +++ b/vendor/k8s.io/helm/scripts/get @@ -46,6 +46,17 @@ initOS() { esac } +# runs the given command as root (detects if we are root already) +runAsRoot() { + local CMD="$*" + + if [ $EUID -ne 0 ]; then + CMD="sudo $CMD" + fi + + $CMD +} + # verifySupported checks that the os/arch combination is supported for # binary builds. verifySupported() { @@ -129,8 +140,8 @@ installFile() { mkdir -p "$HELM_TMP" tar xf "$HELM_TMP_FILE" -C "$HELM_TMP" HELM_TMP_BIN="$HELM_TMP/$OS-$ARCH/$PROJECT_NAME" - echo "Preparing to install into ${HELM_INSTALL_DIR} (sudo)" - sudo cp "$HELM_TMP_BIN" "$HELM_INSTALL_DIR" + echo "Preparing to install into ${HELM_INSTALL_DIR}" + runAsRoot cp "$HELM_TMP_BIN" "$HELM_INSTALL_DIR" } # fail_trap is executed if an error occurs. diff --git a/vendor/k8s.io/helm/scripts/setup-apimachinery.sh b/vendor/k8s.io/helm/scripts/setup-apimachinery.sh index c749edcd..679859f3 100755 --- a/vendor/k8s.io/helm/scripts/setup-apimachinery.sh +++ b/vendor/k8s.io/helm/scripts/setup-apimachinery.sh @@ -19,7 +19,6 @@ # versioned. set -euo pipefail +rm -rf ./vendor/k8s.io/{kube-aggregator,apiserver,apimachinery,client-go,metrics} -rm -rf ./vendor/k8s.io/{kube-aggregator,apiserver,apimachinery,client-go} - -cp -r ./vendor/k8s.io/kubernetes/staging/src/k8s.io/{kube-aggregator,apiserver,apimachinery,client-go} ./vendor/k8s.io +cp -r ./vendor/k8s.io/kubernetes/staging/src/k8s.io/{kube-aggregator,apiserver,apimachinery,client-go,metrics} ./vendor/k8s.io