autoroll/go/config_vars/config_vars.go - buildbot - Git at Google

 package config_vars

 /*
 	Package config_vars provides helpers for configuration templates.
 */

 import (
 	"bytes"
 	"context"
 	"encoding/json"
 	"html/template"
 	"strings"
 	"sync"

 	"go.skia.org/infra/go/chrome_branch"
 	"go.skia.org/infra/go/skerr"
 )

 var (
 	// These templates should not be used.
 	bannedTmpls = []string{
 		"Chromium.Master.Number",
 	}
 )

 // Vars represents current values of variables which may be used in templates.
 type Vars struct {
 	Branches *Branches `json:"branches"`
 }

 // Validate returns an error if Vars is not valid.
 func (v *Vars) Validate() error {
 	if v.Branches == nil {
 		return skerr.Fmt("Branches is required.")
 	}
 	if err := v.Branches.Validate(); err != nil {
 		return skerr.Wrap(err)
 	}
 	return nil
 }

 // Copy returns a deep copy of the Vars.
 func (v *Vars) Copy() *Vars {
 	if v == nil {
 		return nil
 	}
 	return &Vars{
 		Branches: v.Branches.Copy(),
 	}
 }

 // FakeVars returns an instance of Vars with arbitrary contents which may be
 // used during validation and testing.
 func FakeVars() *Vars {
 	activeMilestones := []*chrome_branch.Branch{
 		{
 			Milestone: 82,
 			Number:    0,
 			Ref:       chrome_branch.RefMain,
 			V8Branch:  "8.2",
 		},
 		{
 			Milestone: 81,
 			Number:    4044,
 			Ref:       chrome_branch.ReleaseBranchRef(4044),
 			V8Branch:  "8.1",
 		},
 		{
 			Milestone: 80,
 			Number:    3987,
 			Ref:       chrome_branch.ReleaseBranchRef(4044),
 			V8Branch:  "8.0",
 		},
 	}
 	return &Vars{
 		Branches: &Branches{
 			ActiveMilestones: activeMilestones,
 			Chromium: &chrome_branch.Branches{
 				Main:   activeMilestones[0],
 				Beta:   activeMilestones[1],
 				Stable: activeMilestones[2],
 			},
 		},
 	}
 }

 // Branches represents named branches in git repositories.
 type Branches struct {
 	// ActiveMilestones are the active Chromium milestones.
 	ActiveMilestones []*chrome_branch.Branch `json:"active_milestones"`
 	// Chromium release branches.
 	Chromium *chrome_branch.Branches `json:"chromium"`
 }

 // Validate returns an error if Branches is not valid.
 func (b *Branches) Validate() error {
 	if b.ActiveMilestones == nil || len(b.ActiveMilestones) == 0 {
 		return skerr.Fmt("ActiveMilestones is required.")
 	}
 	for _, m := range b.ActiveMilestones {
 		if err := m.Validate(); err != nil {
 			return skerr.Wrap(err)
 		}
 	}
 	if b.Chromium == nil {
 		return skerr.Fmt("Chromium is required.")
 	}
 	if err := b.Chromium.Validate(); err != nil {
 		return skerr.Wrap(err)
 	}
 	return nil
 }

 // Copy returns a deep copy of the Branches.
 func (b *Branches) Copy() *Branches {
 	if b == nil {
 		return nil
 	}
 	activeMilestones := make([]*chrome_branch.Branch, 0, len(b.ActiveMilestones))
 	for _, m := range b.ActiveMilestones {
 		activeMilestones = append(activeMilestones, m.Copy())
 	}
 	var chromium *chrome_branch.Branches
 	if b.Chromium != nil {
 		chromium = b.Chromium.Copy()
 	}
 	return &Branches{
 		ActiveMilestones: activeMilestones,
 		Chromium:         chromium,
 	}
 }

 // Template is a text template which uses the contents of Vars. It is
 // technically thread-safe, but users should take care to cache the value of
 // Template.String() rather than calling it repeatedly, unless Update() is
 // only ever called within the same thread as String().
 type Template struct {
 	mtx   sync.RWMutex
 	raw   string
 	tmpl  *template.Template
 	value string
 }

 // NewTemplate returns a Template instance.
 func NewTemplate(rawTmpl string) (*Template, error) {
 	rv := &Template{}
 	if err := rv.init(rawTmpl); err != nil {
 		return nil, skerr.Wrap(err)
 	}
 	return rv, nil
 }

 // init initializes the template.
 func (t *Template) init(rawTmpl string) error {
 	for _, banned := range bannedTmpls {
 		if strings.Contains(rawTmpl, banned) {
 			return skerr.Fmt("Templates should not use %q", banned)
 		}
 	}
 	tmpl, err := template.New("").Parse(rawTmpl)
 	if err != nil {
 		return skerr.Wrap(err)
 	}
 	tmpl.Option("missingkey=error")
 	t.raw = rawTmpl
 	t.tmpl = tmpl
 	return skerr.Wrap(t.validate())
 }

 // UnmarshalJSON implements json.Unmarshaler.
 func (t *Template) UnmarshalJSON(b []byte) error {
 	t.mtx.Lock()
 	defer t.mtx.Unlock()
 	var raw string
 	if err := json.Unmarshal(b, &raw); err != nil {
 		return skerr.Wrap(err)
 	}
 	return skerr.Wrap(t.init(raw))
 }

 // MarshalJSON implements json.Marshaler.
 func (t *Template) MarshalJSON() ([]byte, error) {
 	t.mtx.RLock()
 	defer t.mtx.RUnlock()
 	return json.Marshal(t.raw)
 }

 // Validate returns an error if the Template is not valid.
 func (t *Template) Validate() error {
 	t.mtx.RLock()
 	defer t.mtx.RUnlock()
 	return skerr.Wrap(t.validate())
 }

 // validate returns an error if the Template is not valid. Assumes the caller
 // holds t.mtx.
 func (t *Template) validate() error {
 	if t == nil || t.raw == "" || t.tmpl == nil {
 		return skerr.Fmt("Template is missing.")
 	}
 	// Create fake Vars to test the template.
 	v := FakeVars()

 	// Self-check, in case any of the members of Vars change.
 	if err := v.Validate(); err != nil {
 		return skerr.Wrap(err)
 	}
 	var buf bytes.Buffer
 	if err := t.tmpl.Execute(&buf, v); err != nil {
 		return skerr.Wrap(err)
 	}
 	return nil
 }

 // Update executes the Template using the given Vars and updates its value.
 func (t *Template) Update(v *Vars) error {
 	t.mtx.Lock()
 	defer t.mtx.Unlock()
 	var buf bytes.Buffer
 	if err := t.tmpl.Execute(&buf, v); err != nil {
 		return skerr.Wrap(err)
 	}
 	t.value = buf.String()
 	return nil
 }

 // String returns the current value of the Template.
 func (t *Template) String() string {
 	t.mtx.RLock()
 	defer t.mtx.RUnlock()
 	return t.value
 }

 // Equal returns true iff the given Template is equivalent to this one. This
 // allows us to test equality using deepequal.DeepEqual, despite the fact that
 // text.Templates are never DeepEqual.
 func (t *Template) Equal(t2 *Template) bool {
 	t.mtx.RLock()
 	defer t.mtx.RUnlock()
 	t2.mtx.RLock()
 	defer t2.mtx.RUnlock()
 	if t.raw != t2.raw {
 		return false
 	}
 	if t.value != t2.value {
 		return false
 	}
 	return true
 }

 // RawTemplate returns the raw string value of the Template.
 func (t *Template) RawTemplate() string {
 	return t.raw
 }

 // Registry manages a set of Templates, updating their values when Update is
 // called.
 type Registry struct {
 	cbc       chrome_branch.Client
 	mtx       sync.Mutex
 	templates []*Template
 	vars      *Vars
 }

 // NewRegistry returns a Registry instance. Implicitly runs Update().
 func NewRegistry(ctx context.Context, cbc chrome_branch.Client) (*Registry, error) {
 	r := &Registry{
 		cbc: cbc,
 	}
 	if err := r.Update(ctx); err != nil {
 		return nil, err
 	}
 	return r, nil
 }

 // Register the given Template. Implicitly Updates its value using the most
 // recent Vars.
 func (r *Registry) Register(t *Template) error {
 	r.mtx.Lock()
 	defer r.mtx.Unlock()
 	if err := t.Update(r.vars); err != nil {
 		return err
 	}
 	r.templates = append(r.templates, t)
 	return nil
 }

 // updateFrom updates all of the Templates managed by this Registry using the
 // given Vars.
 func (r *Registry) updateFrom(v *Vars) error {
 	r.mtx.Lock()
 	defer r.mtx.Unlock()
 	for _, tmpl := range r.templates {
 		if err := tmpl.Update(v); err != nil {
 			return skerr.Wrap(err)
 		}
 	}
 	r.vars = v
 	return nil
 }

 // Update all of the Templates managed by this Registry by loading new values.
 func (r *Registry) Update(ctx context.Context) error {
 	chromeBranches, activeMilestones, err := r.cbc.Get(ctx)
 	if err != nil {
 		return skerr.Wrap(err)
 	}
 	vars := &Vars{
 		Branches: &Branches{
 			ActiveMilestones: activeMilestones,
 			Chromium:         chromeBranches,
 		},
 	}
 	return skerr.Wrap(r.updateFrom(vars))
 }

 // Vars returns a copy of the current value of the stored Vars.
 func (r *Registry) Vars() *Vars {
 	r.mtx.Lock()
 	defer r.mtx.Unlock()
 	return r.vars.Copy()
 }
	package config_vars

	/*
	Package config_vars provides helpers for configuration templates.
	*/

	import (
	"bytes"
	"context"
	"encoding/json"
	"html/template"
	"strings"
	"sync"

	"go.skia.org/infra/go/chrome_branch"
	"go.skia.org/infra/go/skerr"
	)

	var (
	// These templates should not be used.
	bannedTmpls = []string{
	"Chromium.Master.Number",
	}
	)

	// Vars represents current values of variables which may be used in templates.
	type Vars struct {
	Branches *Branches `json:"branches"`
	}

	// Validate returns an error if Vars is not valid.
	func (v *Vars) Validate() error {
	if v.Branches == nil {
	return skerr.Fmt("Branches is required.")
	}
	if err := v.Branches.Validate(); err != nil {
	return skerr.Wrap(err)
	}
	return nil
	}

	// Copy returns a deep copy of the Vars.
	func (v Vars) Copy() Vars {
	if v == nil {
	return nil
	}
	return &Vars{
	Branches: v.Branches.Copy(),
	}
	}

	// FakeVars returns an instance of Vars with arbitrary contents which may be
	// used during validation and testing.
	func FakeVars() *Vars {
	activeMilestones := []*chrome_branch.Branch{
	{
	Milestone: 82,
	Number: 0,
	Ref: chrome_branch.RefMain,
	V8Branch: "8.2",
	},
	{
	Milestone: 81,
	Number: 4044,
	Ref: chrome_branch.ReleaseBranchRef(4044),
	V8Branch: "8.1",
	},
	{
	Milestone: 80,
	Number: 3987,
	Ref: chrome_branch.ReleaseBranchRef(4044),
	V8Branch: "8.0",
	},
	}
	return &Vars{
	Branches: &Branches{
	ActiveMilestones: activeMilestones,
	Chromium: &chrome_branch.Branches{
	Main: activeMilestones[0],
	Beta: activeMilestones[1],
	Stable: activeMilestones[2],
	},
	},
	}
	}

	// Branches represents named branches in git repositories.
	type Branches struct {
	// ActiveMilestones are the active Chromium milestones.
	ActiveMilestones []*chrome_branch.Branch `json:"active_milestones"`
	// Chromium release branches.
	Chromium *chrome_branch.Branches `json:"chromium"`
	}

	// Validate returns an error if Branches is not valid.
	func (b *Branches) Validate() error {
	if b.ActiveMilestones == nil \|\| len(b.ActiveMilestones) == 0 {
	return skerr.Fmt("ActiveMilestones is required.")
	}
	for _, m := range b.ActiveMilestones {
	if err := m.Validate(); err != nil {
	return skerr.Wrap(err)
	}
	}
	if b.Chromium == nil {
	return skerr.Fmt("Chromium is required.")
	}
	if err := b.Chromium.Validate(); err != nil {
	return skerr.Wrap(err)
	}
	return nil
	}

	// Copy returns a deep copy of the Branches.
	func (b Branches) Copy() Branches {
	if b == nil {
	return nil
	}
	activeMilestones := make([]*chrome_branch.Branch, 0, len(b.ActiveMilestones))
	for _, m := range b.ActiveMilestones {
	activeMilestones = append(activeMilestones, m.Copy())
	}
	var chromium *chrome_branch.Branches
	if b.Chromium != nil {
	chromium = b.Chromium.Copy()
	}
	return &Branches{
	ActiveMilestones: activeMilestones,
	Chromium: chromium,
	}
	}

	// Template is a text template which uses the contents of Vars. It is
	// technically thread-safe, but users should take care to cache the value of
	// Template.String() rather than calling it repeatedly, unless Update() is
	// only ever called within the same thread as String().
	type Template struct {
	mtx sync.RWMutex
	raw string
	tmpl *template.Template
	value string
	}

	// NewTemplate returns a Template instance.
	func NewTemplate(rawTmpl string) (*Template, error) {
	rv := &Template{}
	if err := rv.init(rawTmpl); err != nil {
	return nil, skerr.Wrap(err)
	}
	return rv, nil
	}

	// init initializes the template.
	func (t *Template) init(rawTmpl string) error {
	for _, banned := range bannedTmpls {
	if strings.Contains(rawTmpl, banned) {
	return skerr.Fmt("Templates should not use %q", banned)
	}
	}
	tmpl, err := template.New("").Parse(rawTmpl)
	if err != nil {
	return skerr.Wrap(err)
	}
	tmpl.Option("missingkey=error")
	t.raw = rawTmpl
	t.tmpl = tmpl
	return skerr.Wrap(t.validate())
	}

	// UnmarshalJSON implements json.Unmarshaler.
	func (t *Template) UnmarshalJSON(b []byte) error {
	t.mtx.Lock()
	defer t.mtx.Unlock()
	var raw string
	if err := json.Unmarshal(b, &raw); err != nil {
	return skerr.Wrap(err)
	}
	return skerr.Wrap(t.init(raw))
	}

	// MarshalJSON implements json.Marshaler.
	func (t *Template) MarshalJSON() ([]byte, error) {
	t.mtx.RLock()
	defer t.mtx.RUnlock()
	return json.Marshal(t.raw)
	}

	// Validate returns an error if the Template is not valid.
	func (t *Template) Validate() error {
	t.mtx.RLock()
	defer t.mtx.RUnlock()
	return skerr.Wrap(t.validate())
	}

	// validate returns an error if the Template is not valid. Assumes the caller
	// holds t.mtx.
	func (t *Template) validate() error {
	if t == nil \|\| t.raw == "" \|\| t.tmpl == nil {
	return skerr.Fmt("Template is missing.")
	}
	// Create fake Vars to test the template.
	v := FakeVars()

	// Self-check, in case any of the members of Vars change.
	if err := v.Validate(); err != nil {
	return skerr.Wrap(err)
	}
	var buf bytes.Buffer
	if err := t.tmpl.Execute(&buf, v); err != nil {
	return skerr.Wrap(err)
	}
	return nil
	}

	// Update executes the Template using the given Vars and updates its value.
	func (t Template) Update(v Vars) error {
	t.mtx.Lock()
	defer t.mtx.Unlock()
	var buf bytes.Buffer
	if err := t.tmpl.Execute(&buf, v); err != nil {
	return skerr.Wrap(err)
	}
	t.value = buf.String()
	return nil
	}

	// String returns the current value of the Template.
	func (t *Template) String() string {
	t.mtx.RLock()
	defer t.mtx.RUnlock()
	return t.value
	}

	// Equal returns true iff the given Template is equivalent to this one. This
	// allows us to test equality using deepequal.DeepEqual, despite the fact that
	// text.Templates are never DeepEqual.
	func (t Template) Equal(t2 Template) bool {
	t.mtx.RLock()
	defer t.mtx.RUnlock()
	t2.mtx.RLock()
	defer t2.mtx.RUnlock()
	if t.raw != t2.raw {
	return false
	}
	if t.value != t2.value {
	return false
	}
	return true
	}

	// RawTemplate returns the raw string value of the Template.
	func (t *Template) RawTemplate() string {
	return t.raw
	}

	// Registry manages a set of Templates, updating their values when Update is
	// called.
	type Registry struct {
	cbc chrome_branch.Client
	mtx sync.Mutex
	templates []*Template
	vars *Vars
	}

	// NewRegistry returns a Registry instance. Implicitly runs Update().
	func NewRegistry(ctx context.Context, cbc chrome_branch.Client) (*Registry, error) {
	r := &Registry{
	cbc: cbc,
	}
	if err := r.Update(ctx); err != nil {
	return nil, err
	}
	return r, nil
	}

	// Register the given Template. Implicitly Updates its value using the most
	// recent Vars.
	func (r Registry) Register(t Template) error {
	r.mtx.Lock()
	defer r.mtx.Unlock()
	if err := t.Update(r.vars); err != nil {
	return err
	}
	r.templates = append(r.templates, t)
	return nil
	}

	// updateFrom updates all of the Templates managed by this Registry using the
	// given Vars.
	func (r Registry) updateFrom(v Vars) error {
	r.mtx.Lock()
	defer r.mtx.Unlock()
	for _, tmpl := range r.templates {
	if err := tmpl.Update(v); err != nil {
	return skerr.Wrap(err)
	}
	}
	r.vars = v
	return nil
	}

	// Update all of the Templates managed by this Registry by loading new values.
	func (r *Registry) Update(ctx context.Context) error {
	chromeBranches, activeMilestones, err := r.cbc.Get(ctx)
	if err != nil {
	return skerr.Wrap(err)
	}
	vars := &Vars{
	Branches: &Branches{
	ActiveMilestones: activeMilestones,
	Chromium: chromeBranches,
	},
	}
	return skerr.Wrap(r.updateFrom(vars))
	}

	// Vars returns a copy of the current value of the stored Vars.
	func (r Registry) Vars() Vars {
	r.mtx.Lock()
	defer r.mtx.Unlock()
	return r.vars.Copy()
	}