1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
// SPDX-License-Identifier: GPL-3.0-or-later
package pipeline
import (
"errors"
"fmt"
"github.com/netdata/netdata/go/go.d.plugin/agent/confgroup"
"github.com/netdata/netdata/go/go.d.plugin/agent/discovery/sd/discoverer/dockerd"
"github.com/netdata/netdata/go/go.d.plugin/agent/discovery/sd/discoverer/kubernetes"
"github.com/netdata/netdata/go/go.d.plugin/agent/discovery/sd/discoverer/netlisteners"
)
type Config struct {
Source string `yaml:"-"`
ConfigDefaults confgroup.Registry `yaml:"-"`
Disabled bool `yaml:"disabled"`
Name string `yaml:"name"`
Discover []DiscoveryConfig `yaml:"discover"`
Classify []ClassifyRuleConfig `yaml:"classify"`
Compose []ComposeRuleConfig `yaml:"compose"`
}
type DiscoveryConfig struct {
Discoverer string `yaml:"discoverer"`
NetListeners netlisteners.Config `yaml:"net_listeners"`
Docker dockerd.Config `yaml:"docker"`
K8s []kubernetes.Config `yaml:"k8s"`
}
type ClassifyRuleConfig struct {
Name string `yaml:"name"`
Selector string `yaml:"selector"` // mandatory
Tags string `yaml:"tags"` // mandatory
Match []struct {
Tags string `yaml:"tags"` // mandatory
Expr string `yaml:"expr"` // mandatory
} `yaml:"match"` // mandatory, at least 1
}
type ComposeRuleConfig struct {
Name string `yaml:"name"` // optional
Selector string `yaml:"selector"` // mandatory
Config []struct {
Selector string `yaml:"selector"` // mandatory
Template string `yaml:"template"` // mandatory
} `yaml:"config"` // mandatory, at least 1
}
func validateConfig(cfg Config) error {
if cfg.Name == "" {
return errors.New("'name' not set")
}
if err := validateDiscoveryConfig(cfg.Discover); err != nil {
return fmt.Errorf("discover config: %v", err)
}
if err := validateClassifyConfig(cfg.Classify); err != nil {
return fmt.Errorf("classify rules: %v", err)
}
if err := validateComposeConfig(cfg.Compose); err != nil {
return fmt.Errorf("compose rules: %v", err)
}
return nil
}
func validateDiscoveryConfig(config []DiscoveryConfig) error {
if len(config) == 0 {
return errors.New("no discoverers, must be at least one")
}
for _, cfg := range config {
switch cfg.Discoverer {
case "net_listeners", "docker", "k8s":
default:
return fmt.Errorf("unknown discoverer: '%s'", cfg.Discoverer)
}
}
return nil
}
func validateClassifyConfig(rules []ClassifyRuleConfig) error {
if len(rules) == 0 {
return errors.New("empty config, need least 1 rule")
}
for i, rule := range rules {
i++
if rule.Selector == "" {
return fmt.Errorf("'rule[%s][%d]->selector' not set", rule.Name, i)
}
if rule.Tags == "" {
return fmt.Errorf("'rule[%s][%d]->tags' not set", rule.Name, i)
}
if len(rule.Match) == 0 {
return fmt.Errorf("'rule[%s][%d]->match' not set, need at least 1 rule match", rule.Name, i)
}
for j, match := range rule.Match {
j++
if match.Tags == "" {
return fmt.Errorf("'rule[%s][%d]->match[%d]->tags' not set", rule.Name, i, j)
}
if match.Expr == "" {
return fmt.Errorf("'rule[%s][%d]->match[%d]->expr' not set", rule.Name, i, j)
}
}
}
return nil
}
func validateComposeConfig(rules []ComposeRuleConfig) error {
if len(rules) == 0 {
return errors.New("empty config, need least 1 rule")
}
for i, rule := range rules {
i++
if rule.Selector == "" {
return fmt.Errorf("'rule[%s][%d]->selector' not set", rule.Name, i)
}
if len(rule.Config) == 0 {
return fmt.Errorf("'rule[%s][%d]->config' not set", rule.Name, i)
}
for j, conf := range rule.Config {
j++
if conf.Selector == "" {
return fmt.Errorf("'rule[%s][%d]->config[%d]->selector' not set", rule.Name, i, j)
}
if conf.Template == "" {
return fmt.Errorf("'rule[%s][%d]->config[%d]->template' not set", rule.Name, i, j)
}
}
}
return nil
}
|
