mirror of
https://github.com/kubernetes-sigs/node-feature-discovery.git
synced 2025-03-14 20:56:42 +00:00
Merge pull request #908 from marquiz/devel/type-rename
pkg/api/feature: rename types
This commit is contained in:
commit
4097198848
18 changed files with 777 additions and 777 deletions
|
@ -20,26 +20,26 @@ package feature
|
|||
// features to empty values
|
||||
func NewDomainFeatures() *DomainFeatures {
|
||||
return &DomainFeatures{
|
||||
Keys: make(map[string]KeyFeatureSet),
|
||||
Values: make(map[string]ValueFeatureSet),
|
||||
Instances: make(map[string]InstanceFeatureSet)}
|
||||
Flags: make(map[string]FlagFeatureSet),
|
||||
Attributes: make(map[string]AttributeFeatureSet),
|
||||
Instances: make(map[string]InstanceFeatureSet)}
|
||||
}
|
||||
|
||||
// NewKeyFeatures creates a new instance of KeyFeatureSet.
|
||||
func NewKeyFeatures(keys ...string) KeyFeatureSet {
|
||||
// NewFlagFeatures creates a new instance of KeyFeatureSet.
|
||||
func NewFlagFeatures(keys ...string) FlagFeatureSet {
|
||||
e := make(map[string]Nil, len(keys))
|
||||
for _, k := range keys {
|
||||
e[k] = Nil{}
|
||||
}
|
||||
return KeyFeatureSet{Elements: e}
|
||||
return FlagFeatureSet{Elements: e}
|
||||
}
|
||||
|
||||
// NewValueFeatures creates a new instance of ValueFeatureSet.
|
||||
func NewValueFeatures(values map[string]string) ValueFeatureSet {
|
||||
// NewAttributeFeatures creates a new instance of ValueFeatureSet.
|
||||
func NewAttributeFeatures(values map[string]string) AttributeFeatureSet {
|
||||
if values == nil {
|
||||
values = make(map[string]string)
|
||||
}
|
||||
return ValueFeatureSet{Elements: values}
|
||||
return AttributeFeatureSet{Elements: values}
|
||||
}
|
||||
|
||||
// NewInstanceFeatures creates a new instance of InstanceFeatureSet.
|
||||
|
@ -55,17 +55,17 @@ func NewInstanceFeature(attrs map[string]string) *InstanceFeature {
|
|||
return &InstanceFeature{Attributes: attrs}
|
||||
}
|
||||
|
||||
// InsertFeatureValues inserts new values into a specific feature.
|
||||
func InsertFeatureValues(f Features, domain, feature string, values map[string]string) {
|
||||
// InsertAttributeFeatures inserts new values into a specific feature.
|
||||
func InsertAttributeFeatures(f Features, domain, feature string, values map[string]string) {
|
||||
if _, ok := f[domain]; !ok {
|
||||
f[domain] = NewDomainFeatures()
|
||||
}
|
||||
if _, ok := f[domain].Values[feature]; !ok {
|
||||
f[domain].Values[feature] = NewValueFeatures(values)
|
||||
if _, ok := f[domain].Attributes[feature]; !ok {
|
||||
f[domain].Attributes[feature] = NewAttributeFeatures(values)
|
||||
return
|
||||
}
|
||||
|
||||
for k, v := range values {
|
||||
f[domain].Values[feature].Elements[k] = v
|
||||
f[domain].Attributes[feature].Elements[k] = v
|
||||
}
|
||||
}
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -24,15 +24,25 @@ package feature;
|
|||
// Package-wide variables from generator "generated".
|
||||
option go_package = "sigs.k8s.io/node-feature-discovery/pkg/api/feature";
|
||||
|
||||
// AttributeFeatureSet is a set of features having string value.
|
||||
message AttributeFeatureSet {
|
||||
map<string, string> elements = 1;
|
||||
}
|
||||
|
||||
// DomainFeatures is the collection of all discovered features of one domain.
|
||||
message DomainFeatures {
|
||||
map<string, KeyFeatureSet> keys = 1;
|
||||
map<string, FlagFeatureSet> flags = 1;
|
||||
|
||||
map<string, ValueFeatureSet> values = 2;
|
||||
map<string, AttributeFeatureSet> vattributes = 2;
|
||||
|
||||
map<string, InstanceFeatureSet> instances = 3;
|
||||
}
|
||||
|
||||
// FlagFeatureSet is a set of simple features only containing names without values.
|
||||
message FlagFeatureSet {
|
||||
map<string, Nil> elements = 1;
|
||||
}
|
||||
|
||||
// InstanceFeature represents one instance of a complex features, e.g. a device.
|
||||
message InstanceFeature {
|
||||
map<string, string> attributes = 1;
|
||||
|
@ -43,17 +53,7 @@ message InstanceFeatureSet {
|
|||
repeated InstanceFeature elements = 1;
|
||||
}
|
||||
|
||||
// KeyFeatureSet is a set of simple features only containing names without values.
|
||||
message KeyFeatureSet {
|
||||
map<string, Nil> elements = 1;
|
||||
}
|
||||
|
||||
// Nil is a dummy empty struct for protobuf compatibility
|
||||
message Nil {
|
||||
}
|
||||
|
||||
// ValueFeatureSet is a set of features having string value.
|
||||
message ValueFeatureSet {
|
||||
map<string, string> elements = 1;
|
||||
}
|
||||
|
||||
|
|
|
@ -24,18 +24,18 @@ type Features map[string]*DomainFeatures
|
|||
|
||||
// DomainFeatures is the collection of all discovered features of one domain.
|
||||
type DomainFeatures struct {
|
||||
Keys map[string]KeyFeatureSet `protobuf:"bytes,1,rep,name=keys"`
|
||||
Values map[string]ValueFeatureSet `protobuf:"bytes,2,rep,name=values"`
|
||||
Instances map[string]InstanceFeatureSet `protobuf:"bytes,3,rep,name=instances"`
|
||||
Flags map[string]FlagFeatureSet `protobuf:"bytes,1,rep,name=flags"`
|
||||
Attributes map[string]AttributeFeatureSet `protobuf:"bytes,2,rep,name=vattributes"`
|
||||
Instances map[string]InstanceFeatureSet `protobuf:"bytes,3,rep,name=instances"`
|
||||
}
|
||||
|
||||
// KeyFeatureSet is a set of simple features only containing names without values.
|
||||
type KeyFeatureSet struct {
|
||||
// FlagFeatureSet is a set of simple features only containing names without values.
|
||||
type FlagFeatureSet struct {
|
||||
Elements map[string]Nil `protobuf:"bytes,1,rep,name=elements"`
|
||||
}
|
||||
|
||||
// ValueFeatureSet is a set of features having string value.
|
||||
type ValueFeatureSet struct {
|
||||
// AttributeFeatureSet is a set of features having string value.
|
||||
type AttributeFeatureSet struct {
|
||||
Elements map[string]string `protobuf:"bytes,1,rep,name=elements"`
|
||||
}
|
||||
|
||||
|
|
|
@ -178,12 +178,12 @@ func (m *FeatureMatcher) match(features map[string]*feature.DomainFeatures) (boo
|
|||
|
||||
var isMatch bool
|
||||
var err error
|
||||
if f, ok := domainFeatures.Keys[featureName]; ok {
|
||||
if f, ok := domainFeatures.Flags[featureName]; ok {
|
||||
m, v, e := term.MatchExpressions.MatchGetKeys(f.Elements)
|
||||
isMatch = m
|
||||
err = e
|
||||
matches[domain][featureName] = v
|
||||
} else if f, ok := domainFeatures.Values[featureName]; ok {
|
||||
} else if f, ok := domainFeatures.Attributes[featureName]; ok {
|
||||
m, v, e := term.MatchExpressions.MatchGetValues(f.Elements)
|
||||
isMatch = m
|
||||
err = e
|
||||
|
|
|
@ -60,8 +60,8 @@ func TestRule(t *testing.T) {
|
|||
assert.Error(t, err, "matching against a missing feature type should have returned an error")
|
||||
|
||||
// Test empty feature sets
|
||||
d.Keys["kf-1"] = feature.NewKeyFeatures()
|
||||
d.Values["vf-1"] = feature.NewValueFeatures(nil)
|
||||
d.Flags["kf-1"] = feature.NewFlagFeatures()
|
||||
d.Attributes["vf-1"] = feature.NewAttributeFeatures(nil)
|
||||
d.Instances["if-1"] = feature.NewInstanceFeatures(nil)
|
||||
|
||||
m, err = r1.Execute(f)
|
||||
|
@ -73,8 +73,8 @@ func TestRule(t *testing.T) {
|
|||
assert.Nil(t, m.Labels, "unexpected match")
|
||||
|
||||
// Test non-empty feature sets
|
||||
d.Keys["kf-1"].Elements["key-x"] = feature.Nil{}
|
||||
d.Values["vf-1"].Elements["key-1"] = "val-x"
|
||||
d.Flags["kf-1"].Elements["key-x"] = feature.Nil{}
|
||||
d.Attributes["vf-1"].Elements["key-1"] = "val-x"
|
||||
d.Instances["if-1"] = feature.NewInstanceFeatures([]feature.InstanceFeature{
|
||||
*feature.NewInstanceFeature(map[string]string{"attr-1": "val-x"})})
|
||||
|
||||
|
@ -98,7 +98,7 @@ func TestRule(t *testing.T) {
|
|||
assert.Nilf(t, err, "unexpected error: %v", err)
|
||||
assert.Nil(t, m.Labels, "keys should not have matched")
|
||||
|
||||
d.Keys["kf-1"].Elements["key-1"] = feature.Nil{}
|
||||
d.Flags["kf-1"].Elements["key-1"] = feature.Nil{}
|
||||
m, err = r2.Execute(f)
|
||||
assert.Nilf(t, err, "unexpected error: %v", err)
|
||||
assert.Equal(t, r2.Labels, m.Labels, "keys should have matched")
|
||||
|
@ -120,7 +120,7 @@ func TestRule(t *testing.T) {
|
|||
assert.Nilf(t, err, "unexpected error: %v", err)
|
||||
assert.Nil(t, m.Labels, "values should not have matched")
|
||||
|
||||
d.Values["vf-1"].Elements["key-1"] = "val-1"
|
||||
d.Attributes["vf-1"].Elements["key-1"] = "val-1"
|
||||
m, err = r3.Execute(f)
|
||||
assert.Nilf(t, err, "unexpected error: %v", err)
|
||||
assert.Equal(t, r3.Labels, m.Labels, "values should have matched")
|
||||
|
@ -210,8 +210,8 @@ func TestRule(t *testing.T) {
|
|||
func TestTemplating(t *testing.T) {
|
||||
f := map[string]*feature.DomainFeatures{
|
||||
"domain_1": &feature.DomainFeatures{
|
||||
Keys: map[string]feature.KeyFeatureSet{
|
||||
"kf_1": feature.KeyFeatureSet{
|
||||
Flags: map[string]feature.FlagFeatureSet{
|
||||
"kf_1": feature.FlagFeatureSet{
|
||||
Elements: map[string]feature.Nil{
|
||||
"key-a": feature.Nil{},
|
||||
"key-b": feature.Nil{},
|
||||
|
@ -219,8 +219,8 @@ func TestTemplating(t *testing.T) {
|
|||
},
|
||||
},
|
||||
},
|
||||
Values: map[string]feature.ValueFeatureSet{
|
||||
"vf_1": feature.ValueFeatureSet{
|
||||
Attributes: map[string]feature.AttributeFeatureSet{
|
||||
"vf_1": feature.AttributeFeatureSet{
|
||||
Elements: map[string]string{
|
||||
"key-1": "val-1",
|
||||
"keu-2": "val-2",
|
||||
|
|
|
@ -507,8 +507,8 @@ func (m *nfdMaster) crLabels(r *pb.SetLabelsRequest) map[string]string {
|
|||
}
|
||||
|
||||
// Feed back rule output to features map for subsequent rules to match
|
||||
feature.InsertFeatureValues(r.Features, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Labels)
|
||||
feature.InsertFeatureValues(r.Features, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Vars)
|
||||
feature.InsertAttributeFeatures(r.Features, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Labels)
|
||||
feature.InsertAttributeFeatures(r.Features, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Vars)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -140,54 +140,54 @@ func (s *cpuSource) GetLabels() (source.FeatureLabels, error) {
|
|||
features := s.GetFeatures()
|
||||
|
||||
// CPUID
|
||||
for f := range features.Keys[CpuidFeature].Elements {
|
||||
for f := range features.Flags[CpuidFeature].Elements {
|
||||
if s.cpuidFilter.unmask(f) {
|
||||
labels["cpuid."+f] = true
|
||||
}
|
||||
}
|
||||
|
||||
// CPU model
|
||||
for k, v := range features.Values[Cpumodel].Elements {
|
||||
for k, v := range features.Attributes[Cpumodel].Elements {
|
||||
labels["model."+k] = v
|
||||
}
|
||||
|
||||
// Cstate
|
||||
for k, v := range features.Values[CstateFeature].Elements {
|
||||
for k, v := range features.Attributes[CstateFeature].Elements {
|
||||
labels["cstate."+k] = v
|
||||
}
|
||||
|
||||
// Pstate
|
||||
for k, v := range features.Values[PstateFeature].Elements {
|
||||
for k, v := range features.Attributes[PstateFeature].Elements {
|
||||
labels["pstate."+k] = v
|
||||
}
|
||||
|
||||
// RDT
|
||||
for k := range features.Keys[RdtFeature].Elements {
|
||||
for k := range features.Flags[RdtFeature].Elements {
|
||||
labels["rdt."+k] = true
|
||||
}
|
||||
|
||||
// Security
|
||||
for k, v := range features.Values[SecurityFeature].Elements {
|
||||
for k, v := range features.Attributes[SecurityFeature].Elements {
|
||||
labels["security."+k] = v
|
||||
}
|
||||
|
||||
// SGX
|
||||
for k, v := range features.Values[SgxFeature].Elements {
|
||||
for k, v := range features.Attributes[SgxFeature].Elements {
|
||||
labels["sgx."+k] = v
|
||||
}
|
||||
|
||||
// Secure Execution
|
||||
for k, v := range features.Values[SeFeature].Elements {
|
||||
for k, v := range features.Attributes[SeFeature].Elements {
|
||||
labels["se."+k] = v
|
||||
}
|
||||
|
||||
// SST
|
||||
for k, v := range features.Values[SstFeature].Elements {
|
||||
for k, v := range features.Attributes[SstFeature].Elements {
|
||||
labels["power.sst_"+k] = v
|
||||
}
|
||||
|
||||
// Hyperthreading
|
||||
if v, ok := features.Values[TopologyFeature].Elements["hardware_multithreading"]; ok {
|
||||
if v, ok := features.Attributes[TopologyFeature].Elements["hardware_multithreading"]; ok {
|
||||
labels["hardware_multithreading"] = v
|
||||
}
|
||||
|
||||
|
@ -199,17 +199,17 @@ func (s *cpuSource) Discover() error {
|
|||
s.features = feature.NewDomainFeatures()
|
||||
|
||||
// Detect CPUID
|
||||
s.features.Keys[CpuidFeature] = feature.NewKeyFeatures(getCpuidFlags()...)
|
||||
s.features.Flags[CpuidFeature] = feature.NewFlagFeatures(getCpuidFlags()...)
|
||||
|
||||
// Detect CPU model
|
||||
s.features.Values[Cpumodel] = feature.NewValueFeatures(getCPUModel())
|
||||
s.features.Attributes[Cpumodel] = feature.NewAttributeFeatures(getCPUModel())
|
||||
|
||||
// Detect cstate configuration
|
||||
cstate, err := detectCstate()
|
||||
if err != nil {
|
||||
klog.Errorf("failed to detect cstate: %v", err)
|
||||
} else {
|
||||
s.features.Values[CstateFeature] = feature.NewValueFeatures(cstate)
|
||||
s.features.Attributes[CstateFeature] = feature.NewAttributeFeatures(cstate)
|
||||
}
|
||||
|
||||
// Detect pstate features
|
||||
|
@ -217,33 +217,33 @@ func (s *cpuSource) Discover() error {
|
|||
if err != nil {
|
||||
klog.Error(err)
|
||||
}
|
||||
s.features.Values[PstateFeature] = feature.NewValueFeatures(pstate)
|
||||
s.features.Attributes[PstateFeature] = feature.NewAttributeFeatures(pstate)
|
||||
|
||||
// Detect RDT features
|
||||
s.features.Keys[RdtFeature] = feature.NewKeyFeatures(discoverRDT()...)
|
||||
s.features.Flags[RdtFeature] = feature.NewFlagFeatures(discoverRDT()...)
|
||||
|
||||
// Detect SGX features
|
||||
s.features.Values[SecurityFeature] = feature.NewValueFeatures(discoverSecurity())
|
||||
s.features.Attributes[SecurityFeature] = feature.NewAttributeFeatures(discoverSecurity())
|
||||
|
||||
// Detect SGX features
|
||||
//
|
||||
// DEPRECATED in v0.12: will be removed in the future
|
||||
if val, ok := s.features.Values[SecurityFeature].Elements["sgx.enabled"]; ok {
|
||||
s.features.Values[SgxFeature] = feature.NewValueFeatures(map[string]string{"enabled": val})
|
||||
if val, ok := s.features.Attributes[SecurityFeature].Elements["sgx.enabled"]; ok {
|
||||
s.features.Attributes[SgxFeature] = feature.NewAttributeFeatures(map[string]string{"enabled": val})
|
||||
}
|
||||
|
||||
// Detect Secure Execution features
|
||||
//
|
||||
// DEPRECATED in v0.12: will be removed in the future
|
||||
if val, ok := s.features.Values[SecurityFeature].Elements["se.enabled"]; ok {
|
||||
s.features.Values[SeFeature] = feature.NewValueFeatures(map[string]string{"enabled": val})
|
||||
if val, ok := s.features.Attributes[SecurityFeature].Elements["se.enabled"]; ok {
|
||||
s.features.Attributes[SeFeature] = feature.NewAttributeFeatures(map[string]string{"enabled": val})
|
||||
}
|
||||
|
||||
// Detect SST features
|
||||
s.features.Values[SstFeature] = feature.NewValueFeatures(discoverSST())
|
||||
s.features.Attributes[SstFeature] = feature.NewAttributeFeatures(discoverSST())
|
||||
|
||||
// Detect hyper-threading
|
||||
s.features.Values[TopologyFeature] = feature.NewValueFeatures(discoverTopology())
|
||||
s.features.Attributes[TopologyFeature] = feature.NewAttributeFeatures(discoverTopology())
|
||||
|
||||
utils.KlogDump(3, "discovered cpu features:", " ", s.features)
|
||||
|
||||
|
|
|
@ -129,8 +129,8 @@ func (s *customSource) GetLabels() (source.FeatureLabels, error) {
|
|||
labels[n] = v
|
||||
}
|
||||
// Feed back rule output to features map for subsequent rules to match
|
||||
feature.InsertFeatureValues(domainFeatures, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Labels)
|
||||
feature.InsertFeatureValues(domainFeatures, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Vars)
|
||||
feature.InsertAttributeFeatures(domainFeatures, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Labels)
|
||||
feature.InsertAttributeFeatures(domainFeatures, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Vars)
|
||||
}
|
||||
return labels, nil
|
||||
}
|
||||
|
|
|
@ -31,7 +31,7 @@ type CpuIDRule struct {
|
|||
|
||||
// Match checks if CpuId rule matches.
|
||||
func (r *CpuIDRule) Match() (bool, error) {
|
||||
flags, ok := source.GetFeatureSource("cpu").GetFeatures().Keys[cpu.CpuidFeature]
|
||||
flags, ok := source.GetFeatureSource("cpu").GetFeatures().Flags[cpu.CpuidFeature]
|
||||
if !ok {
|
||||
return false, fmt.Errorf("cpuid information not available")
|
||||
}
|
||||
|
|
|
@ -31,7 +31,7 @@ type LoadedKModRule struct {
|
|||
|
||||
// Match loaded kernel modules on provided list of kernel modules
|
||||
func (r *LoadedKModRule) Match() (bool, error) {
|
||||
modules, ok := source.GetFeatureSource("kernel").GetFeatures().Keys[kernel.LoadedModuleFeature]
|
||||
modules, ok := source.GetFeatureSource("kernel").GetFeatures().Flags[kernel.LoadedModuleFeature]
|
||||
if !ok {
|
||||
return false, fmt.Errorf("info about loaded modules not available")
|
||||
}
|
||||
|
|
|
@ -32,7 +32,7 @@ type NodenameRule struct {
|
|||
|
||||
// Match checks if node name matches the rule.
|
||||
func (r *NodenameRule) Match() (bool, error) {
|
||||
nodeName, ok := source.GetFeatureSource("system").GetFeatures().Values[system.NameFeature].Elements["nodename"]
|
||||
nodeName, ok := source.GetFeatureSource("system").GetFeatures().Attributes[system.NameFeature].Elements["nodename"]
|
||||
if !ok || nodeName == "" {
|
||||
return false, fmt.Errorf("node name not available")
|
||||
}
|
||||
|
|
|
@ -118,8 +118,8 @@ func (s *fakeSource) SetConfig(conf source.Config) {
|
|||
func (s *fakeSource) Discover() error {
|
||||
s.features = feature.NewDomainFeatures()
|
||||
|
||||
s.features.Keys[FlagFeature] = feature.NewKeyFeatures(s.config.FlagFeatures...)
|
||||
s.features.Values[AttributeFeature] = feature.NewValueFeatures(s.config.AttributeFeatures)
|
||||
s.features.Flags[FlagFeature] = feature.NewFlagFeatures(s.config.FlagFeatures...)
|
||||
s.features.Attributes[AttributeFeature] = feature.NewAttributeFeatures(s.config.AttributeFeatures)
|
||||
|
||||
instances := make([]feature.InstanceFeature, len(s.config.InstanceFeatures))
|
||||
for i, instanceAttributes := range s.config.InstanceFeatures {
|
||||
|
|
|
@ -98,7 +98,7 @@ func (s *kernelSource) GetLabels() (source.FeatureLabels, error) {
|
|||
labels := source.FeatureLabels{}
|
||||
features := s.GetFeatures()
|
||||
|
||||
for k, v := range features.Values[VersionFeature].Elements {
|
||||
for k, v := range features.Attributes[VersionFeature].Elements {
|
||||
labels[VersionFeature+"."+k] = v
|
||||
}
|
||||
|
||||
|
@ -108,7 +108,7 @@ func (s *kernelSource) GetLabels() (source.FeatureLabels, error) {
|
|||
}
|
||||
}
|
||||
|
||||
if enabled, ok := features.Values[SelinuxFeature].Elements["enabled"]; ok && enabled == "true" {
|
||||
if enabled, ok := features.Attributes[SelinuxFeature].Elements["enabled"]; ok && enabled == "true" {
|
||||
labels["selinux.enabled"] = "true"
|
||||
}
|
||||
|
||||
|
@ -123,7 +123,7 @@ func (s *kernelSource) Discover() error {
|
|||
if version, err := parseVersion(); err != nil {
|
||||
klog.Errorf("failed to get kernel version: %s", err)
|
||||
} else {
|
||||
s.features.Values[VersionFeature] = feature.NewValueFeatures(version)
|
||||
s.features.Attributes[VersionFeature] = feature.NewAttributeFeatures(version)
|
||||
}
|
||||
|
||||
// Read kconfig
|
||||
|
@ -131,21 +131,21 @@ func (s *kernelSource) Discover() error {
|
|||
s.legacyKconfig = nil
|
||||
klog.Errorf("failed to read kconfig: %s", err)
|
||||
} else {
|
||||
s.features.Values[ConfigFeature] = feature.NewValueFeatures(realKconfig)
|
||||
s.features.Attributes[ConfigFeature] = feature.NewAttributeFeatures(realKconfig)
|
||||
s.legacyKconfig = legacyKconfig
|
||||
}
|
||||
|
||||
if kmods, err := getLoadedModules(); err != nil {
|
||||
klog.Errorf("failed to get loaded kernel modules: %v", err)
|
||||
} else {
|
||||
s.features.Keys[LoadedModuleFeature] = feature.NewKeyFeatures(kmods...)
|
||||
s.features.Flags[LoadedModuleFeature] = feature.NewFlagFeatures(kmods...)
|
||||
}
|
||||
|
||||
if selinux, err := SelinuxEnabled(); err != nil {
|
||||
klog.Warning(err)
|
||||
} else {
|
||||
s.features.Values[SelinuxFeature] = feature.NewValueFeatures(nil)
|
||||
s.features.Values[SelinuxFeature].Elements["enabled"] = strconv.FormatBool(selinux)
|
||||
s.features.Attributes[SelinuxFeature] = feature.NewAttributeFeatures(nil)
|
||||
s.features.Attributes[SelinuxFeature].Elements["enabled"] = strconv.FormatBool(selinux)
|
||||
}
|
||||
|
||||
utils.KlogDump(3, "discovered kernel features:", " ", s.features)
|
||||
|
|
|
@ -88,7 +88,7 @@ func (s *localSource) GetLabels() (source.FeatureLabels, error) {
|
|||
labels := make(source.FeatureLabels)
|
||||
features := s.GetFeatures()
|
||||
|
||||
for k, v := range features.Values[LabelFeature].Elements {
|
||||
for k, v := range features.Attributes[LabelFeature].Elements {
|
||||
labels[k] = v
|
||||
}
|
||||
return labels, nil
|
||||
|
@ -129,7 +129,7 @@ func (s *localSource) Discover() error {
|
|||
}
|
||||
}
|
||||
|
||||
s.features.Values[LabelFeature] = feature.NewValueFeatures(featuresFromFiles)
|
||||
s.features.Attributes[LabelFeature] = feature.NewAttributeFeatures(featuresFromFiles)
|
||||
|
||||
utils.KlogDump(3, "discovered local features:", " ", s.features)
|
||||
|
||||
|
|
|
@ -63,7 +63,7 @@ func (s *memorySource) GetLabels() (source.FeatureLabels, error) {
|
|||
features := s.GetFeatures()
|
||||
|
||||
// NUMA
|
||||
if isNuma, ok := features.Values[NumaFeature].Elements["is_numa"]; ok && isNuma == "true" {
|
||||
if isNuma, ok := features.Attributes[NumaFeature].Elements["is_numa"]; ok && isNuma == "true" {
|
||||
labels["numa"] = true
|
||||
}
|
||||
|
||||
|
@ -89,7 +89,7 @@ func (s *memorySource) Discover() error {
|
|||
if numa, err := detectNuma(); err != nil {
|
||||
klog.Errorf("failed to detect NUMA nodes: %v", err)
|
||||
} else {
|
||||
s.features.Values[NumaFeature] = feature.ValueFeatureSet{Elements: numa}
|
||||
s.features.Attributes[NumaFeature] = feature.AttributeFeatureSet{Elements: numa}
|
||||
}
|
||||
|
||||
// Detect NVDIMM
|
||||
|
|
|
@ -73,8 +73,8 @@ func TestFeatureSources(t *testing.T) {
|
|||
|
||||
f := s.GetFeatures()
|
||||
assert.NotNil(t, f, msg)
|
||||
assert.Empty(t, (*f).Keys, msg)
|
||||
assert.Empty(t, (*f).Values, msg)
|
||||
assert.Empty(t, (*f).Flags, msg)
|
||||
assert.Empty(t, (*f).Attributes, msg)
|
||||
assert.Empty(t, (*f).Instances, msg)
|
||||
}
|
||||
}
|
||||
|
|
|
@ -67,7 +67,7 @@ func (s *systemSource) GetLabels() (source.FeatureLabels, error) {
|
|||
features := s.GetFeatures()
|
||||
|
||||
for _, key := range osReleaseFields {
|
||||
if value, exists := features.Values[OsReleaseFeature].Elements[key]; exists {
|
||||
if value, exists := features.Attributes[OsReleaseFeature].Elements[key]; exists {
|
||||
feature := "os_release." + key
|
||||
labels[feature] = value
|
||||
}
|
||||
|
@ -80,21 +80,21 @@ func (s *systemSource) Discover() error {
|
|||
s.features = feature.NewDomainFeatures()
|
||||
|
||||
// Get node name
|
||||
s.features.Values[NameFeature] = feature.NewValueFeatures(nil)
|
||||
s.features.Values[NameFeature].Elements["nodename"] = os.Getenv("NODE_NAME")
|
||||
s.features.Attributes[NameFeature] = feature.NewAttributeFeatures(nil)
|
||||
s.features.Attributes[NameFeature].Elements["nodename"] = os.Getenv("NODE_NAME")
|
||||
|
||||
// Get os-release information
|
||||
release, err := parseOSRelease()
|
||||
if err != nil {
|
||||
klog.Errorf("failed to get os-release: %s", err)
|
||||
} else {
|
||||
s.features.Values[OsReleaseFeature] = feature.NewValueFeatures(release)
|
||||
s.features.Attributes[OsReleaseFeature] = feature.NewAttributeFeatures(release)
|
||||
|
||||
if v, ok := release["VERSION_ID"]; ok {
|
||||
versionComponents := splitVersion(v)
|
||||
for subKey, subValue := range versionComponents {
|
||||
if subValue != "" {
|
||||
s.features.Values[OsReleaseFeature].Elements["VERSION_ID."+subKey] = subValue
|
||||
s.features.Attributes[OsReleaseFeature].Elements["VERSION_ID."+subKey] = subValue
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Add table
Reference in a new issue