2373 lines
61 KiB
Go
2373 lines
61 KiB
Go
package pkger
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"path"
|
|
"regexp"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
|
|
"github.com/influxdata/flux/ast"
|
|
"github.com/influxdata/flux/ast/edit"
|
|
fluxurl "github.com/influxdata/flux/dependencies/url"
|
|
"github.com/influxdata/flux/parser"
|
|
errors2 "github.com/influxdata/influxdb/v2/kit/platform/errors"
|
|
"github.com/influxdata/influxdb/v2/pkg/jsonnet"
|
|
"github.com/influxdata/influxdb/v2/task/options"
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
type (
|
|
// ReaderFn is used for functional inputs to abstract the individual
|
|
// entrypoints for the reader itself.
|
|
ReaderFn func() (r io.Reader, source string, err error)
|
|
|
|
// Encoder is an encodes a type.
|
|
Encoder interface {
|
|
Encode(v interface{}) error
|
|
}
|
|
|
|
// Encoding describes the encoding for the raw package data. The
|
|
// encoding determines how the raw data is parsed.
|
|
Encoding int
|
|
)
|
|
|
|
// encoding types
|
|
const (
|
|
EncodingUnknown Encoding = iota
|
|
EncodingJSON
|
|
EncodingJsonnet
|
|
EncodingSource // EncodingSource draws the encoding type by inferring it from the source.
|
|
EncodingYAML
|
|
)
|
|
|
|
// String provides the string representation of the encoding.
|
|
func (e Encoding) String() string {
|
|
switch e {
|
|
case EncodingJSON:
|
|
return "json"
|
|
case EncodingJsonnet:
|
|
return "jsonnet"
|
|
case EncodingSource:
|
|
return "source"
|
|
case EncodingYAML:
|
|
return "yaml"
|
|
default:
|
|
return "unknown"
|
|
}
|
|
}
|
|
|
|
// ErrInvalidEncoding indicates the encoding is invalid type for the parser.
|
|
var ErrInvalidEncoding = errors.New("invalid encoding provided")
|
|
|
|
// Parse parses a pkg defined by the encoding and readerFns. As of writing this
|
|
// we can parse both a YAML, JSON, and Jsonnet formats of the Template model.
|
|
func Parse(encoding Encoding, readerFn ReaderFn, opts ...ValidateOptFn) (*Template, error) {
|
|
r, source, err := readerFn()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var pkgFn func(io.Reader, ...ValidateOptFn) (*Template, error)
|
|
switch encoding {
|
|
case EncodingJSON:
|
|
pkgFn = parseJSON
|
|
case EncodingJsonnet:
|
|
pkgFn = parseJsonnet
|
|
case EncodingSource:
|
|
pkgFn = parseSource
|
|
case EncodingYAML:
|
|
pkgFn = parseYAML
|
|
default:
|
|
return nil, ErrInvalidEncoding
|
|
}
|
|
|
|
pkg, err := pkgFn(r, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
pkg.sources = []string{source}
|
|
|
|
return pkg, nil
|
|
}
|
|
|
|
// FromFile reads a file from disk and provides a reader from it.
|
|
func FromFile(filePath string) ReaderFn {
|
|
return func() (io.Reader, string, error) {
|
|
u, err := url.Parse(filePath)
|
|
if err != nil {
|
|
return nil, filePath, &errors2.Error{
|
|
Code: errors2.EInvalid,
|
|
Msg: "invalid filepath provided",
|
|
Err: err,
|
|
}
|
|
}
|
|
if u.Scheme == "" {
|
|
u.Scheme = "file"
|
|
}
|
|
|
|
// not using os.Open to avoid having to deal with closing the file in here
|
|
b, err := os.ReadFile(u.Path)
|
|
if err != nil {
|
|
return nil, filePath, err
|
|
}
|
|
|
|
return bytes.NewBuffer(b), u.String(), nil
|
|
}
|
|
}
|
|
|
|
// FromReader simply passes the reader along. Useful when consuming
|
|
// this from an HTTP request body. There are a number of other useful
|
|
// places for this functional input.
|
|
func FromReader(r io.Reader, sources ...string) ReaderFn {
|
|
return func() (io.Reader, string, error) {
|
|
source := "byte stream"
|
|
if len(sources) > 0 {
|
|
source = formatSources(sources)
|
|
}
|
|
return r, source, nil
|
|
}
|
|
}
|
|
|
|
// FromString parses a pkg from a raw string value. This is very useful
|
|
// in tests.
|
|
func FromString(s string) ReaderFn {
|
|
return func() (io.Reader, string, error) {
|
|
return strings.NewReader(s), "string", nil
|
|
}
|
|
}
|
|
|
|
// NewDefaultHTTPClient creates a client with the specified flux IP validator.
|
|
// This is copied from flux/dependencies/http/http.go
|
|
func NewDefaultHTTPClient(urlValidator fluxurl.Validator) *http.Client {
|
|
// Control is called after DNS lookup, but before the network
|
|
// connection is initiated.
|
|
control := func(network, address string, c syscall.RawConn) error {
|
|
host, _, err := net.SplitHostPort(address)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
ip := net.ParseIP(host)
|
|
return urlValidator.ValidateIP(ip)
|
|
}
|
|
|
|
dialer := &net.Dialer{
|
|
Timeout: time.Minute,
|
|
Control: control,
|
|
// DualStack is deprecated
|
|
}
|
|
|
|
return &http.Client{
|
|
Transport: &http.Transport{
|
|
DialContext: dialer.DialContext,
|
|
},
|
|
}
|
|
}
|
|
|
|
// FromHTTPRequest parses a pkg from the request body of a HTTP request. This is
|
|
// very useful when using packages that are hosted..
|
|
func FromHTTPRequest(addr string, client *http.Client) ReaderFn {
|
|
return func() (io.Reader, string, error) {
|
|
resp, err := client.Get(normalizeGithubURLToContent(addr))
|
|
if err != nil {
|
|
return nil, addr, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
var buf bytes.Buffer
|
|
if _, err := io.Copy(&buf, resp.Body); err != nil {
|
|
return nil, addr, err
|
|
}
|
|
|
|
if resp.StatusCode/100 != 2 {
|
|
return nil, addr, fmt.Errorf(
|
|
"bad response: address=%s status_code=%d body=%q",
|
|
addr, resp.StatusCode, strings.TrimSpace(buf.String()),
|
|
)
|
|
}
|
|
|
|
return &buf, addr, nil
|
|
}
|
|
}
|
|
|
|
const (
|
|
githubRawContentHost = "raw.githubusercontent.com"
|
|
githubHost = "github.com"
|
|
)
|
|
|
|
func normalizeGithubURLToContent(addr string) string {
|
|
u, err := url.Parse(addr)
|
|
if err != nil {
|
|
return addr
|
|
}
|
|
|
|
if u.Host == githubHost {
|
|
switch path.Ext(u.Path) {
|
|
case ".yaml", ".yml", ".json", ".jsonnet":
|
|
default:
|
|
return u.String()
|
|
}
|
|
|
|
parts := strings.Split(u.Path, "/")
|
|
if len(parts) < 4 {
|
|
return u.String()
|
|
}
|
|
u.Host = githubRawContentHost
|
|
u.Path = path.Join(append(parts[:3], parts[4:]...)...)
|
|
}
|
|
|
|
return u.String()
|
|
}
|
|
|
|
func parseJSON(r io.Reader, opts ...ValidateOptFn) (*Template, error) {
|
|
return parse(json.NewDecoder(r), opts...)
|
|
}
|
|
|
|
func parseJsonnet(r io.Reader, opts ...ValidateOptFn) (*Template, error) {
|
|
opt := &validateOpt{}
|
|
for _, o := range opts {
|
|
o(opt)
|
|
}
|
|
// For security, we'll default to disabling parsing jsonnet but allow callers to override the behavior via
|
|
// EnableJsonnet(). Enabling jsonnet might be useful for client code where parsing jsonnet could be acceptable.
|
|
if opt.enableJsonnet {
|
|
return parse(jsonnet.NewDecoder(r), opts...)
|
|
}
|
|
return nil, fmt.Errorf("%s: jsonnet", ErrInvalidEncoding)
|
|
}
|
|
|
|
func parseSource(r io.Reader, opts ...ValidateOptFn) (*Template, error) {
|
|
var b []byte
|
|
if byter, ok := r.(interface{ Bytes() []byte }); ok {
|
|
b = byter.Bytes()
|
|
} else {
|
|
bb, err := io.ReadAll(r)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to decode pkg source: %s", err)
|
|
}
|
|
b = bb
|
|
}
|
|
|
|
contentType := http.DetectContentType(b[:512])
|
|
switch {
|
|
case strings.Contains(contentType, "jsonnet"):
|
|
// highly unlikely to fall in here with supported content type detection as is
|
|
return parseJsonnet(bytes.NewReader(b), opts...)
|
|
case strings.Contains(contentType, "json"):
|
|
return parseJSON(bytes.NewReader(b), opts...)
|
|
case strings.Contains(contentType, "yaml"),
|
|
strings.Contains(contentType, "yml"):
|
|
return parseYAML(bytes.NewReader(b), opts...)
|
|
default:
|
|
return parseYAML(bytes.NewReader(b), opts...)
|
|
}
|
|
}
|
|
|
|
func parseYAML(r io.Reader, opts ...ValidateOptFn) (*Template, error) {
|
|
dec := yaml.NewDecoder(r)
|
|
|
|
var pkg Template
|
|
for {
|
|
// forced to use this for loop b/c the yaml dependency does not
|
|
// decode multi documents.
|
|
var k Object
|
|
err := dec.Decode(&k)
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
pkg.Objects = append(pkg.Objects, k)
|
|
}
|
|
|
|
if err := pkg.Validate(opts...); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &pkg, nil
|
|
}
|
|
|
|
type decoder interface {
|
|
Decode(interface{}) error
|
|
}
|
|
|
|
func parse(dec decoder, opts ...ValidateOptFn) (*Template, error) {
|
|
var pkg Template
|
|
if err := dec.Decode(&pkg.Objects); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := pkg.Validate(opts...); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &pkg, nil
|
|
}
|
|
|
|
// Object describes the metadata and raw spec for an entity of a package kind.
|
|
type Object struct {
|
|
APIVersion string `json:"apiVersion" yaml:"apiVersion"`
|
|
Kind Kind `json:"kind" yaml:"kind"`
|
|
Metadata Resource `json:"metadata" yaml:"metadata"`
|
|
Spec Resource `json:"spec" yaml:"spec"`
|
|
}
|
|
|
|
// Name returns the name of the kind.
|
|
func (k Object) Name() string {
|
|
return k.Metadata.references(fieldName).String()
|
|
}
|
|
|
|
// ObjectAssociation is an association for an object. The supported types
|
|
// at this time are KindLabel.
|
|
type ObjectAssociation struct {
|
|
Kind Kind
|
|
MetaName string
|
|
}
|
|
|
|
// AddAssociations adds an association to the object.
|
|
func (k Object) AddAssociations(associations ...ObjectAssociation) {
|
|
if len(associations) == 0 {
|
|
return
|
|
}
|
|
|
|
if k.Spec == nil {
|
|
k.Spec = make(Resource)
|
|
}
|
|
|
|
existingAss := k.Spec.slcResource(fieldAssociations)
|
|
for _, ass := range associations {
|
|
existingAss = append(existingAss, Resource{
|
|
fieldKind: ass.Kind,
|
|
fieldName: ass.MetaName,
|
|
})
|
|
}
|
|
sort.Slice(existingAss, func(i, j int) bool {
|
|
iPkgName, jPkgName := existingAss[i].Name(), existingAss[j].Name()
|
|
return iPkgName < jPkgName
|
|
})
|
|
if existingAss == nil {
|
|
return
|
|
}
|
|
|
|
k.Spec[fieldAssociations] = existingAss
|
|
}
|
|
|
|
// SetMetadataName sets the metadata.name field.
|
|
func (k Object) SetMetadataName(name string) {
|
|
if k.Metadata == nil {
|
|
k.Metadata = make(Resource)
|
|
}
|
|
k.Metadata[fieldName] = name
|
|
}
|
|
|
|
// Template is the model for a package. The resources are more generic that one might
|
|
// expect at first glance. This was done on purpose. The way json/yaml/toml or
|
|
// w/e scripting you want to use, can have very different ways of parsing. The
|
|
// different parsers are limited for the parsers that do not come from the std
|
|
// lib (looking at you yaml/v2). This allows us to parse it and leave the matching
|
|
// to another power, the graphing of the package is handled within itself.
|
|
type Template struct {
|
|
Objects []Object `json:"-" yaml:"-"`
|
|
sources []string
|
|
|
|
mLabels map[string]*label
|
|
mBuckets map[string]*bucket
|
|
mChecks map[string]*check
|
|
mDashboards map[string]*dashboard
|
|
mNotificationEndpoints map[string]*notificationEndpoint
|
|
mNotificationRules map[string]*notificationRule
|
|
mTasks map[string]*task
|
|
mTelegrafs map[string]*telegraf
|
|
mVariables map[string]*variable
|
|
|
|
mEnv map[string]bool
|
|
mEnvVals map[string]interface{}
|
|
mSecrets map[string]bool
|
|
|
|
isParsed bool // indicates the pkg has been parsed and all resources graphed accordingly
|
|
}
|
|
|
|
// Encode is a helper for encoding the pkg correctly.
|
|
func (p *Template) Encode(encoding Encoding) ([]byte, error) {
|
|
if p == nil {
|
|
panic("attempted to encode a nil Template")
|
|
}
|
|
|
|
var (
|
|
buf bytes.Buffer
|
|
err error
|
|
)
|
|
switch encoding {
|
|
case EncodingJSON, EncodingJsonnet:
|
|
enc := json.NewEncoder(&buf)
|
|
enc.SetIndent("", "\t")
|
|
err = enc.Encode(p.Objects)
|
|
case EncodingYAML:
|
|
enc := yaml.NewEncoder(&buf)
|
|
for _, k := range p.Objects {
|
|
if err = enc.Encode(k); err != nil {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
return nil, ErrInvalidEncoding
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
|
|
func (p *Template) Sources() []string {
|
|
// note: we prevent the internal field from being changed by enabling access
|
|
// to the sources via the exported method here.
|
|
return p.sources
|
|
}
|
|
|
|
// Summary returns a package Summary that describes all the resources and
|
|
// associations the pkg contains. It is very useful for informing users of
|
|
// the changes that will take place when this pkg would be applied.
|
|
func (p *Template) Summary() Summary {
|
|
// ensure zero values for arrays aren't returned, but instead
|
|
// we always returning an initialized slice.
|
|
sum := Summary{
|
|
Buckets: []SummaryBucket{},
|
|
Checks: []SummaryCheck{},
|
|
Dashboards: []SummaryDashboard{},
|
|
NotificationEndpoints: []SummaryNotificationEndpoint{},
|
|
NotificationRules: []SummaryNotificationRule{},
|
|
Labels: []SummaryLabel{},
|
|
MissingEnvs: p.missingEnvRefs(),
|
|
MissingSecrets: p.missingSecrets(),
|
|
Tasks: []SummaryTask{},
|
|
TelegrafConfigs: []SummaryTelegraf{},
|
|
Variables: []SummaryVariable{},
|
|
}
|
|
|
|
for _, b := range p.buckets() {
|
|
sum.Buckets = append(sum.Buckets, b.summarize())
|
|
}
|
|
|
|
for _, c := range p.checks() {
|
|
sum.Checks = append(sum.Checks, c.summarize())
|
|
}
|
|
|
|
for _, d := range p.dashboards() {
|
|
sum.Dashboards = append(sum.Dashboards, d.summarize())
|
|
}
|
|
|
|
for _, l := range p.labels() {
|
|
sum.Labels = append(sum.Labels, l.summarize())
|
|
}
|
|
|
|
sum.LabelMappings = p.labelMappings()
|
|
|
|
for _, n := range p.notificationEndpoints() {
|
|
sum.NotificationEndpoints = append(sum.NotificationEndpoints, n.summarize())
|
|
}
|
|
|
|
for _, r := range p.notificationRules() {
|
|
sum.NotificationRules = append(sum.NotificationRules, r.summarize())
|
|
}
|
|
|
|
for _, t := range p.tasks() {
|
|
sum.Tasks = append(sum.Tasks, t.summarize())
|
|
}
|
|
|
|
for _, t := range p.telegrafs() {
|
|
sum.TelegrafConfigs = append(sum.TelegrafConfigs, t.summarize())
|
|
}
|
|
|
|
for _, v := range p.variables() {
|
|
sum.Variables = append(sum.Variables, v.summarize())
|
|
}
|
|
|
|
return sum
|
|
}
|
|
|
|
func (p *Template) applyEnvRefs(envRefs map[string]interface{}) error {
|
|
if len(envRefs) == 0 {
|
|
return nil
|
|
}
|
|
|
|
if p.mEnvVals == nil {
|
|
p.mEnvVals = make(map[string]interface{})
|
|
}
|
|
|
|
for k, v := range envRefs {
|
|
p.mEnvVals[k] = v
|
|
}
|
|
|
|
return p.Validate()
|
|
}
|
|
|
|
func (p *Template) applySecrets(secrets map[string]string) {
|
|
for k := range secrets {
|
|
p.mSecrets[k] = true
|
|
}
|
|
}
|
|
|
|
// Contains identifies if a pkg contains a given object identified
|
|
// by its kind and metadata.Name (MetaName) field.
|
|
func (p *Template) Contains(k Kind, pkgName string) bool {
|
|
switch k {
|
|
case KindBucket:
|
|
_, ok := p.mBuckets[pkgName]
|
|
return ok
|
|
case KindCheck, KindCheckDeadman, KindCheckThreshold:
|
|
_, ok := p.mChecks[pkgName]
|
|
return ok
|
|
case KindLabel:
|
|
_, ok := p.mLabels[pkgName]
|
|
return ok
|
|
case KindNotificationEndpoint,
|
|
KindNotificationEndpointHTTP,
|
|
KindNotificationEndpointPagerDuty,
|
|
KindNotificationEndpointSlack:
|
|
_, ok := p.mNotificationEndpoints[pkgName]
|
|
return ok
|
|
case KindNotificationRule:
|
|
_, ok := p.mNotificationRules[pkgName]
|
|
return ok
|
|
case KindTask:
|
|
_, ok := p.mTasks[pkgName]
|
|
return ok
|
|
case KindTelegraf:
|
|
_, ok := p.mTelegrafs[pkgName]
|
|
return ok
|
|
case KindVariable:
|
|
_, ok := p.mVariables[pkgName]
|
|
return ok
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Combine combines pkgs together. Is useful when you want to take multiple disparate pkgs
|
|
// and compile them into one to take advantage of the parser and service guarantees.
|
|
func Combine(pkgs []*Template, validationOpts ...ValidateOptFn) (*Template, error) {
|
|
newPkg := new(Template)
|
|
for _, p := range pkgs {
|
|
if len(p.Objects) == 0 {
|
|
continue
|
|
}
|
|
newPkg.sources = append(newPkg.sources, p.sources...)
|
|
newPkg.Objects = append(newPkg.Objects, p.Objects...)
|
|
}
|
|
|
|
return newPkg, newPkg.Validate(validationOpts...)
|
|
}
|
|
|
|
type (
|
|
validateOpt struct {
|
|
minResources bool
|
|
skipValidate bool
|
|
enableJsonnet bool
|
|
}
|
|
|
|
// ValidateOptFn provides a means to disable desired validation checks.
|
|
ValidateOptFn func(*validateOpt)
|
|
)
|
|
|
|
// Jsonnet parsing is disabled by default. EnableJsonnet turns it back on.
|
|
func EnableJsonnet() ValidateOptFn {
|
|
return func(opt *validateOpt) {
|
|
opt.enableJsonnet = true
|
|
}
|
|
}
|
|
|
|
// ValidWithoutResources ignores the validation check for minimum number
|
|
// of resources. This is useful for the service Create to ignore this and
|
|
// allow the creation of a pkg without resources.
|
|
func ValidWithoutResources() ValidateOptFn {
|
|
return func(opt *validateOpt) {
|
|
opt.minResources = false
|
|
}
|
|
}
|
|
|
|
// ValidSkipParseError ignores the validation check from the of resources. This
|
|
// is useful for the service Create to ignore this and allow the creation of a
|
|
// pkg without resources.
|
|
func ValidSkipParseError() ValidateOptFn {
|
|
return func(opt *validateOpt) {
|
|
opt.skipValidate = true
|
|
}
|
|
}
|
|
|
|
// Validate will graph all resources and validate every thing is in a useful form.
|
|
func (p *Template) Validate(opts ...ValidateOptFn) error {
|
|
opt := &validateOpt{minResources: true}
|
|
for _, o := range opts {
|
|
o(opt)
|
|
}
|
|
|
|
var setupFns []func() error
|
|
if opt.minResources {
|
|
setupFns = append(setupFns, p.validResources)
|
|
}
|
|
setupFns = append(setupFns, p.graphResources)
|
|
|
|
var pErr parseErr
|
|
for _, fn := range setupFns {
|
|
if err := fn(); err != nil {
|
|
if IsParseErr(err) {
|
|
pErr.append(err.(*parseErr).Resources...)
|
|
continue
|
|
}
|
|
return err
|
|
}
|
|
}
|
|
|
|
if len(pErr.Resources) > 0 && !opt.skipValidate {
|
|
return &pErr
|
|
}
|
|
|
|
p.isParsed = true
|
|
return nil
|
|
}
|
|
|
|
func (p *Template) buckets() []*bucket {
|
|
buckets := make([]*bucket, 0, len(p.mBuckets))
|
|
for _, b := range p.mBuckets {
|
|
buckets = append(buckets, b)
|
|
}
|
|
|
|
sort.Slice(buckets, func(i, j int) bool { return buckets[i].MetaName() < buckets[j].MetaName() })
|
|
|
|
return buckets
|
|
}
|
|
|
|
func (p *Template) checks() []*check {
|
|
checks := make([]*check, 0, len(p.mChecks))
|
|
for _, c := range p.mChecks {
|
|
checks = append(checks, c)
|
|
}
|
|
|
|
sort.Slice(checks, func(i, j int) bool { return checks[i].MetaName() < checks[j].MetaName() })
|
|
|
|
return checks
|
|
}
|
|
|
|
func (p *Template) labels() []*label {
|
|
labels := make(sortedLabels, 0, len(p.mLabels))
|
|
for _, l := range p.mLabels {
|
|
labels = append(labels, l)
|
|
}
|
|
|
|
sort.Sort(labels)
|
|
|
|
return labels
|
|
}
|
|
|
|
func (p *Template) dashboards() []*dashboard {
|
|
dashes := make([]*dashboard, 0, len(p.mDashboards))
|
|
for _, d := range p.mDashboards {
|
|
dashes = append(dashes, d)
|
|
}
|
|
sort.Slice(dashes, func(i, j int) bool { return dashes[i].MetaName() < dashes[j].MetaName() })
|
|
return dashes
|
|
}
|
|
|
|
func (p *Template) notificationEndpoints() []*notificationEndpoint {
|
|
endpoints := make([]*notificationEndpoint, 0, len(p.mNotificationEndpoints))
|
|
for _, e := range p.mNotificationEndpoints {
|
|
endpoints = append(endpoints, e)
|
|
}
|
|
sort.Slice(endpoints, func(i, j int) bool {
|
|
ei, ej := endpoints[i], endpoints[j]
|
|
if ei.kind == ej.kind {
|
|
return ei.MetaName() < ej.MetaName()
|
|
}
|
|
return ei.kind < ej.kind
|
|
})
|
|
return endpoints
|
|
}
|
|
|
|
func (p *Template) notificationRules() []*notificationRule {
|
|
rules := make([]*notificationRule, 0, len(p.mNotificationRules))
|
|
for _, r := range p.mNotificationRules {
|
|
rules = append(rules, r)
|
|
}
|
|
sort.Slice(rules, func(i, j int) bool { return rules[i].MetaName() < rules[j].MetaName() })
|
|
return rules
|
|
}
|
|
|
|
func (p *Template) missingEnvRefs() []string {
|
|
envRefs := make([]string, 0)
|
|
for envRef, matching := range p.mEnv {
|
|
if !matching {
|
|
envRefs = append(envRefs, envRef)
|
|
}
|
|
}
|
|
sort.Strings(envRefs)
|
|
return envRefs
|
|
}
|
|
|
|
func (p *Template) missingSecrets() []string {
|
|
secrets := make([]string, 0, len(p.mSecrets))
|
|
for secret, foundInPlatform := range p.mSecrets {
|
|
if foundInPlatform {
|
|
continue
|
|
}
|
|
secrets = append(secrets, secret)
|
|
}
|
|
return secrets
|
|
}
|
|
|
|
func (p *Template) tasks() []*task {
|
|
tasks := make([]*task, 0, len(p.mTasks))
|
|
for _, t := range p.mTasks {
|
|
tasks = append(tasks, t)
|
|
}
|
|
|
|
sort.Slice(tasks, func(i, j int) bool { return tasks[i].MetaName() < tasks[j].MetaName() })
|
|
|
|
return tasks
|
|
}
|
|
|
|
func (p *Template) telegrafs() []*telegraf {
|
|
teles := make([]*telegraf, 0, len(p.mTelegrafs))
|
|
for _, t := range p.mTelegrafs {
|
|
t.config.Name = t.Name()
|
|
teles = append(teles, t)
|
|
}
|
|
|
|
sort.Slice(teles, func(i, j int) bool { return teles[i].MetaName() < teles[j].MetaName() })
|
|
|
|
return teles
|
|
}
|
|
|
|
func (p *Template) variables() []*variable {
|
|
vars := make([]*variable, 0, len(p.mVariables))
|
|
for _, v := range p.mVariables {
|
|
vars = append(vars, v)
|
|
}
|
|
|
|
sort.Slice(vars, func(i, j int) bool { return vars[i].MetaName() < vars[j].MetaName() })
|
|
|
|
return vars
|
|
}
|
|
|
|
// labelMappings returns the mappings that will be created for
|
|
// valid pairs of labels and resources of which all have IDs.
|
|
// If a resource does not exist yet, a label mapping will not
|
|
// be returned for it.
|
|
func (p *Template) labelMappings() []SummaryLabelMapping {
|
|
labels := p.mLabels
|
|
mappings := make([]SummaryLabelMapping, 0, len(labels))
|
|
for _, l := range labels {
|
|
mappings = append(mappings, l.mappingSummary()...)
|
|
}
|
|
|
|
// sort by res type ASC, then res name ASC, then label name ASC
|
|
sort.Slice(mappings, func(i, j int) bool {
|
|
n, m := mappings[i], mappings[j]
|
|
if n.ResourceType < m.ResourceType {
|
|
return true
|
|
}
|
|
if n.ResourceType > m.ResourceType {
|
|
return false
|
|
}
|
|
if n.ResourceName < m.ResourceName {
|
|
return true
|
|
}
|
|
if n.ResourceName > m.ResourceName {
|
|
return false
|
|
}
|
|
return n.LabelName < m.LabelName
|
|
})
|
|
|
|
return mappings
|
|
}
|
|
|
|
func (p *Template) validResources() error {
|
|
if len(p.Objects) > 0 {
|
|
return nil
|
|
}
|
|
|
|
res := resourceErr{
|
|
Kind: KindPackage.String(),
|
|
RootErrs: []validationErr{{
|
|
Field: "resources",
|
|
Msg: "at least 1 kind must be provided",
|
|
}},
|
|
}
|
|
var err parseErr
|
|
err.append(res)
|
|
return &err
|
|
}
|
|
|
|
func (p *Template) graphResources() error {
|
|
p.mEnv = make(map[string]bool)
|
|
p.mSecrets = make(map[string]bool)
|
|
|
|
graphFns := []func() *parseErr{
|
|
// labels are first, this is to validate associations with other resources
|
|
p.graphLabels,
|
|
p.graphVariables,
|
|
p.graphBuckets,
|
|
p.graphChecks,
|
|
p.graphDashboards,
|
|
p.graphNotificationEndpoints,
|
|
p.graphNotificationRules,
|
|
p.graphTasks,
|
|
p.graphTelegrafs,
|
|
}
|
|
|
|
var pErr parseErr
|
|
for _, fn := range graphFns {
|
|
if err := fn(); err != nil {
|
|
pErr.append(err.Resources...)
|
|
}
|
|
}
|
|
|
|
if len(pErr.Resources) > 0 {
|
|
sort.Slice(pErr.Resources, func(i, j int) bool {
|
|
ir, jr := pErr.Resources[i], pErr.Resources[j]
|
|
return *ir.Idx < *jr.Idx
|
|
})
|
|
return &pErr
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (p *Template) graphBuckets() *parseErr {
|
|
p.mBuckets = make(map[string]*bucket)
|
|
tracker := p.trackNames(true)
|
|
return p.eachResource(KindBucket, func(o Object) []validationErr {
|
|
ident, errs := tracker(o)
|
|
if len(errs) > 0 {
|
|
return errs
|
|
}
|
|
|
|
bkt := &bucket{
|
|
identity: ident,
|
|
Description: o.Spec.stringShort(fieldDescription),
|
|
SchemaType: o.Spec.stringShort(fieldBucketSchemaType),
|
|
}
|
|
if rules, ok := o.Spec[fieldBucketRetentionRules].(retentionRules); ok {
|
|
bkt.RetentionRules = rules
|
|
} else {
|
|
for _, r := range o.Spec.slcResource(fieldBucketRetentionRules) {
|
|
bkt.RetentionRules = append(bkt.RetentionRules, retentionRule{
|
|
Type: r.stringShort(fieldType),
|
|
Seconds: r.intShort(fieldRetentionRulesEverySeconds),
|
|
})
|
|
}
|
|
}
|
|
if schemas, ok := o.Spec[fieldMeasurementSchemas].(measurementSchemas); ok {
|
|
bkt.MeasurementSchemas = schemas
|
|
} else {
|
|
for _, sr := range o.Spec.slcResource(fieldMeasurementSchemas) {
|
|
ms := measurementSchema{Name: sr.stringShort(fieldMeasurementSchemaName)}
|
|
for _, scr := range sr.slcResource(fieldMeasurementSchemaColumns) {
|
|
ms.Columns = append(ms.Columns, measurementColumn{
|
|
Name: scr.stringShort(fieldMeasurementColumnName),
|
|
Type: scr.stringShort(fieldMeasurementColumnType),
|
|
DataType: scr.stringShort(fieldMeasurementColumnDataType),
|
|
})
|
|
}
|
|
bkt.MeasurementSchemas = append(bkt.MeasurementSchemas, ms)
|
|
}
|
|
}
|
|
p.setRefs(bkt.name, bkt.displayName)
|
|
|
|
failures := p.parseNestedLabels(o.Spec, func(l *label) error {
|
|
bkt.labels = append(bkt.labels, l)
|
|
p.mLabels[l.MetaName()].setMapping(bkt, false)
|
|
return nil
|
|
})
|
|
sort.Sort(bkt.labels)
|
|
|
|
p.mBuckets[bkt.MetaName()] = bkt
|
|
|
|
return append(failures, bkt.valid()...)
|
|
})
|
|
}
|
|
|
|
func (p *Template) graphLabels() *parseErr {
|
|
p.mLabels = make(map[string]*label)
|
|
tracker := p.trackNames(true)
|
|
return p.eachResource(KindLabel, func(o Object) []validationErr {
|
|
ident, errs := tracker(o)
|
|
if len(errs) > 0 {
|
|
return errs
|
|
}
|
|
|
|
l := &label{
|
|
identity: ident,
|
|
Color: o.Spec.stringShort(fieldLabelColor),
|
|
Description: o.Spec.stringShort(fieldDescription),
|
|
}
|
|
p.mLabels[l.MetaName()] = l
|
|
p.setRefs(l.name, l.displayName)
|
|
|
|
return l.valid()
|
|
})
|
|
}
|
|
|
|
func (p *Template) graphChecks() *parseErr {
|
|
p.mChecks = make(map[string]*check)
|
|
// todo: what is the business goal wrt having unique names? (currently duplicates are allowed)
|
|
tracker := p.trackNames(false)
|
|
|
|
checkKinds := []struct {
|
|
kind Kind
|
|
checkKind checkKind
|
|
}{
|
|
{kind: KindCheckThreshold, checkKind: checkKindThreshold},
|
|
{kind: KindCheckDeadman, checkKind: checkKindDeadman},
|
|
}
|
|
var pErr parseErr
|
|
for _, checkKind := range checkKinds {
|
|
err := p.eachResource(checkKind.kind, func(o Object) []validationErr {
|
|
ident, errs := tracker(o)
|
|
if len(errs) > 0 {
|
|
return errs
|
|
}
|
|
|
|
ch := &check{
|
|
kind: checkKind.checkKind,
|
|
identity: ident,
|
|
description: o.Spec.stringShort(fieldDescription),
|
|
every: o.Spec.durationShort(fieldEvery),
|
|
level: o.Spec.stringShort(fieldLevel),
|
|
offset: o.Spec.durationShort(fieldOffset),
|
|
query: strings.TrimSpace(o.Spec.stringShort(fieldQuery)),
|
|
reportZero: o.Spec.boolShort(fieldCheckReportZero),
|
|
staleTime: o.Spec.durationShort(fieldCheckStaleTime),
|
|
status: normStr(o.Spec.stringShort(fieldStatus)),
|
|
statusMessage: o.Spec.stringShort(fieldCheckStatusMessageTemplate),
|
|
timeSince: o.Spec.durationShort(fieldCheckTimeSince),
|
|
}
|
|
for _, tagRes := range o.Spec.slcResource(fieldCheckTags) {
|
|
ch.tags = append(ch.tags, struct{ k, v string }{
|
|
k: tagRes.stringShort(fieldKey),
|
|
v: tagRes.stringShort(fieldValue),
|
|
})
|
|
}
|
|
for _, th := range o.Spec.slcResource(fieldCheckThresholds) {
|
|
ch.thresholds = append(ch.thresholds, threshold{
|
|
threshType: thresholdType(normStr(th.stringShort(fieldType))),
|
|
allVals: th.boolShort(fieldCheckAllValues),
|
|
level: strings.TrimSpace(strings.ToUpper(th.stringShort(fieldLevel))),
|
|
max: th.float64Short(fieldMax),
|
|
min: th.float64Short(fieldMin),
|
|
val: th.float64Short(fieldValue),
|
|
})
|
|
}
|
|
|
|
failures := p.parseNestedLabels(o.Spec, func(l *label) error {
|
|
ch.labels = append(ch.labels, l)
|
|
p.mLabels[l.MetaName()].setMapping(ch, false)
|
|
return nil
|
|
})
|
|
sort.Sort(ch.labels)
|
|
|
|
p.mChecks[ch.MetaName()] = ch
|
|
p.setRefs(ch.name, ch.displayName)
|
|
return append(failures, ch.valid()...)
|
|
})
|
|
if err != nil {
|
|
pErr.append(err.Resources...)
|
|
}
|
|
}
|
|
if len(pErr.Resources) > 0 {
|
|
return &pErr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *Template) graphDashboards() *parseErr {
|
|
p.mDashboards = make(map[string]*dashboard)
|
|
tracker := p.trackNames(false)
|
|
return p.eachResource(KindDashboard, func(o Object) []validationErr {
|
|
ident, errs := tracker(o)
|
|
if len(errs) > 0 {
|
|
return errs
|
|
}
|
|
|
|
dash := &dashboard{
|
|
identity: ident,
|
|
Description: o.Spec.stringShort(fieldDescription),
|
|
}
|
|
|
|
failures := p.parseNestedLabels(o.Spec, func(l *label) error {
|
|
dash.labels = append(dash.labels, l)
|
|
p.mLabels[l.MetaName()].setMapping(dash, false)
|
|
return nil
|
|
})
|
|
sort.Sort(dash.labels)
|
|
|
|
for i, cr := range o.Spec.slcResource(fieldDashCharts) {
|
|
ch, fails := p.parseChart(dash.MetaName(), i, cr)
|
|
if fails != nil {
|
|
failures = append(failures,
|
|
objectValidationErr(fieldSpec, validationErr{
|
|
Field: fieldDashCharts,
|
|
Index: intPtr(i),
|
|
Nested: fails,
|
|
}),
|
|
)
|
|
continue
|
|
}
|
|
dash.Charts = append(dash.Charts, ch)
|
|
}
|
|
|
|
p.mDashboards[dash.MetaName()] = dash
|
|
p.setRefs(dash.refs()...)
|
|
|
|
return append(failures, dash.valid()...)
|
|
})
|
|
}
|
|
|
|
func (p *Template) graphNotificationEndpoints() *parseErr {
|
|
p.mNotificationEndpoints = make(map[string]*notificationEndpoint)
|
|
tracker := p.trackNames(true)
|
|
|
|
notificationKinds := []struct {
|
|
kind Kind
|
|
notificationKind notificationEndpointKind
|
|
}{
|
|
{
|
|
kind: KindNotificationEndpointHTTP,
|
|
notificationKind: notificationKindHTTP,
|
|
},
|
|
{
|
|
kind: KindNotificationEndpointPagerDuty,
|
|
notificationKind: notificationKindPagerDuty,
|
|
},
|
|
{
|
|
kind: KindNotificationEndpointSlack,
|
|
notificationKind: notificationKindSlack,
|
|
},
|
|
}
|
|
|
|
var pErr parseErr
|
|
for _, nk := range notificationKinds {
|
|
err := p.eachResource(nk.kind, func(o Object) []validationErr {
|
|
ident, errs := tracker(o)
|
|
if len(errs) > 0 {
|
|
return errs
|
|
}
|
|
|
|
endpoint := ¬ificationEndpoint{
|
|
kind: nk.notificationKind,
|
|
identity: ident,
|
|
description: o.Spec.stringShort(fieldDescription),
|
|
method: strings.TrimSpace(strings.ToUpper(o.Spec.stringShort(fieldNotificationEndpointHTTPMethod))),
|
|
httpType: normStr(o.Spec.stringShort(fieldType)),
|
|
password: o.Spec.references(fieldNotificationEndpointPassword),
|
|
routingKey: o.Spec.references(fieldNotificationEndpointRoutingKey),
|
|
status: normStr(o.Spec.stringShort(fieldStatus)),
|
|
token: o.Spec.references(fieldNotificationEndpointToken),
|
|
url: o.Spec.stringShort(fieldNotificationEndpointURL),
|
|
username: o.Spec.references(fieldNotificationEndpointUsername),
|
|
}
|
|
failures := p.parseNestedLabels(o.Spec, func(l *label) error {
|
|
endpoint.labels = append(endpoint.labels, l)
|
|
p.mLabels[l.MetaName()].setMapping(endpoint, false)
|
|
return nil
|
|
})
|
|
sort.Sort(endpoint.labels)
|
|
|
|
p.setRefs(
|
|
endpoint.name,
|
|
endpoint.displayName,
|
|
endpoint.password,
|
|
endpoint.routingKey,
|
|
endpoint.token,
|
|
endpoint.username,
|
|
)
|
|
|
|
p.mNotificationEndpoints[endpoint.MetaName()] = endpoint
|
|
return append(failures, endpoint.valid()...)
|
|
})
|
|
if err != nil {
|
|
pErr.append(err.Resources...)
|
|
}
|
|
}
|
|
if len(pErr.Resources) > 0 {
|
|
return &pErr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *Template) graphNotificationRules() *parseErr {
|
|
p.mNotificationRules = make(map[string]*notificationRule)
|
|
tracker := p.trackNames(false)
|
|
return p.eachResource(KindNotificationRule, func(o Object) []validationErr {
|
|
ident, errs := tracker(o)
|
|
if len(errs) > 0 {
|
|
return errs
|
|
}
|
|
|
|
rule := ¬ificationRule{
|
|
identity: ident,
|
|
endpointName: p.getRefWithKnownEnvs(o.Spec, fieldNotificationRuleEndpointName),
|
|
description: o.Spec.stringShort(fieldDescription),
|
|
channel: o.Spec.stringShort(fieldNotificationRuleChannel),
|
|
every: o.Spec.durationShort(fieldEvery),
|
|
msgTemplate: o.Spec.stringShort(fieldNotificationRuleMessageTemplate),
|
|
offset: o.Spec.durationShort(fieldOffset),
|
|
status: normStr(o.Spec.stringShort(fieldStatus)),
|
|
}
|
|
|
|
for _, sRule := range o.Spec.slcResource(fieldNotificationRuleStatusRules) {
|
|
rule.statusRules = append(rule.statusRules, struct{ curLvl, prevLvl string }{
|
|
curLvl: strings.TrimSpace(strings.ToUpper(sRule.stringShort(fieldNotificationRuleCurrentLevel))),
|
|
prevLvl: strings.TrimSpace(strings.ToUpper(sRule.stringShort(fieldNotificationRulePreviousLevel))),
|
|
})
|
|
}
|
|
|
|
for _, tRule := range o.Spec.slcResource(fieldNotificationRuleTagRules) {
|
|
rule.tagRules = append(rule.tagRules, struct{ k, v, op string }{
|
|
k: tRule.stringShort(fieldKey),
|
|
v: tRule.stringShort(fieldValue),
|
|
op: normStr(tRule.stringShort(fieldOperator)),
|
|
})
|
|
}
|
|
|
|
rule.associatedEndpoint = p.mNotificationEndpoints[rule.endpointName.String()]
|
|
|
|
failures := p.parseNestedLabels(o.Spec, func(l *label) error {
|
|
rule.labels = append(rule.labels, l)
|
|
p.mLabels[l.MetaName()].setMapping(rule, false)
|
|
return nil
|
|
})
|
|
sort.Sort(rule.labels)
|
|
|
|
p.mNotificationRules[rule.MetaName()] = rule
|
|
p.setRefs(rule.name, rule.displayName, rule.endpointName)
|
|
return append(failures, rule.valid()...)
|
|
})
|
|
}
|
|
|
|
func (p *Template) graphTasks() *parseErr {
|
|
p.mTasks = make(map[string]*task)
|
|
tracker := p.trackNames(false)
|
|
return p.eachResource(KindTask, func(o Object) []validationErr {
|
|
ident, errs := tracker(o)
|
|
if len(errs) > 0 {
|
|
return errs
|
|
}
|
|
|
|
t := &task{
|
|
identity: ident,
|
|
cron: o.Spec.stringShort(fieldTaskCron),
|
|
description: o.Spec.stringShort(fieldDescription),
|
|
every: o.Spec.durationShort(fieldEvery),
|
|
offset: o.Spec.durationShort(fieldOffset),
|
|
status: normStr(o.Spec.stringShort(fieldStatus)),
|
|
}
|
|
|
|
prefix := fmt.Sprintf("tasks[%s].spec", t.MetaName())
|
|
params := o.Spec.slcResource(fieldParams)
|
|
task := o.Spec.slcResource("task")
|
|
|
|
var (
|
|
err error
|
|
failures []validationErr
|
|
)
|
|
|
|
t.query, err = p.parseQuery(prefix, o.Spec.stringShort(fieldQuery), params, task)
|
|
if err != nil {
|
|
failures = append(failures, validationErr{
|
|
Field: fieldQuery,
|
|
Msg: err.Error(),
|
|
})
|
|
}
|
|
|
|
if o.APIVersion == APIVersion2 {
|
|
for _, ref := range t.query.task {
|
|
switch ref.EnvRef {
|
|
case prefix + ".task.name", prefix + ".params.name":
|
|
t.displayName = ref
|
|
case prefix + ".task.every":
|
|
every, ok := ref.defaultVal.(time.Duration)
|
|
if ok {
|
|
t.every = every
|
|
} else {
|
|
failures = append(failures, validationErr{
|
|
Field: fieldTask,
|
|
Msg: "field every is not duration",
|
|
})
|
|
}
|
|
case prefix + ".task.offset":
|
|
offset, ok := ref.defaultVal.(time.Duration)
|
|
if ok {
|
|
t.offset = offset
|
|
} else {
|
|
failures = append(failures, validationErr{
|
|
Field: fieldTask,
|
|
Msg: "field every is not duration",
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
failures = append(failures, p.parseNestedLabels(o.Spec, func(l *label) error {
|
|
t.labels = append(t.labels, l)
|
|
p.mLabels[l.MetaName()].setMapping(t, false)
|
|
return nil
|
|
})...)
|
|
sort.Sort(t.labels)
|
|
|
|
p.mTasks[t.MetaName()] = t
|
|
|
|
p.setRefs(t.refs()...)
|
|
return append(failures, t.valid()...)
|
|
})
|
|
}
|
|
|
|
func (p *Template) graphTelegrafs() *parseErr {
|
|
p.mTelegrafs = make(map[string]*telegraf)
|
|
tracker := p.trackNames(false)
|
|
return p.eachResource(KindTelegraf, func(o Object) []validationErr {
|
|
ident, errs := tracker(o)
|
|
if len(errs) > 0 {
|
|
return errs
|
|
}
|
|
|
|
tele := &telegraf{
|
|
identity: ident,
|
|
}
|
|
tele.config.Config = o.Spec.stringShort(fieldTelegrafConfig)
|
|
tele.config.Description = o.Spec.stringShort(fieldDescription)
|
|
|
|
failures := p.parseNestedLabels(o.Spec, func(l *label) error {
|
|
tele.labels = append(tele.labels, l)
|
|
p.mLabels[l.MetaName()].setMapping(tele, false)
|
|
return nil
|
|
})
|
|
sort.Sort(tele.labels)
|
|
|
|
p.mTelegrafs[tele.MetaName()] = tele
|
|
p.setRefs(tele.name, tele.displayName)
|
|
|
|
return append(failures, tele.valid()...)
|
|
})
|
|
}
|
|
|
|
func (p *Template) graphVariables() *parseErr {
|
|
p.mVariables = make(map[string]*variable)
|
|
tracker := p.trackNames(true)
|
|
return p.eachResource(KindVariable, func(o Object) []validationErr {
|
|
ident, errs := tracker(o)
|
|
if len(errs) > 0 {
|
|
return errs
|
|
}
|
|
|
|
newVar := &variable{
|
|
identity: ident,
|
|
Description: o.Spec.stringShort(fieldDescription),
|
|
Type: normStr(o.Spec.stringShort(fieldType)),
|
|
Query: strings.TrimSpace(o.Spec.stringShort(fieldQuery)),
|
|
Language: normStr(o.Spec.stringShort(fieldLanguage)),
|
|
ConstValues: o.Spec.slcStr(fieldValues),
|
|
MapValues: o.Spec.mapStrStr(fieldValues),
|
|
}
|
|
|
|
if iSelected, ok := o.Spec[fieldVariableSelected].([]interface{}); ok {
|
|
for _, res := range iSelected {
|
|
newVar.selected = append(newVar.selected, ifaceToReference(res))
|
|
}
|
|
}
|
|
|
|
failures := p.parseNestedLabels(o.Spec, func(l *label) error {
|
|
newVar.labels = append(newVar.labels, l)
|
|
p.mLabels[l.MetaName()].setMapping(newVar, false)
|
|
return nil
|
|
})
|
|
sort.Sort(newVar.labels)
|
|
|
|
p.mVariables[newVar.MetaName()] = newVar
|
|
p.setRefs(newVar.name, newVar.displayName)
|
|
p.setRefs(newVar.selected...)
|
|
|
|
return append(failures, newVar.valid()...)
|
|
})
|
|
}
|
|
|
|
func (p *Template) eachResource(resourceKind Kind, fn func(o Object) []validationErr) *parseErr {
|
|
var pErr parseErr
|
|
for i, k := range p.Objects {
|
|
if err := k.Kind.OK(); err != nil {
|
|
pErr.append(resourceErr{
|
|
Kind: k.Kind.String(),
|
|
Idx: intPtr(i),
|
|
ValidationErrs: []validationErr{
|
|
{
|
|
Field: fieldKind,
|
|
Msg: err.Error(),
|
|
},
|
|
},
|
|
})
|
|
continue
|
|
}
|
|
if !k.Kind.is(resourceKind) {
|
|
continue
|
|
}
|
|
|
|
if k.APIVersion != APIVersion && k.APIVersion != APIVersion2 {
|
|
pErr.append(resourceErr{
|
|
Kind: k.Kind.String(),
|
|
Idx: intPtr(i),
|
|
ValidationErrs: []validationErr{
|
|
{
|
|
Field: fieldAPIVersion,
|
|
Msg: fmt.Sprintf("invalid API version provided %q; must be 1 in [%s, %s]", k.APIVersion, APIVersion, APIVersion2),
|
|
},
|
|
},
|
|
})
|
|
continue
|
|
}
|
|
|
|
if errs := isDNS1123Label(k.Name()); len(errs) > 0 {
|
|
pErr.append(resourceErr{
|
|
Kind: k.Kind.String(),
|
|
Idx: intPtr(i),
|
|
ValidationErrs: []validationErr{
|
|
objectValidationErr(fieldMetadata, validationErr{
|
|
Field: fieldName,
|
|
Msg: fmt.Sprintf("name %q is invalid; %s", k.Name(), strings.Join(errs, "; ")),
|
|
}),
|
|
},
|
|
})
|
|
continue
|
|
}
|
|
|
|
if failures := fn(k); failures != nil {
|
|
err := resourceErr{
|
|
Kind: resourceKind.String(),
|
|
Idx: intPtr(i),
|
|
}
|
|
for _, f := range failures {
|
|
vErr := validationErr{
|
|
Field: f.Field,
|
|
Msg: f.Msg,
|
|
Index: f.Index,
|
|
Nested: f.Nested,
|
|
}
|
|
if vErr.Field == "associations" {
|
|
err.AssociationErrs = append(err.AssociationErrs, vErr)
|
|
continue
|
|
}
|
|
err.ValidationErrs = append(err.ValidationErrs, vErr)
|
|
}
|
|
pErr.append(err)
|
|
}
|
|
}
|
|
|
|
if len(pErr.Resources) > 0 {
|
|
return &pErr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *Template) parseNestedLabels(r Resource, fn func(lb *label) error) []validationErr {
|
|
nestedLabels := make(map[string]*label)
|
|
|
|
var failures []validationErr
|
|
for i, nr := range r.slcResource(fieldAssociations) {
|
|
fail := p.parseNestedLabel(nr, func(l *label) error {
|
|
if _, ok := nestedLabels[l.Name()]; ok {
|
|
return fmt.Errorf("duplicate nested label: %q", l.Name())
|
|
}
|
|
nestedLabels[l.Name()] = l
|
|
|
|
return fn(l)
|
|
})
|
|
if fail != nil {
|
|
fail.Index = intPtr(i)
|
|
failures = append(failures, *fail)
|
|
}
|
|
}
|
|
|
|
return failures
|
|
}
|
|
|
|
func (p *Template) parseNestedLabel(nr Resource, fn func(lb *label) error) *validationErr {
|
|
k, err := nr.kind()
|
|
if err != nil {
|
|
return &validationErr{
|
|
Field: fieldAssociations,
|
|
Nested: []validationErr{
|
|
{
|
|
Field: fieldKind,
|
|
Msg: err.Error(),
|
|
},
|
|
},
|
|
}
|
|
}
|
|
if !k.is(KindLabel) {
|
|
return nil
|
|
}
|
|
|
|
nameRef := p.getRefWithKnownEnvs(nr, fieldName)
|
|
lb, found := p.mLabels[nameRef.String()]
|
|
if !found {
|
|
return &validationErr{
|
|
Field: fieldAssociations,
|
|
Msg: fmt.Sprintf("label %q does not exist in pkg", nr.Name()),
|
|
}
|
|
}
|
|
|
|
if err := fn(lb); err != nil {
|
|
return &validationErr{
|
|
Field: fieldAssociations,
|
|
Msg: err.Error(),
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *Template) trackNames(resourceUniqueByName bool) func(Object) (identity, []validationErr) {
|
|
mPkgNames := make(map[string]bool)
|
|
uniqNames := make(map[string]bool)
|
|
return func(o Object) (identity, []validationErr) {
|
|
nameRef := p.getRefWithKnownEnvs(o.Metadata, fieldName)
|
|
if mPkgNames[nameRef.String()] {
|
|
return identity{}, []validationErr{
|
|
objectValidationErr(fieldMetadata, validationErr{
|
|
Field: fieldName,
|
|
Msg: "duplicate name: " + nameRef.String(),
|
|
}),
|
|
}
|
|
}
|
|
mPkgNames[nameRef.String()] = true
|
|
|
|
displayNameRef := p.getRefWithKnownEnvs(o.Spec, fieldName)
|
|
identity := identity{
|
|
name: nameRef,
|
|
displayName: displayNameRef,
|
|
}
|
|
if !resourceUniqueByName {
|
|
return identity, nil
|
|
}
|
|
|
|
name := identity.Name()
|
|
if uniqNames[name] {
|
|
return identity, []validationErr{
|
|
objectValidationErr(fieldSpec, validationErr{
|
|
Field: fieldName,
|
|
Msg: "duplicate name: " + nameRef.String(),
|
|
}),
|
|
}
|
|
}
|
|
uniqNames[name] = true
|
|
|
|
return identity, nil
|
|
}
|
|
}
|
|
|
|
func (p *Template) getRefWithKnownEnvs(r Resource, field string) *references {
|
|
nameRef := r.references(field)
|
|
if v, ok := p.mEnvVals[nameRef.EnvRef]; ok {
|
|
nameRef.val = v
|
|
}
|
|
return nameRef
|
|
}
|
|
|
|
func (p *Template) setRefs(refs ...*references) {
|
|
for _, ref := range refs {
|
|
if ref.Secret != "" {
|
|
p.mSecrets[ref.Secret] = false
|
|
}
|
|
if ref.EnvRef != "" {
|
|
p.mEnv[ref.EnvRef] = p.mEnvVals[ref.EnvRef] != nil
|
|
}
|
|
}
|
|
}
|
|
|
|
func parseAxis(ra Resource, domain []float64) *axis {
|
|
return &axis{
|
|
Base: ra.stringShort(fieldAxisBase),
|
|
Label: ra.stringShort(fieldAxisLabel),
|
|
Name: ra.Name(),
|
|
Prefix: ra.stringShort(fieldPrefix),
|
|
Scale: ra.stringShort(fieldAxisScale),
|
|
Suffix: ra.stringShort(fieldSuffix),
|
|
Domain: domain,
|
|
}
|
|
}
|
|
|
|
func parseColor(rc Resource) *color {
|
|
return &color{
|
|
ID: rc.stringShort("id"),
|
|
Name: rc.Name(),
|
|
Type: rc.stringShort(fieldType),
|
|
Hex: rc.stringShort(fieldColorHex),
|
|
Value: flt64Ptr(rc.float64Short(fieldValue)),
|
|
}
|
|
}
|
|
|
|
func (p *Template) parseChart(dashMetaName string, chartIdx int, r Resource) (*chart, []validationErr) {
|
|
ck, err := r.chartKind()
|
|
if err != nil {
|
|
return nil, []validationErr{{
|
|
Field: fieldKind,
|
|
Msg: err.Error(),
|
|
}}
|
|
}
|
|
|
|
c := chart{
|
|
Kind: ck,
|
|
Name: r.Name(),
|
|
BinSize: r.intShort(fieldChartBinSize),
|
|
BinCount: r.intShort(fieldChartBinCount),
|
|
Geom: r.stringShort(fieldChartGeom),
|
|
Height: r.intShort(fieldChartHeight),
|
|
Note: r.stringShort(fieldChartNote),
|
|
NoteOnEmpty: r.boolShort(fieldChartNoteOnEmpty),
|
|
Position: r.stringShort(fieldChartPosition),
|
|
Prefix: r.stringShort(fieldPrefix),
|
|
Shade: r.boolShort(fieldChartShade),
|
|
HoverDimension: r.stringShort(fieldChartHoverDimension),
|
|
Suffix: r.stringShort(fieldSuffix),
|
|
TickPrefix: r.stringShort(fieldChartTickPrefix),
|
|
TickSuffix: r.stringShort(fieldChartTickSuffix),
|
|
TimeFormat: r.stringShort(fieldChartTimeFormat),
|
|
Width: r.intShort(fieldChartWidth),
|
|
XCol: r.stringShort(fieldChartXCol),
|
|
GenerateXAxisTicks: r.slcStr(fieldChartGenerateXAxisTicks),
|
|
XTotalTicks: r.intShort(fieldChartXTotalTicks),
|
|
XTickStart: r.float64Short(fieldChartXTickStart),
|
|
XTickStep: r.float64Short(fieldChartXTickStep),
|
|
YCol: r.stringShort(fieldChartYCol),
|
|
GenerateYAxisTicks: r.slcStr(fieldChartGenerateYAxisTicks),
|
|
YTotalTicks: r.intShort(fieldChartYTotalTicks),
|
|
YTickStart: r.float64Short(fieldChartYTickStart),
|
|
YTickStep: r.float64Short(fieldChartYTickStep),
|
|
XPos: r.intShort(fieldChartXPos),
|
|
YPos: r.intShort(fieldChartYPos),
|
|
FillColumns: r.slcStr(fieldChartFillColumns),
|
|
YLabelColumnSeparator: r.stringShort(fieldChartYLabelColumnSeparator),
|
|
YLabelColumns: r.slcStr(fieldChartYLabelColumns),
|
|
YSeriesColumns: r.slcStr(fieldChartYSeriesColumns),
|
|
UpperColumn: r.stringShort(fieldChartUpperColumn),
|
|
MainColumn: r.stringShort(fieldChartMainColumn),
|
|
LowerColumn: r.stringShort(fieldChartLowerColumn),
|
|
LegendColorizeRows: r.boolShort(fieldChartLegendColorizeRows),
|
|
LegendHide: r.boolShort(fieldChartLegendHide),
|
|
LegendOpacity: r.float64Short(fieldChartLegendOpacity),
|
|
LegendOrientationThreshold: r.intShort(fieldChartLegendOrientationThreshold),
|
|
Zoom: r.float64Short(fieldChartGeoZoom),
|
|
Center: center{Lat: r.float64Short(fieldChartGeoCenterLat), Lon: r.float64Short(fieldChartGeoCenterLon)},
|
|
MapStyle: r.stringShort(fieldChartGeoMapStyle),
|
|
AllowPanAndZoom: r.boolShort(fieldChartGeoAllowPanAndZoom),
|
|
DetectCoordinateFields: r.boolShort(fieldChartGeoDetectCoordinateFields),
|
|
}
|
|
|
|
if presStaticLeg, ok := r[fieldChartStaticLegend].(StaticLegend); ok {
|
|
c.StaticLegend = presStaticLeg
|
|
} else {
|
|
if staticLeg, ok := ifaceToResource(r[fieldChartStaticLegend]); ok {
|
|
c.StaticLegend.ColorizeRows = staticLeg.boolShort(fieldChartStaticLegendColorizeRows)
|
|
c.StaticLegend.HeightRatio = staticLeg.float64Short(fieldChartStaticLegendHeightRatio)
|
|
c.StaticLegend.Show = staticLeg.boolShort(fieldChartStaticLegendShow)
|
|
c.StaticLegend.Opacity = staticLeg.float64Short(fieldChartStaticLegendOpacity)
|
|
c.StaticLegend.OrientationThreshold = staticLeg.intShort(fieldChartStaticLegendOrientationThreshold)
|
|
c.StaticLegend.ValueAxis = staticLeg.stringShort(fieldChartStaticLegendValueAxis)
|
|
c.StaticLegend.WidthRatio = staticLeg.float64Short(fieldChartStaticLegendWidthRatio)
|
|
}
|
|
}
|
|
|
|
if dp, ok := r.int(fieldChartDecimalPlaces); ok {
|
|
c.EnforceDecimals = true
|
|
c.DecimalPlaces = dp
|
|
}
|
|
|
|
var failures []validationErr
|
|
if presentQueries, ok := r[fieldChartQueries].(queries); ok {
|
|
c.Queries = presentQueries
|
|
} else {
|
|
q, vErrs := p.parseChartQueries(dashMetaName, chartIdx, r.slcResource(fieldChartQueries))
|
|
if len(vErrs) > 0 {
|
|
failures = append(failures, validationErr{
|
|
Field: "queries",
|
|
Nested: vErrs,
|
|
})
|
|
}
|
|
c.Queries = q
|
|
}
|
|
|
|
if presentColors, ok := r[fieldChartColors].(colors); ok {
|
|
c.Colors = presentColors
|
|
} else {
|
|
for _, rc := range r.slcResource(fieldChartColors) {
|
|
c.Colors = append(c.Colors, parseColor(rc))
|
|
}
|
|
}
|
|
|
|
if presAxes, ok := r[fieldChartAxes].(axes); ok {
|
|
c.Axes = presAxes
|
|
} else {
|
|
for _, ra := range r.slcResource(fieldChartAxes) {
|
|
domain := []float64{}
|
|
|
|
if _, ok := ra[fieldChartDomain]; ok {
|
|
for _, str := range ra.slcStr(fieldChartDomain) {
|
|
val, err := strconv.ParseFloat(str, 64)
|
|
if err != nil {
|
|
failures = append(failures, validationErr{
|
|
Field: "axes",
|
|
Msg: err.Error(),
|
|
})
|
|
}
|
|
domain = append(domain, val)
|
|
}
|
|
}
|
|
|
|
c.Axes = append(c.Axes, *parseAxis(ra, domain))
|
|
}
|
|
}
|
|
|
|
if presentGeoLayers, ok := r[fieldChartGeoLayers].(geoLayers); ok {
|
|
c.GeoLayers = presentGeoLayers
|
|
} else {
|
|
parseGeoAxis := func(r Resource, field string) *axis {
|
|
if axis, ok := r[field].(*axis); ok {
|
|
return axis
|
|
} else {
|
|
if leg, ok := ifaceToResource(r[field]); ok {
|
|
return parseAxis(leg, nil)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
for _, rl := range r.slcResource(fieldChartGeoLayers) {
|
|
gl := geoLayer{
|
|
Type: rl.stringShort(fieldChartGeoLayerType),
|
|
RadiusField: rl.stringShort(fieldChartGeoLayerRadiusField),
|
|
ColorField: rl.stringShort(fieldChartGeoLayerColorField),
|
|
IntensityField: rl.stringShort(fieldChartGeoLayerIntensityField),
|
|
Radius: int32(rl.intShort(fieldChartGeoLayerRadius)),
|
|
Blur: int32(rl.intShort(fieldChartGeoLayerBlur)),
|
|
RadiusDimension: parseGeoAxis(rl, fieldChartGeoLayerRadiusDimension),
|
|
ColorDimension: parseGeoAxis(rl, fieldChartGeoLayerColorDimension),
|
|
IntensityDimension: parseGeoAxis(rl, fieldChartGeoLayerIntensityDimension),
|
|
InterpolateColors: rl.boolShort(fieldChartGeoLayerInterpolateColors),
|
|
TrackWidth: int32(rl.intShort(fieldChartGeoLayerTrackWidth)),
|
|
Speed: int32(rl.intShort(fieldChartGeoLayerSpeed)),
|
|
RandomColors: rl.boolShort(fieldChartGeoLayerRandomColors),
|
|
IsClustered: rl.boolShort(fieldChartGeoLayerIsClustered),
|
|
}
|
|
if presentColors, ok := rl[fieldChartGeoLayerViewColors].(colors); ok {
|
|
gl.ViewColors = presentColors
|
|
} else {
|
|
for _, rc := range rl.slcResource(fieldChartGeoLayerViewColors) {
|
|
gl.ViewColors = append(gl.ViewColors, parseColor(rc))
|
|
}
|
|
}
|
|
c.GeoLayers = append(c.GeoLayers, &gl)
|
|
}
|
|
}
|
|
|
|
if tableOptsRes, ok := ifaceToResource(r[fieldChartTableOptions]); ok {
|
|
c.TableOptions = tableOptions{
|
|
VerticalTimeAxis: tableOptsRes.boolShort(fieldChartTableOptionVerticalTimeAxis),
|
|
SortByField: tableOptsRes.stringShort(fieldChartTableOptionSortBy),
|
|
Wrapping: tableOptsRes.stringShort(fieldChartTableOptionWrapping),
|
|
FixFirstColumn: tableOptsRes.boolShort(fieldChartTableOptionFixFirstColumn),
|
|
}
|
|
}
|
|
|
|
for _, fieldOptRes := range r.slcResource(fieldChartFieldOptions) {
|
|
c.FieldOptions = append(c.FieldOptions, fieldOption{
|
|
FieldName: fieldOptRes.stringShort(fieldChartFieldOptionFieldName),
|
|
DisplayName: fieldOptRes.stringShort(fieldChartFieldOptionDisplayName),
|
|
Visible: fieldOptRes.boolShort(fieldChartFieldOptionVisible),
|
|
})
|
|
}
|
|
|
|
if failures = append(failures, c.validProperties()...); len(failures) > 0 {
|
|
return nil, failures
|
|
}
|
|
|
|
return &c, nil
|
|
}
|
|
|
|
func (p *Template) parseChartQueries(dashMetaName string, chartIdx int, resources []Resource) (queries, []validationErr) {
|
|
var (
|
|
q queries
|
|
vErrs []validationErr
|
|
)
|
|
for i, rq := range resources {
|
|
source := rq.stringShort(fieldQuery)
|
|
if source == "" {
|
|
continue
|
|
}
|
|
prefix := fmt.Sprintf("dashboards[%s].spec.charts[%d].queries[%d]", dashMetaName, chartIdx, i)
|
|
qq, err := p.parseQuery(prefix, source, rq.slcResource(fieldParams), nil)
|
|
if err != nil {
|
|
vErrs = append(vErrs, validationErr{
|
|
Field: "query",
|
|
Index: intPtr(i),
|
|
Msg: err.Error(),
|
|
})
|
|
}
|
|
q = append(q, qq)
|
|
}
|
|
return q, vErrs
|
|
}
|
|
|
|
func (p *Template) parseQuery(prefix, source string, params, task []Resource) (query, error) {
|
|
files := parser.ParseSource(source).Files
|
|
if len(files) != 1 {
|
|
return query{}, influxErr(errors2.EInvalid, "invalid query source")
|
|
}
|
|
|
|
q := query{
|
|
Query: strings.TrimSpace(source),
|
|
}
|
|
|
|
mParams := make(map[string]*references)
|
|
tParams := make(map[string]*references)
|
|
|
|
paramsOpt, paramsErr := edit.GetOption(files[0], "params")
|
|
taskOpt, taskErr := edit.GetOption(files[0], "task")
|
|
if paramsErr != nil && taskErr != nil {
|
|
return q, nil
|
|
}
|
|
|
|
if paramsErr == nil {
|
|
obj, ok := paramsOpt.(*ast.ObjectExpression)
|
|
if ok {
|
|
for _, p := range obj.Properties {
|
|
sl, ok := p.Key.(*ast.Identifier)
|
|
if !ok {
|
|
continue
|
|
}
|
|
|
|
mParams[sl.Name] = &references{
|
|
EnvRef: sl.Name,
|
|
defaultVal: valFromExpr(p.Value),
|
|
valType: p.Value.Type(),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if taskErr == nil {
|
|
tobj, ok := taskOpt.(*ast.ObjectExpression)
|
|
if ok {
|
|
for _, p := range tobj.Properties {
|
|
sl, ok := p.Key.(*ast.Identifier)
|
|
if !ok {
|
|
continue
|
|
}
|
|
|
|
tParams[sl.Name] = &references{
|
|
EnvRef: sl.Name,
|
|
defaultVal: valFromExpr(p.Value),
|
|
valType: p.Value.Type(),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// override defaults here maybe?
|
|
for _, pr := range params {
|
|
field := pr.stringShort(fieldKey)
|
|
if field == "" {
|
|
continue
|
|
}
|
|
|
|
if _, ok := mParams[field]; !ok {
|
|
mParams[field] = &references{EnvRef: field}
|
|
}
|
|
if def, ok := pr[fieldDefault]; ok {
|
|
mParams[field].defaultVal = def
|
|
}
|
|
if valtype, ok := pr.string(fieldType); ok {
|
|
mParams[field].valType = valtype
|
|
}
|
|
}
|
|
|
|
var err error
|
|
for _, pr := range task {
|
|
field := pr.stringShort(fieldKey)
|
|
if field == "" {
|
|
continue
|
|
}
|
|
|
|
if _, ok := tParams[field]; !ok {
|
|
tParams[field] = &references{EnvRef: field}
|
|
}
|
|
|
|
if valtype, ok := pr.string(fieldType); ok {
|
|
tParams[field].valType = valtype
|
|
}
|
|
|
|
if def, ok := pr[fieldDefault]; ok {
|
|
switch tParams[field].valType {
|
|
case "duration":
|
|
switch defDur := def.(type) {
|
|
case string:
|
|
tParams[field].defaultVal, err = time.ParseDuration(defDur)
|
|
if err != nil {
|
|
return query{}, influxErr(errors2.EInvalid, err.Error())
|
|
}
|
|
case time.Duration:
|
|
tParams[field].defaultVal = defDur
|
|
}
|
|
default:
|
|
tParams[field].defaultVal = def
|
|
}
|
|
}
|
|
}
|
|
|
|
for _, ref := range mParams {
|
|
envRef := fmt.Sprintf("%s.params.%s", prefix, ref.EnvRef)
|
|
q.params = append(q.params, &references{
|
|
EnvRef: envRef,
|
|
defaultVal: ref.defaultVal,
|
|
val: p.mEnvVals[envRef],
|
|
valType: ref.valType,
|
|
})
|
|
}
|
|
|
|
for _, ref := range tParams {
|
|
envRef := fmt.Sprintf("%s.task.%s", prefix, ref.EnvRef)
|
|
q.task = append(q.task, &references{
|
|
EnvRef: envRef,
|
|
defaultVal: ref.defaultVal,
|
|
val: p.mEnvVals[envRef],
|
|
valType: ref.valType,
|
|
})
|
|
}
|
|
return q, nil
|
|
}
|
|
|
|
func valFromExpr(p ast.Expression) interface{} {
|
|
switch literal := p.(type) {
|
|
case *ast.CallExpression:
|
|
sl, ok := literal.Callee.(*ast.Identifier)
|
|
if ok && sl.Name == "now" {
|
|
return "now()"
|
|
}
|
|
return nil
|
|
case *ast.DateTimeLiteral:
|
|
return ast.DateTimeFromLiteral(literal)
|
|
case *ast.FloatLiteral:
|
|
return ast.FloatFromLiteral(literal)
|
|
case *ast.IntegerLiteral:
|
|
return ast.IntegerFromLiteral(literal)
|
|
case *ast.DurationLiteral:
|
|
dur, _ := ast.DurationFrom(literal, time.Time{})
|
|
return dur
|
|
case *ast.StringLiteral:
|
|
return ast.StringFromLiteral(literal)
|
|
case *ast.UnaryExpression:
|
|
// a signed duration is represented by a UnaryExpression.
|
|
// it is the only unary expression allowed.
|
|
v := valFromExpr(literal.Argument)
|
|
if dur, ok := v.(time.Duration); ok {
|
|
switch literal.Operator {
|
|
case ast.SubtractionOperator:
|
|
return "-" + dur.String()
|
|
}
|
|
}
|
|
return v
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
|
|
// dns1123LabelMaxLength is a label's max length in DNS (RFC 1123)
|
|
const dns1123LabelMaxLength int = 63
|
|
|
|
const dns1123LabelFmt string = "[a-z0-9]([-a-z0-9]*[a-z0-9])?"
|
|
const dns1123LabelErrMsg string = "a DNS-1123 label must consist of lower case alphanumeric characters or '-', and must start and end with an alphanumeric character"
|
|
|
|
var dns1123LabelRegexp = regexp.MustCompile("^" + dns1123LabelFmt + "$")
|
|
|
|
// isDNS1123Label tests for a string that conforms to the definition of a label in
|
|
// DNS (RFC 1123).
|
|
func isDNS1123Label(value string) []string {
|
|
var errs []string
|
|
if len(value) > dns1123LabelMaxLength {
|
|
errs = append(errs, fmt.Sprintf("must be no more than %d characters", dns1123LabelMaxLength))
|
|
}
|
|
if !dns1123LabelRegexp.MatchString(value) {
|
|
errs = append(errs, regexError(dns1123LabelErrMsg, dns1123LabelFmt, "my-name", "123-abc"))
|
|
}
|
|
return errs
|
|
}
|
|
|
|
// regexError returns a string explanation of a regex validation failure.
|
|
func regexError(msg string, fmt string, examples ...string) string {
|
|
if len(examples) == 0 {
|
|
return msg + " (regex used for validation is '" + fmt + "')"
|
|
}
|
|
msg += " (e.g. "
|
|
for i := range examples {
|
|
if i > 0 {
|
|
msg += " or "
|
|
}
|
|
msg += "'" + examples[i] + "', "
|
|
}
|
|
msg += "regex used for validation is '" + fmt + "')"
|
|
return msg
|
|
}
|
|
|
|
// Resource is a pkger Resource kind. It can be one of any of
|
|
// available kinds that are supported.
|
|
type Resource map[string]interface{}
|
|
|
|
// Name returns the name of the resource.
|
|
func (r Resource) Name() string {
|
|
return strings.TrimSpace(r.stringShort(fieldName))
|
|
}
|
|
|
|
func (r Resource) kind() (Kind, error) {
|
|
if k, ok := r[fieldKind].(Kind); ok {
|
|
return k, k.OK()
|
|
}
|
|
|
|
resKind, ok := r.string(fieldKind)
|
|
if !ok {
|
|
return KindUnknown, errors.New("no kind provided")
|
|
}
|
|
|
|
k := Kind(resKind)
|
|
return k, k.OK()
|
|
}
|
|
|
|
func (r Resource) chartKind() (chartKind, error) {
|
|
ck, _ := r.kind()
|
|
chartKind := chartKind(normStr(string(ck)))
|
|
if !chartKind.ok() {
|
|
return chartKindUnknown, errors.New("invalid chart kind provided: " + string(chartKind))
|
|
}
|
|
return chartKind, nil
|
|
}
|
|
|
|
func (r Resource) bool(key string) (bool, bool) {
|
|
b, ok := r[key].(bool)
|
|
return b, ok
|
|
}
|
|
|
|
func (r Resource) boolShort(key string) bool {
|
|
b, _ := r.bool(key)
|
|
return b
|
|
}
|
|
|
|
func (r Resource) duration(key string) (time.Duration, bool) {
|
|
astDur, err := options.ParseSignedDuration(r.stringShort(key))
|
|
if err != nil {
|
|
return time.Duration(0), false
|
|
}
|
|
|
|
dur, err := ast.DurationFrom(astDur, time.Time{})
|
|
return dur, err == nil
|
|
}
|
|
|
|
func (r Resource) durationShort(key string) time.Duration {
|
|
dur, _ := r.duration(key)
|
|
return dur
|
|
}
|
|
|
|
func (r Resource) float64(key string) (float64, bool) {
|
|
f, ok := r[key].(float64)
|
|
if ok {
|
|
return f, true
|
|
}
|
|
|
|
i, ok := r[key].(int)
|
|
if ok {
|
|
return float64(i), true
|
|
}
|
|
return 0, false
|
|
}
|
|
|
|
func (r Resource) float64Short(key string) float64 {
|
|
f, _ := r.float64(key)
|
|
return f
|
|
}
|
|
|
|
func (r Resource) int(key string) (int, bool) {
|
|
i, ok := r[key].(int)
|
|
if ok {
|
|
return i, true
|
|
}
|
|
|
|
f, ok := r[key].(float64)
|
|
if ok {
|
|
return int(f), true
|
|
}
|
|
return 0, false
|
|
}
|
|
|
|
func (r Resource) intShort(key string) int {
|
|
i, _ := r.int(key)
|
|
return i
|
|
}
|
|
|
|
func (r Resource) references(key string) *references {
|
|
v, ok := r[key]
|
|
if !ok {
|
|
return &references{}
|
|
}
|
|
return ifaceToReference(v)
|
|
}
|
|
|
|
func (r Resource) string(key string) (string, bool) {
|
|
return ifaceToStr(r[key])
|
|
}
|
|
|
|
func (r Resource) stringShort(key string) string {
|
|
s, _ := r.string(key)
|
|
return s
|
|
}
|
|
|
|
func (r Resource) slcResource(key string) []Resource {
|
|
v, ok := r[key]
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
if resources, ok := v.([]Resource); ok {
|
|
return resources
|
|
}
|
|
|
|
iFaceSlc, ok := v.([]interface{})
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
var newResources []Resource
|
|
for _, iFace := range iFaceSlc {
|
|
r, ok := ifaceToResource(iFace)
|
|
if !ok {
|
|
continue
|
|
}
|
|
newResources = append(newResources, r)
|
|
}
|
|
|
|
return newResources
|
|
}
|
|
|
|
func (r Resource) slcStr(key string) []string {
|
|
v, ok := r[key]
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
if strSlc, ok := v.([]string); ok {
|
|
return strSlc
|
|
}
|
|
|
|
iFaceSlc, ok := v.([]interface{})
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
var out []string
|
|
for _, iface := range iFaceSlc {
|
|
s, ok := ifaceToStr(iface)
|
|
if !ok {
|
|
continue
|
|
}
|
|
out = append(out, s)
|
|
}
|
|
|
|
return out
|
|
}
|
|
|
|
func (r Resource) mapStrStr(key string) map[string]string {
|
|
v, ok := r[key]
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
if m, ok := v.(map[string]string); ok {
|
|
return m
|
|
}
|
|
|
|
res, ok := ifaceToResource(v)
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
m := make(map[string]string)
|
|
for k, v := range res {
|
|
s, ok := ifaceToStr(v)
|
|
if !ok {
|
|
continue
|
|
}
|
|
m[k] = s
|
|
}
|
|
return m
|
|
}
|
|
|
|
func ifaceToResource(i interface{}) (Resource, bool) {
|
|
if i == nil {
|
|
return nil, false
|
|
}
|
|
|
|
if res, ok := i.(Resource); ok {
|
|
return res, true
|
|
}
|
|
|
|
if m, ok := i.(map[string]interface{}); ok {
|
|
return m, true
|
|
}
|
|
|
|
m, ok := i.(map[interface{}]interface{})
|
|
if !ok {
|
|
return nil, false
|
|
}
|
|
|
|
newRes := make(Resource)
|
|
for k, v := range m {
|
|
s, ok := k.(string)
|
|
if !ok {
|
|
continue
|
|
}
|
|
newRes[s] = v
|
|
}
|
|
return newRes, true
|
|
}
|
|
|
|
func ifaceToReference(i interface{}) *references {
|
|
var ref references
|
|
for _, f := range []string{fieldReferencesSecret, fieldReferencesEnv} {
|
|
resBody, ok := ifaceToResource(i)
|
|
if !ok {
|
|
continue
|
|
}
|
|
if keyRes, ok := ifaceToResource(resBody[f]); ok {
|
|
switch f {
|
|
case fieldReferencesEnv:
|
|
ref.EnvRef = keyRes.stringShort(fieldKey)
|
|
ref.defaultVal = keyRes[fieldDefault]
|
|
case fieldReferencesSecret:
|
|
ref.Secret = keyRes.stringShort(fieldKey)
|
|
}
|
|
}
|
|
}
|
|
if ref.hasValue() {
|
|
return &ref
|
|
}
|
|
|
|
return &references{val: i}
|
|
}
|
|
|
|
func ifaceToStr(v interface{}) (string, bool) {
|
|
if v == nil {
|
|
return "", false
|
|
}
|
|
|
|
if s, ok := v.(string); ok {
|
|
return s, true
|
|
}
|
|
|
|
if i, ok := v.(int); ok {
|
|
return strconv.Itoa(i), true
|
|
}
|
|
|
|
if f, ok := v.(float64); ok {
|
|
return strconv.FormatFloat(f, 'f', -1, 64), true
|
|
}
|
|
|
|
return "", false
|
|
}
|
|
|
|
// ParseError is the error from parsing the given package. The ParseError
|
|
// behavior provides a list of resources that failed and all validations
|
|
// that failed for that resource. A resource can multiple errors, and
|
|
// a parseErr can have multiple resources which themselves can have
|
|
// multiple validation failures.
|
|
type ParseError interface {
|
|
ValidationErrs() []ValidationErr
|
|
}
|
|
|
|
// NewParseError creates a new parse error from existing validation errors.
|
|
func NewParseError(errs ...ValidationErr) error {
|
|
if len(errs) == 0 {
|
|
return nil
|
|
}
|
|
return &parseErr{rawErrs: errs}
|
|
}
|
|
|
|
type (
|
|
parseErr struct {
|
|
Resources []resourceErr
|
|
rawErrs []ValidationErr
|
|
}
|
|
|
|
// resourceErr describes the error for a particular resource. In
|
|
// which it may have numerous validation and association errors.
|
|
resourceErr struct {
|
|
Kind string
|
|
Idx *int
|
|
RootErrs []validationErr
|
|
AssociationErrs []validationErr
|
|
ValidationErrs []validationErr
|
|
}
|
|
|
|
validationErr struct {
|
|
Field string
|
|
Msg string
|
|
Index *int
|
|
|
|
Nested []validationErr
|
|
}
|
|
)
|
|
|
|
// Error implements the error interface.
|
|
func (e *parseErr) Error() string {
|
|
var (
|
|
errMsg []string
|
|
seenErrs = make(map[string]bool)
|
|
)
|
|
for _, ve := range append(e.ValidationErrs(), e.rawErrs...) {
|
|
msg := ve.Error()
|
|
if seenErrs[msg] {
|
|
continue
|
|
}
|
|
seenErrs[msg] = true
|
|
errMsg = append(errMsg, ve.Error())
|
|
}
|
|
|
|
return strings.Join(errMsg, "\n\t")
|
|
}
|
|
|
|
func (e *parseErr) ValidationErrs() []ValidationErr {
|
|
errs := e.rawErrs[:]
|
|
for _, r := range e.Resources {
|
|
rootErr := ValidationErr{
|
|
Kind: r.Kind,
|
|
}
|
|
for _, v := range r.RootErrs {
|
|
errs = append(errs, traverseErrs(rootErr, v)...)
|
|
}
|
|
|
|
rootErr.Indexes = []*int{r.Idx}
|
|
rootErr.Fields = []string{"root"}
|
|
for _, v := range append(r.ValidationErrs, r.AssociationErrs...) {
|
|
errs = append(errs, traverseErrs(rootErr, v)...)
|
|
}
|
|
}
|
|
|
|
// used to provide a means to == or != in the map lookup
|
|
// to remove duplicate errors
|
|
type key struct {
|
|
kind string
|
|
fields string
|
|
indexes string
|
|
reason string
|
|
}
|
|
|
|
m := make(map[key]bool)
|
|
var out []ValidationErr
|
|
for _, verr := range errs {
|
|
k := key{
|
|
kind: verr.Kind,
|
|
fields: strings.Join(verr.Fields, ":"),
|
|
reason: verr.Reason,
|
|
}
|
|
var indexes []string
|
|
for _, idx := range verr.Indexes {
|
|
if idx == nil {
|
|
continue
|
|
}
|
|
indexes = append(indexes, strconv.Itoa(*idx))
|
|
}
|
|
k.indexes = strings.Join(indexes, ":")
|
|
if m[k] {
|
|
continue
|
|
}
|
|
m[k] = true
|
|
out = append(out, verr)
|
|
}
|
|
|
|
return out
|
|
}
|
|
|
|
// ValidationErr represents an error during the parsing of a package.
|
|
type ValidationErr struct {
|
|
Kind string `json:"kind" yaml:"kind"`
|
|
Fields []string `json:"fields" yaml:"fields"`
|
|
Indexes []*int `json:"idxs" yaml:"idxs"`
|
|
Reason string `json:"reason" yaml:"reason"`
|
|
}
|
|
|
|
func (v ValidationErr) Error() string {
|
|
fieldPairs := make([]string, 0, len(v.Fields))
|
|
for i, idx := range v.Indexes {
|
|
field := v.Fields[i]
|
|
if idx == nil || *idx == -1 {
|
|
fieldPairs = append(fieldPairs, field)
|
|
continue
|
|
}
|
|
fieldPairs = append(fieldPairs, fmt.Sprintf("%s[%d]", field, *idx))
|
|
}
|
|
|
|
return fmt.Sprintf("kind=%s field=%s reason=%q", v.Kind, strings.Join(fieldPairs, "."), v.Reason)
|
|
}
|
|
|
|
func traverseErrs(root ValidationErr, vErr validationErr) []ValidationErr {
|
|
root.Fields = append(root.Fields, vErr.Field)
|
|
root.Indexes = append(root.Indexes, vErr.Index)
|
|
if len(vErr.Nested) == 0 {
|
|
root.Reason = vErr.Msg
|
|
return []ValidationErr{root}
|
|
}
|
|
|
|
var errs []ValidationErr
|
|
for _, n := range vErr.Nested {
|
|
errs = append(errs, traverseErrs(root, n)...)
|
|
}
|
|
return errs
|
|
}
|
|
|
|
func (e *parseErr) append(errs ...resourceErr) {
|
|
e.Resources = append(e.Resources, errs...)
|
|
}
|
|
|
|
// IsParseErr inspects a given error to determine if it is
|
|
// a parseErr. If a parseErr it is, it will return it along
|
|
// with the confirmation boolean. If the error is not a parseErr
|
|
// it will return nil values for the parseErr, making it unsafe
|
|
// to use.
|
|
func IsParseErr(err error) bool {
|
|
if _, ok := err.(*parseErr); ok {
|
|
return true
|
|
}
|
|
|
|
iErr, ok := err.(*errors2.Error)
|
|
if !ok {
|
|
return false
|
|
}
|
|
return IsParseErr(iErr.Err)
|
|
}
|
|
|
|
func objectValidationErr(field string, vErrs ...validationErr) validationErr {
|
|
return validationErr{
|
|
Field: field,
|
|
Nested: vErrs,
|
|
}
|
|
}
|
|
|
|
func normStr(s string) string {
|
|
return strings.TrimSpace(strings.ToLower(s))
|
|
}
|