mirrors/node-feature-discovery
mirrors/node-feature-discovery
1
0
Fork 0
mirror of https://github.com/kubernetes-sigs/node-feature-discovery.git synced 2025-03-31 04:04:51 +00:00
Code Activity

pkg/api/feature: rename types

Browse source 
Sync type names with NFD documentation. Aims at making the codebase
easier to follow.
This commit is contained in:
Markus Lehtonen 2022-06-14 17:02:49 +03:00 • committed by Markus Lehtonen
parent 906aad6717
commit abdbd420d1
17 changed files with 142 additions and 142 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
pkg/api/feature/feature.go
View file

@ -20,26 +20,26 @@ package feature
// features to empty values // features to empty values
func NewDomainFeatures() *DomainFeatures { func NewDomainFeatures() *DomainFeatures {
return &DomainFeatures{ return &DomainFeatures{
Keys: make(map[string]KeyFeatureSet), Flags: make(map[string]FlagFeatureSet),
Values: make(map[string]ValueFeatureSet), Attributes: make(map[string]AttributeFeatureSet),
Instances: make(map[string]InstanceFeatureSet)} Instances: make(map[string]InstanceFeatureSet)}
} }
// NewKeyFeatures creates a new instance of KeyFeatureSet. // NewFlagFeatures creates a new instance of KeyFeatureSet.
func NewKeyFeatures(keys ...string) KeyFeatureSet { func NewFlagFeatures(keys ...string) FlagFeatureSet {
e := make(map[string]Nil, len(keys)) e := make(map[string]Nil, len(keys))
for _, k := range keys { for _, k := range keys {
e[k] = Nil{} e[k] = Nil{}
} }
return KeyFeatureSet{Elements: e} return FlagFeatureSet{Elements: e}
} }
// NewValueFeatures creates a new instance of ValueFeatureSet. // NewAttributeFeatures creates a new instance of ValueFeatureSet.
func NewValueFeatures(values map[string]string) ValueFeatureSet { func NewAttributeFeatures(values map[string]string) AttributeFeatureSet {
if values == nil { if values == nil {
values = make(map[string]string) values = make(map[string]string)
} }
return ValueFeatureSet{Elements: values} return AttributeFeatureSet{Elements: values}
} }
// NewInstanceFeatures creates a new instance of InstanceFeatureSet. // NewInstanceFeatures creates a new instance of InstanceFeatureSet.
@ -55,17 +55,17 @@ func NewInstanceFeature(attrs map[string]string) *InstanceFeature {
return &InstanceFeature{Attributes: attrs} return &InstanceFeature{Attributes: attrs}
} }
// InsertFeatureValues inserts new values into a specific feature. // InsertAttributeFeatures inserts new values into a specific feature.
func InsertFeatureValues(f Features, domain, feature string, values map[string]string) { func InsertAttributeFeatures(f Features, domain, feature string, values map[string]string) {
if _, ok := f[domain]; !ok { if _, ok := f[domain]; !ok {
f[domain] = NewDomainFeatures() f[domain] = NewDomainFeatures()
} }
if _, ok := f[domain].Values[feature]; !ok { if _, ok := f[domain].Attributes[feature]; !ok {
f[domain].Values[feature] = NewValueFeatures(values) f[domain].Attributes[feature] = NewAttributeFeatures(values)
return return
} }
for k, v := range values { for k, v := range values {
f[domain].Values[feature].Elements[k] = v f[domain].Attributes[feature].Elements[k] = v
} }
} }

120
pkg/api/feature/generated.pb.go
View file

@ -127,15 +127,15 @@ func (m *InstanceFeatureSet) XXX_DiscardUnknown() {
var xxx_messageInfo_InstanceFeatureSet proto.InternalMessageInfo var xxx_messageInfo_InstanceFeatureSet proto.InternalMessageInfo
func (m *KeyFeatureSet) Reset() { *m = KeyFeatureSet{} } func (m *FlagFeatureSet) Reset() { *m = FlagFeatureSet{} }
func (*KeyFeatureSet) ProtoMessage() {} func (*FlagFeatureSet) ProtoMessage() {}
func (*KeyFeatureSet) Descriptor() ([]byte, []int) { func (*FlagFeatureSet) Descriptor() ([]byte, []int) {
return fileDescriptor_870e6eafce4d2482, []int{3} return fileDescriptor_870e6eafce4d2482, []int{3}
} }
func (m *KeyFeatureSet) XXX_Unmarshal(b []byte) error { func (m *FlagFeatureSet) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
} }
func (m *KeyFeatureSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { func (m *FlagFeatureSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
b = b[:cap(b)] b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b) n, err := m.MarshalToSizedBuffer(b)
if err != nil { if err != nil {
@ -143,13 +143,13 @@ func (m *KeyFeatureSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error
} }
return b[:n], nil return b[:n], nil
} }
func (m *KeyFeatureSet) XXX_Merge(src proto.Message) { func (m *FlagFeatureSet) XXX_Merge(src proto.Message) {
xxx_messageInfo_KeyFeatureSet.Merge(m, src) xxx_messageInfo_KeyFeatureSet.Merge(m, src)
} }
func (m *KeyFeatureSet) XXX_Size() int { func (m *FlagFeatureSet) XXX_Size() int {
return m.Size() return m.Size()
} }
func (m *KeyFeatureSet) XXX_DiscardUnknown() { func (m *FlagFeatureSet) XXX_DiscardUnknown() {
xxx_messageInfo_KeyFeatureSet.DiscardUnknown(m) xxx_messageInfo_KeyFeatureSet.DiscardUnknown(m)
} }
@ -183,15 +183,15 @@ func (m *Nil) XXX_DiscardUnknown() {
var xxx_messageInfo_Nil proto.InternalMessageInfo var xxx_messageInfo_Nil proto.InternalMessageInfo
func (m *ValueFeatureSet) Reset() { *m = ValueFeatureSet{} } func (m *AttributeFeatureSet) Reset() { *m = AttributeFeatureSet{} }
func (*ValueFeatureSet) ProtoMessage() {} func (*AttributeFeatureSet) ProtoMessage() {}
func (*ValueFeatureSet) Descriptor() ([]byte, []int) { func (*AttributeFeatureSet) Descriptor() ([]byte, []int) {
return fileDescriptor_870e6eafce4d2482, []int{5} return fileDescriptor_870e6eafce4d2482, []int{5}
} }
func (m *ValueFeatureSet) XXX_Unmarshal(b []byte) error { func (m *AttributeFeatureSet) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
} }
func (m *ValueFeatureSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { func (m *AttributeFeatureSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
b = b[:cap(b)] b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b) n, err := m.MarshalToSizedBuffer(b)
if err != nil { if err != nil {
@ -199,13 +199,13 @@ func (m *ValueFeatureSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, err
} }
return b[:n], nil return b[:n], nil
} }
func (m *ValueFeatureSet) XXX_Merge(src proto.Message) { func (m *AttributeFeatureSet) XXX_Merge(src proto.Message) {
xxx_messageInfo_ValueFeatureSet.Merge(m, src) xxx_messageInfo_ValueFeatureSet.Merge(m, src)
} }
func (m *ValueFeatureSet) XXX_Size() int { func (m *AttributeFeatureSet) XXX_Size() int {
return m.Size() return m.Size()
} }
func (m *ValueFeatureSet) XXX_DiscardUnknown() { func (m *AttributeFeatureSet) XXX_DiscardUnknown() {
xxx_messageInfo_ValueFeatureSet.DiscardUnknown(m) xxx_messageInfo_ValueFeatureSet.DiscardUnknown(m)
} }
@ -214,15 +214,15 @@ var xxx_messageInfo_ValueFeatureSet proto.InternalMessageInfo
func init() { func init() {
proto.RegisterType((*DomainFeatures)(nil), "feature.DomainFeatures") proto.RegisterType((*DomainFeatures)(nil), "feature.DomainFeatures")
proto.RegisterMapType((map[string]InstanceFeatureSet)(nil), "feature.DomainFeatures.InstancesEntry") proto.RegisterMapType((map[string]InstanceFeatureSet)(nil), "feature.DomainFeatures.InstancesEntry")
proto.RegisterMapType((map[string]KeyFeatureSet)(nil), "feature.DomainFeatures.KeysEntry") proto.RegisterMapType((map[string]FlagFeatureSet)(nil), "feature.DomainFeatures.KeysEntry")
proto.RegisterMapType((map[string]ValueFeatureSet)(nil), "feature.DomainFeatures.ValuesEntry") proto.RegisterMapType((map[string]AttributeFeatureSet)(nil), "feature.DomainFeatures.ValuesEntry")
proto.RegisterType((*InstanceFeature)(nil), "feature.InstanceFeature") proto.RegisterType((*InstanceFeature)(nil), "feature.InstanceFeature")
proto.RegisterMapType((map[string]string)(nil), "feature.InstanceFeature.AttributesEntry") proto.RegisterMapType((map[string]string)(nil), "feature.InstanceFeature.AttributesEntry")
proto.RegisterType((*InstanceFeatureSet)(nil), "feature.InstanceFeatureSet") proto.RegisterType((*InstanceFeatureSet)(nil), "feature.InstanceFeatureSet")
proto.RegisterType((*KeyFeatureSet)(nil), "feature.KeyFeatureSet") proto.RegisterType((*FlagFeatureSet)(nil), "feature.KeyFeatureSet")
proto.RegisterMapType((map[string]Nil)(nil), "feature.KeyFeatureSet.ElementsEntry") proto.RegisterMapType((map[string]Nil)(nil), "feature.KeyFeatureSet.ElementsEntry")
proto.RegisterType((*Nil)(nil), "feature.Nil") proto.RegisterType((*Nil)(nil), "feature.Nil")
proto.RegisterType((*ValueFeatureSet)(nil), "feature.ValueFeatureSet") proto.RegisterType((*AttributeFeatureSet)(nil), "feature.ValueFeatureSet")
proto.RegisterMapType((map[string]string)(nil), "feature.ValueFeatureSet.ElementsEntry") proto.RegisterMapType((map[string]string)(nil), "feature.ValueFeatureSet.ElementsEntry")
} }
@ -313,14 +313,14 @@ func (m *DomainFeatures) MarshalToSizedBuffer(dAtA []byte) (int, error) {
dAtA[i] = 0x1a dAtA[i] = 0x1a
} }
} }
if len(m.Values) > 0 { if len(m.Attributes) > 0 {
keysForValues := make([]string, 0, len(m.Values)) keysForValues := make([]string, 0, len(m.Attributes))
for k := range m.Values { for k := range m.Attributes {
keysForValues = append(keysForValues, string(k)) keysForValues = append(keysForValues, string(k))
} }
github_com_gogo_protobuf_sortkeys.Strings(keysForValues) github_com_gogo_protobuf_sortkeys.Strings(keysForValues)
for iNdEx := len(keysForValues) - 1; iNdEx >= 0; iNdEx-- { for iNdEx := len(keysForValues) - 1; iNdEx >= 0; iNdEx-- {
v := m.Values[string(keysForValues[iNdEx])] v := m.Attributes[string(keysForValues[iNdEx])]
baseI := i baseI := i
{ {
size, err := (&v).MarshalToSizedBuffer(dAtA[:i]) size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
@ -342,14 +342,14 @@ func (m *DomainFeatures) MarshalToSizedBuffer(dAtA []byte) (int, error) {
dAtA[i] = 0x12 dAtA[i] = 0x12
} }
} }
if len(m.Keys) > 0 { if len(m.Flags) > 0 {
keysForKeys := make([]string, 0, len(m.Keys)) keysForKeys := make([]string, 0, len(m.Flags))
for k := range m.Keys { for k := range m.Flags {
keysForKeys = append(keysForKeys, string(k)) keysForKeys = append(keysForKeys, string(k))
} }
github_com_gogo_protobuf_sortkeys.Strings(keysForKeys) github_com_gogo_protobuf_sortkeys.Strings(keysForKeys)
for iNdEx := len(keysForKeys) - 1; iNdEx >= 0; iNdEx-- { for iNdEx := len(keysForKeys) - 1; iNdEx >= 0; iNdEx-- {
v := m.Keys[string(keysForKeys[iNdEx])] v := m.Flags[string(keysForKeys[iNdEx])]
baseI := i baseI := i
{ {
size, err := (&v).MarshalToSizedBuffer(dAtA[:i]) size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
@ -458,7 +458,7 @@ func (m *InstanceFeatureSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil return len(dAtA) - i, nil
} }
func (m *KeyFeatureSet) Marshal() (dAtA []byte, err error) { func (m *FlagFeatureSet) Marshal() (dAtA []byte, err error) {
size := m.Size() size := m.Size()
dAtA = make([]byte, size) dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size]) n, err := m.MarshalToSizedBuffer(dAtA[:size])
@ -468,12 +468,12 @@ func (m *KeyFeatureSet) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil return dAtA[:n], nil
} }
func (m *KeyFeatureSet) MarshalTo(dAtA []byte) (int, error) { func (m *FlagFeatureSet) MarshalTo(dAtA []byte) (int, error) {
size := m.Size() size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size]) return m.MarshalToSizedBuffer(dAtA[:size])
} }
func (m *KeyFeatureSet) MarshalToSizedBuffer(dAtA []byte) (int, error) { func (m *FlagFeatureSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA) i := len(dAtA)
_ = i _ = i
var l int var l int
@ -533,7 +533,7 @@ func (m *Nil) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil return len(dAtA) - i, nil
} }
func (m *ValueFeatureSet) Marshal() (dAtA []byte, err error) { func (m *AttributeFeatureSet) Marshal() (dAtA []byte, err error) {
size := m.Size() size := m.Size()
dAtA = make([]byte, size) dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size]) n, err := m.MarshalToSizedBuffer(dAtA[:size])
@ -543,12 +543,12 @@ func (m *ValueFeatureSet) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil return dAtA[:n], nil
} }
func (m *ValueFeatureSet) MarshalTo(dAtA []byte) (int, error) { func (m *AttributeFeatureSet) MarshalTo(dAtA []byte) (int, error) {
size := m.Size() size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size]) return m.MarshalToSizedBuffer(dAtA[:size])
} }
func (m *ValueFeatureSet) MarshalToSizedBuffer(dAtA []byte) (int, error) { func (m *AttributeFeatureSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA) i := len(dAtA)
_ = i _ = i
var l int var l int
@ -597,8 +597,8 @@ func (m *DomainFeatures) Size() (n int) {
} }
var l int var l int
_ = l _ = l
if len(m.Keys) > 0 { if len(m.Flags) > 0 {
for k, v := range m.Keys { for k, v := range m.Flags {
_ = k _ = k
_ = v _ = v
l = v.Size() l = v.Size()
@ -606,8 +606,8 @@ func (m *DomainFeatures) Size() (n int) {
n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize))
} }
} }
if len(m.Values) > 0 { if len(m.Attributes) > 0 {
for k, v := range m.Values { for k, v := range m.Attributes {
_ = k _ = k
_ = v _ = v
l = v.Size() l = v.Size()
@ -659,7 +659,7 @@ func (m *InstanceFeatureSet) Size() (n int) {
return n return n
} }
func (m *KeyFeatureSet) Size() (n int) { func (m *FlagFeatureSet) Size() (n int) {
if m == nil { if m == nil {
return 0 return 0
} }
@ -686,7 +686,7 @@ func (m *Nil) Size() (n int) {
return n return n
} }
func (m *ValueFeatureSet) Size() (n int) { func (m *AttributeFeatureSet) Size() (n int) {
if m == nil { if m == nil {
return 0 return 0
} }
@ -713,24 +713,24 @@ func (this *DomainFeatures) String() string {
if this == nil { if this == nil {
return "nil" return "nil"
} }
keysForKeys := make([]string, 0, len(this.Keys)) keysForKeys := make([]string, 0, len(this.Flags))
for k := range this.Keys { for k := range this.Flags {
keysForKeys = append(keysForKeys, k) keysForKeys = append(keysForKeys, k)
} }
github_com_gogo_protobuf_sortkeys.Strings(keysForKeys) github_com_gogo_protobuf_sortkeys.Strings(keysForKeys)
mapStringForKeys := "map[string]KeyFeatureSet{" mapStringForKeys := "map[string]KeyFeatureSet{"
for _, k := range keysForKeys { for _, k := range keysForKeys {
mapStringForKeys += fmt.Sprintf("%v: %v,", k, this.Keys[k]) mapStringForKeys += fmt.Sprintf("%v: %v,", k, this.Flags[k])
} }
mapStringForKeys += "}" mapStringForKeys += "}"
keysForValues := make([]string, 0, len(this.Values)) keysForValues := make([]string, 0, len(this.Attributes))
for k := range this.Values { for k := range this.Attributes {
keysForValues = append(keysForValues, k) keysForValues = append(keysForValues, k)
} }
github_com_gogo_protobuf_sortkeys.Strings(keysForValues) github_com_gogo_protobuf_sortkeys.Strings(keysForValues)
mapStringForValues := "map[string]ValueFeatureSet{" mapStringForValues := "map[string]ValueFeatureSet{"
for _, k := range keysForValues { for _, k := range keysForValues {
mapStringForValues += fmt.Sprintf("%v: %v,", k, this.Values[k]) mapStringForValues += fmt.Sprintf("%v: %v,", k, this.Attributes[k])
} }
mapStringForValues += "}" mapStringForValues += "}"
keysForInstances := make([]string, 0, len(this.Instances)) keysForInstances := make([]string, 0, len(this.Instances))
@ -786,7 +786,7 @@ func (this *InstanceFeatureSet) String() string {
}, "") }, "")
return s return s
} }
func (this *KeyFeatureSet) String() string { func (this *FlagFeatureSet) String() string {
if this == nil { if this == nil {
return "nil" return "nil"
} }
@ -815,7 +815,7 @@ func (this *Nil) String() string {
}, "") }, "")
return s return s
} }
func (this *ValueFeatureSet) String() string { func (this *AttributeFeatureSet) String() string {
if this == nil { if this == nil {
return "nil" return "nil"
} }
@ -901,11 +901,11 @@ func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
if m.Keys == nil { if m.Flags == nil {
m.Keys = make(map[string]KeyFeatureSet) m.Flags = make(map[string]FlagFeatureSet)
} }
var mapkey string var mapkey string
mapvalue := &KeyFeatureSet{} mapvalue := &FlagFeatureSet{}
for iNdEx < postIndex { for iNdEx < postIndex {
entryPreIndex := iNdEx entryPreIndex := iNdEx
var wire uint64 var wire uint64
@ -979,7 +979,7 @@ func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
if postmsgIndex > l { if postmsgIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
mapvalue = &KeyFeatureSet{} mapvalue = &FlagFeatureSet{}
if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
return err return err
} }
@ -999,7 +999,7 @@ func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
iNdEx += skippy iNdEx += skippy
} }
} }
m.Keys[mapkey] = *mapvalue m.Flags[mapkey] = *mapvalue
iNdEx = postIndex iNdEx = postIndex
case 2: case 2:
if wireType != 2 { if wireType != 2 {
@ -1030,11 +1030,11 @@ func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
if m.Values == nil { if m.Attributes == nil {
m.Values = make(map[string]ValueFeatureSet) m.Attributes = make(map[string]AttributeFeatureSet)
} }
var mapkey string var mapkey string
mapvalue := &ValueFeatureSet{} mapvalue := &AttributeFeatureSet{}
for iNdEx < postIndex { for iNdEx < postIndex {
entryPreIndex := iNdEx entryPreIndex := iNdEx
var wire uint64 var wire uint64
@ -1108,7 +1108,7 @@ func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
if postmsgIndex > l { if postmsgIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
mapvalue = &ValueFeatureSet{} mapvalue = &AttributeFeatureSet{}
if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil { if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
return err return err
} }
@ -1128,7 +1128,7 @@ func (m *DomainFeatures) Unmarshal(dAtA []byte) error {
iNdEx += skippy iNdEx += skippy
} }
} }
m.Values[mapkey] = *mapvalue m.Attributes[mapkey] = *mapvalue
iNdEx = postIndex iNdEx = postIndex
case 3: case 3:
if wireType != 2 { if wireType != 2 {
@ -1541,7 +1541,7 @@ func (m *InstanceFeatureSet) Unmarshal(dAtA []byte) error {
} }
return nil return nil
} }
func (m *KeyFeatureSet) Unmarshal(dAtA []byte) error { func (m *FlagFeatureSet) Unmarshal(dAtA []byte) error {
l := len(dAtA) l := len(dAtA)
iNdEx := 0 iNdEx := 0
for iNdEx < l { for iNdEx < l {
@ -1770,7 +1770,7 @@ func (m *Nil) Unmarshal(dAtA []byte) error {
} }
return nil return nil
} }
func (m *ValueFeatureSet) Unmarshal(dAtA []byte) error { func (m *AttributeFeatureSet) Unmarshal(dAtA []byte) error {
l := len(dAtA) l := len(dAtA)
iNdEx := 0 iNdEx := 0
for iNdEx < l { for iNdEx < l {

14
pkg/api/feature/types.go
View file

@ -24,18 +24,18 @@ type Features map[string]*DomainFeatures
// DomainFeatures is the collection of all discovered features of one domain. // DomainFeatures is the collection of all discovered features of one domain.
type DomainFeatures struct { type DomainFeatures struct {
Keys map[string]KeyFeatureSet `protobuf:"bytes,1,rep,name=keys"` Flags map[string]FlagFeatureSet `protobuf:"bytes,1,rep,name=flags"`
Values map[string]ValueFeatureSet `protobuf:"bytes,2,rep,name=values"` Attributes map[string]AttributeFeatureSet `protobuf:"bytes,2,rep,name=vattributes"`
Instances map[string]InstanceFeatureSet `protobuf:"bytes,3,rep,name=instances"` Instances map[string]InstanceFeatureSet `protobuf:"bytes,3,rep,name=instances"`
} }
// KeyFeatureSet is a set of simple features only containing names without values. // FlagFeatureSet is a set of simple features only containing names without values.
type KeyFeatureSet struct { type FlagFeatureSet struct {
Elements map[string]Nil `protobuf:"bytes,1,rep,name=elements"` Elements map[string]Nil `protobuf:"bytes,1,rep,name=elements"`
} }
// ValueFeatureSet is a set of features having string value. // AttributeFeatureSet is a set of features having string value.
type ValueFeatureSet struct { type AttributeFeatureSet struct {
Elements map[string]string `protobuf:"bytes,1,rep,name=elements"` Elements map[string]string `protobuf:"bytes,1,rep,name=elements"`
} }

4
pkg/apis/nfd/v1alpha1/rule.go
View file

@ -178,12 +178,12 @@ func (m *FeatureMatcher) match(features map[string]*feature.DomainFeatures) (boo
var isMatch bool var isMatch bool
var err error 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) m, v, e := term.MatchExpressions.MatchGetKeys(f.Elements)
isMatch = m isMatch = m
err = e err = e
matches[domain][featureName] = v 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) m, v, e := term.MatchExpressions.MatchGetValues(f.Elements)
isMatch = m isMatch = m
err = e err = e

20
pkg/apis/nfd/v1alpha1/rule_test.go
View file

@ -60,8 +60,8 @@ func TestRule(t *testing.T) {
assert.Error(t, err, "matching against a missing feature type should have returned an error") assert.Error(t, err, "matching against a missing feature type should have returned an error")
// Test empty feature sets // Test empty feature sets
d.Keys["kf-1"] = feature.NewKeyFeatures() d.Flags["kf-1"] = feature.NewFlagFeatures()
d.Values["vf-1"] = feature.NewValueFeatures(nil) d.Attributes["vf-1"] = feature.NewAttributeFeatures(nil)
d.Instances["if-1"] = feature.NewInstanceFeatures(nil) d.Instances["if-1"] = feature.NewInstanceFeatures(nil)
m, err = r1.Execute(f) m, err = r1.Execute(f)
@ -73,8 +73,8 @@ func TestRule(t *testing.T) {
assert.Nil(t, m.Labels, "unexpected match") assert.Nil(t, m.Labels, "unexpected match")
// Test non-empty feature sets // Test non-empty feature sets
d.Keys["kf-1"].Elements["key-x"] = feature.Nil{} d.Flags["kf-1"].Elements["key-x"] = feature.Nil{}
d.Values["vf-1"].Elements["key-1"] = "val-x" d.Attributes["vf-1"].Elements["key-1"] = "val-x"
d.Instances["if-1"] = feature.NewInstanceFeatures([]feature.InstanceFeature{ d.Instances["if-1"] = feature.NewInstanceFeatures([]feature.InstanceFeature{
*feature.NewInstanceFeature(map[string]string{"attr-1": "val-x"})}) *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.Nilf(t, err, "unexpected error: %v", err)
assert.Nil(t, m.Labels, "keys should not have matched") 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) m, err = r2.Execute(f)
assert.Nilf(t, err, "unexpected error: %v", err) assert.Nilf(t, err, "unexpected error: %v", err)
assert.Equal(t, r2.Labels, m.Labels, "keys should have matched") 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.Nilf(t, err, "unexpected error: %v", err)
assert.Nil(t, m.Labels, "values should not have matched") 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) m, err = r3.Execute(f)
assert.Nilf(t, err, "unexpected error: %v", err) assert.Nilf(t, err, "unexpected error: %v", err)
assert.Equal(t, r3.Labels, m.Labels, "values should have matched") 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) { func TestTemplating(t *testing.T) {
f := map[string]*feature.DomainFeatures{ f := map[string]*feature.DomainFeatures{
"domain_1": &feature.DomainFeatures{ "domain_1": &feature.DomainFeatures{
Keys: map[string]feature.KeyFeatureSet{ Flags: map[string]feature.FlagFeatureSet{
"kf_1": feature.KeyFeatureSet{ "kf_1": feature.FlagFeatureSet{
Elements: map[string]feature.Nil{ Elements: map[string]feature.Nil{
"key-a": feature.Nil{}, "key-a": feature.Nil{},
"key-b": feature.Nil{}, "key-b": feature.Nil{},
@ -219,8 +219,8 @@ func TestTemplating(t *testing.T) {
}, },
}, },
}, },
Values: map[string]feature.ValueFeatureSet{ Attributes: map[string]feature.AttributeFeatureSet{
"vf_1": feature.ValueFeatureSet{ "vf_1": feature.AttributeFeatureSet{
Elements: map[string]string{ Elements: map[string]string{
"key-1": "val-1", "key-1": "val-1",
"keu-2": "val-2", "keu-2": "val-2",

4
pkg/nfd-master/nfd-master.go
View file

@ -534,8 +534,8 @@ func (m *nfdMaster) crLabels(r *pb.SetLabelsRequest) map[string]string {
} }
// Feed back rule output to features map for subsequent rules to match // Feed back rule output to features map for subsequent rules to match
feature.InsertFeatureValues(r.Features, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Labels) feature.InsertAttributeFeatures(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.Vars)
} }
} }

44
source/cpu/cpu.go
View file

@ -140,54 +140,54 @@ func (s *cpuSource) GetLabels() (source.FeatureLabels, error) {
features := s.GetFeatures() features := s.GetFeatures()
// CPUID // CPUID
for f := range features.Keys[CpuidFeature].Elements { for f := range features.Flags[CpuidFeature].Elements {
if s.cpuidFilter.unmask(f) { if s.cpuidFilter.unmask(f) {
labels["cpuid."+f] = true labels["cpuid."+f] = true
} }
} }
// CPU model // CPU model
for k, v := range features.Values[Cpumodel].Elements { for k, v := range features.Attributes[Cpumodel].Elements {
labels["model."+k] = v labels["model."+k] = v
} }
// Cstate // Cstate
for k, v := range features.Values[CstateFeature].Elements { for k, v := range features.Attributes[CstateFeature].Elements {
labels["cstate."+k] = v labels["cstate."+k] = v
} }
// Pstate // Pstate
for k, v := range features.Values[PstateFeature].Elements { for k, v := range features.Attributes[PstateFeature].Elements {
labels["pstate."+k] = v labels["pstate."+k] = v
} }
// RDT // RDT
for k := range features.Keys[RdtFeature].Elements { for k := range features.Flags[RdtFeature].Elements {
labels["rdt."+k] = true labels["rdt."+k] = true
} }
// Security // Security
for k, v := range features.Values[SecurityFeature].Elements { for k, v := range features.Attributes[SecurityFeature].Elements {
labels["security."+k] = v labels["security."+k] = v
} }
// SGX // SGX
for k, v := range features.Values[SgxFeature].Elements { for k, v := range features.Attributes[SgxFeature].Elements {
labels["sgx."+k] = v labels["sgx."+k] = v
} }
// Secure Execution // Secure Execution
for k, v := range features.Values[SeFeature].Elements { for k, v := range features.Attributes[SeFeature].Elements {
labels["se."+k] = v labels["se."+k] = v
} }
// SST // SST
for k, v := range features.Values[SstFeature].Elements { for k, v := range features.Attributes[SstFeature].Elements {
labels["power.sst_"+k] = v labels["power.sst_"+k] = v
} }
// Hyperthreading // 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 labels["hardware_multithreading"] = v
} }
@ -199,17 +199,17 @@ func (s *cpuSource) Discover() error {
s.features = feature.NewDomainFeatures() s.features = feature.NewDomainFeatures()
// Detect CPUID // Detect CPUID
s.features.Keys[CpuidFeature] = feature.NewKeyFeatures(getCpuidFlags()...) s.features.Flags[CpuidFeature] = feature.NewFlagFeatures(getCpuidFlags()...)
// Detect CPU model // Detect CPU model
s.features.Values[Cpumodel] = feature.NewValueFeatures(getCPUModel()) s.features.Attributes[Cpumodel] = feature.NewAttributeFeatures(getCPUModel())
// Detect cstate configuration // Detect cstate configuration
cstate, err := detectCstate() cstate, err := detectCstate()
if err != nil { if err != nil {
klog.Errorf("failed to detect cstate: %v", err) klog.Errorf("failed to detect cstate: %v", err)
} else { } else {
s.features.Values[CstateFeature] = feature.NewValueFeatures(cstate) s.features.Attributes[CstateFeature] = feature.NewAttributeFeatures(cstate)
} }
// Detect pstate features // Detect pstate features
@ -217,33 +217,33 @@ func (s *cpuSource) Discover() error {
if err != nil { if err != nil {
klog.Error(err) klog.Error(err)
} }
s.features.Values[PstateFeature] = feature.NewValueFeatures(pstate) s.features.Attributes[PstateFeature] = feature.NewAttributeFeatures(pstate)
// Detect RDT features // Detect RDT features
s.features.Keys[RdtFeature] = feature.NewKeyFeatures(discoverRDT()...) s.features.Flags[RdtFeature] = feature.NewFlagFeatures(discoverRDT()...)
// Detect SGX features // Detect SGX features
s.features.Values[SecurityFeature] = feature.NewValueFeatures(discoverSecurity()) s.features.Attributes[SecurityFeature] = feature.NewAttributeFeatures(discoverSecurity())
// Detect SGX features // Detect SGX features
// //
// DEPRECATED in v0.12: will be removed in the future // DEPRECATED in v0.12: will be removed in the future
if val, ok := s.features.Values[SecurityFeature].Elements["sgx.enabled"]; ok { if val, ok := s.features.Attributes[SecurityFeature].Elements["sgx.enabled"]; ok {
s.features.Values[SgxFeature] = feature.NewValueFeatures(map[string]string{"enabled": val}) s.features.Attributes[SgxFeature] = feature.NewAttributeFeatures(map[string]string{"enabled": val})
} }
// Detect Secure Execution features // Detect Secure Execution features
// //
// DEPRECATED in v0.12: will be removed in the future // DEPRECATED in v0.12: will be removed in the future
if val, ok := s.features.Values[SecurityFeature].Elements["se.enabled"]; ok { if val, ok := s.features.Attributes[SecurityFeature].Elements["se.enabled"]; ok {
s.features.Values[SeFeature] = feature.NewValueFeatures(map[string]string{"enabled": val}) s.features.Attributes[SeFeature] = feature.NewAttributeFeatures(map[string]string{"enabled": val})
} }
// Detect SST features // Detect SST features
s.features.Values[SstFeature] = feature.NewValueFeatures(discoverSST()) s.features.Attributes[SstFeature] = feature.NewAttributeFeatures(discoverSST())
// Detect hyper-threading // 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) utils.KlogDump(3, "discovered cpu features:", " ", s.features)

4
source/custom/custom.go
View file

@ -129,8 +129,8 @@ func (s *customSource) GetLabels() (source.FeatureLabels, error) {
labels[n] = v labels[n] = v
} }
// Feed back rule output to features map for subsequent rules to match // Feed back rule output to features map for subsequent rules to match
feature.InsertFeatureValues(domainFeatures, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Labels) feature.InsertAttributeFeatures(domainFeatures, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Labels)
feature.InsertFeatureValues(domainFeatures, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Vars) feature.InsertAttributeFeatures(domainFeatures, nfdv1alpha1.RuleBackrefDomain, nfdv1alpha1.RuleBackrefFeature, ruleOut.Vars)
} }
return labels, nil return labels, nil
} }

2
source/custom/rules/cpuid_rule.go
View file

@ -31,7 +31,7 @@ type CpuIDRule struct {
// Match checks if CpuId rule matches. // Match checks if CpuId rule matches.
func (r *CpuIDRule) Match() (bool, error) { 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 { if !ok {
return false, fmt.Errorf("cpuid information not available") return false, fmt.Errorf("cpuid information not available")
} }

2
source/custom/rules/loaded_kmod_rule.go
View file

@ -31,7 +31,7 @@ type LoadedKModRule struct {
// Match loaded kernel modules on provided list of kernel modules // Match loaded kernel modules on provided list of kernel modules
func (r *LoadedKModRule) Match() (bool, error) { 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 { if !ok {
return false, fmt.Errorf("info about loaded modules not available") return false, fmt.Errorf("info about loaded modules not available")
} }

2
source/custom/rules/nodename_rule.go
View file

@ -32,7 +32,7 @@ type NodenameRule struct {
// Match checks if node name matches the rule. // Match checks if node name matches the rule.
func (r *NodenameRule) Match() (bool, error) { 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 == "" { if !ok || nodeName == "" {
return false, fmt.Errorf("node name not available") return false, fmt.Errorf("node name not available")
} }

4
source/fake/fake.go
View file

@ -118,8 +118,8 @@ func (s *fakeSource) SetConfig(conf source.Config) {
func (s *fakeSource) Discover() error { func (s *fakeSource) Discover() error {
s.features = feature.NewDomainFeatures() s.features = feature.NewDomainFeatures()
s.features.Keys[FlagFeature] = feature.NewKeyFeatures(s.config.FlagFeatures...) s.features.Flags[FlagFeature] = feature.NewFlagFeatures(s.config.FlagFeatures...)
s.features.Values[AttributeFeature] = feature.NewValueFeatures(s.config.AttributeFeatures) s.features.Attributes[AttributeFeature] = feature.NewAttributeFeatures(s.config.AttributeFeatures)
instances := make([]feature.InstanceFeature, len(s.config.InstanceFeatures)) instances := make([]feature.InstanceFeature, len(s.config.InstanceFeatures))
for i, instanceAttributes := range s.config.InstanceFeatures { for i, instanceAttributes := range s.config.InstanceFeatures {

14
source/kernel/kernel.go
View file

@ -98,7 +98,7 @@ func (s *kernelSource) GetLabels() (source.FeatureLabels, error) {
labels := source.FeatureLabels{} labels := source.FeatureLabels{}
features := s.GetFeatures() features := s.GetFeatures()
for k, v := range features.Values[VersionFeature].Elements { for k, v := range features.Attributes[VersionFeature].Elements {
labels[VersionFeature+"."+k] = v 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" labels["selinux.enabled"] = "true"
} }
@ -123,7 +123,7 @@ func (s *kernelSource) Discover() error {
if version, err := parseVersion(); err != nil { if version, err := parseVersion(); err != nil {
klog.Errorf("failed to get kernel version: %s", err) klog.Errorf("failed to get kernel version: %s", err)
} else { } else {
s.features.Values[VersionFeature] = feature.NewValueFeatures(version) s.features.Attributes[VersionFeature] = feature.NewAttributeFeatures(version)
} }
// Read kconfig // Read kconfig
@ -131,21 +131,21 @@ func (s *kernelSource) Discover() error {
s.legacyKconfig = nil s.legacyKconfig = nil
klog.Errorf("failed to read kconfig: %s", err) klog.Errorf("failed to read kconfig: %s", err)
} else { } else {
s.features.Values[ConfigFeature] = feature.NewValueFeatures(realKconfig) s.features.Attributes[ConfigFeature] = feature.NewAttributeFeatures(realKconfig)
s.legacyKconfig = legacyKconfig s.legacyKconfig = legacyKconfig
} }
if kmods, err := getLoadedModules(); err != nil { if kmods, err := getLoadedModules(); err != nil {
klog.Errorf("failed to get loaded kernel modules: %v", err) klog.Errorf("failed to get loaded kernel modules: %v", err)
} else { } else {
s.features.Keys[LoadedModuleFeature] = feature.NewKeyFeatures(kmods...) s.features.Flags[LoadedModuleFeature] = feature.NewFlagFeatures(kmods...)
} }
if selinux, err := SelinuxEnabled(); err != nil { if selinux, err := SelinuxEnabled(); err != nil {
klog.Warning(err) klog.Warning(err)
} else { } else {
s.features.Values[SelinuxFeature] = feature.NewValueFeatures(nil) s.features.Attributes[SelinuxFeature] = feature.NewAttributeFeatures(nil)
s.features.Values[SelinuxFeature].Elements["enabled"] = strconv.FormatBool(selinux) s.features.Attributes[SelinuxFeature].Elements["enabled"] = strconv.FormatBool(selinux)
} }
utils.KlogDump(3, "discovered kernel features:", " ", s.features) utils.KlogDump(3, "discovered kernel features:", " ", s.features)

4
source/local/local.go
View file

@ -88,7 +88,7 @@ func (s *localSource) GetLabels() (source.FeatureLabels, error) {
labels := make(source.FeatureLabels) labels := make(source.FeatureLabels)
features := s.GetFeatures() features := s.GetFeatures()
for k, v := range features.Values[LabelFeature].Elements { for k, v := range features.Attributes[LabelFeature].Elements {
labels[k] = v labels[k] = v
} }
return labels, nil 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) utils.KlogDump(3, "discovered local features:", " ", s.features)

4
source/memory/memory.go
View file

@ -63,7 +63,7 @@ func (s *memorySource) GetLabels() (source.FeatureLabels, error) {
features := s.GetFeatures() features := s.GetFeatures()
// NUMA // 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 labels["numa"] = true
} }
@ -89,7 +89,7 @@ func (s *memorySource) Discover() error {
if numa, err := detectNuma(); err != nil { if numa, err := detectNuma(); err != nil {
klog.Errorf("failed to detect NUMA nodes: %v", err) klog.Errorf("failed to detect NUMA nodes: %v", err)
} else { } else {
s.features.Values[NumaFeature] = feature.ValueFeatureSet{Elements: numa} s.features.Attributes[NumaFeature] = feature.AttributeFeatureSet{Elements: numa}
} }
// Detect NVDIMM // Detect NVDIMM

4
source/source_test.go
View file

@ -73,8 +73,8 @@ func TestFeatureSources(t *testing.T) {
f := s.GetFeatures() f := s.GetFeatures()
assert.NotNil(t, f, msg) assert.NotNil(t, f, msg)
assert.Empty(t, (*f).Keys, msg) assert.Empty(t, (*f).Flags, msg)
assert.Empty(t, (*f).Values, msg) assert.Empty(t, (*f).Attributes, msg)
assert.Empty(t, (*f).Instances, msg) assert.Empty(t, (*f).Instances, msg)
} }
} }

10
source/system/system.go
View file

@ -67,7 +67,7 @@ func (s *systemSource) GetLabels() (source.FeatureLabels, error) {
features := s.GetFeatures() features := s.GetFeatures()
for _, key := range osReleaseFields { 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 feature := "os_release." + key
labels[feature] = value labels[feature] = value
} }
@ -80,21 +80,21 @@ func (s *systemSource) Discover() error {
s.features = feature.NewDomainFeatures() s.features = feature.NewDomainFeatures()
// Get node name // Get node name
s.features.Values[NameFeature] = feature.NewValueFeatures(nil) s.features.Attributes[NameFeature] = feature.NewAttributeFeatures(nil)
s.features.Values[NameFeature].Elements["nodename"] = os.Getenv("NODE_NAME") s.features.Attributes[NameFeature].Elements["nodename"] = os.Getenv("NODE_NAME")
// Get os-release information // Get os-release information
release, err := parseOSRelease() release, err := parseOSRelease()
if err != nil { if err != nil {
klog.Errorf("failed to get os-release: %s", err) klog.Errorf("failed to get os-release: %s", err)
} else { } else {
s.features.Values[OsReleaseFeature] = feature.NewValueFeatures(release) s.features.Attributes[OsReleaseFeature] = feature.NewAttributeFeatures(release)
if v, ok := release["VERSION_ID"]; ok { if v, ok := release["VERSION_ID"]; ok {
versionComponents := splitVersion(v) versionComponents := splitVersion(v)
for subKey, subValue := range versionComponents { for subKey, subValue := range versionComponents {
if subValue != "" { if subValue != "" {
s.features.Values[OsReleaseFeature].Elements["VERSION_ID."+subKey] = subValue s.features.Attributes[OsReleaseFeature].Elements["VERSION_ID."+subKey] = subValue
} }
} }
} }