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-14 20:56:42 +00:00
Code Activity

Merge pull request #908 from marquiz/devel/type-rename

Browse source 
pkg/api/feature: rename types
This commit is contained in:
Kubernetes Prow Robot 2022-10-06 01:59:51 -07:00 • committed by GitHub
commit 4097198848
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
18 changed files with 777 additions and 777 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
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
}
}

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

File diff suppressed because it is too large Load diff

24
pkg/api/feature/generated.proto
View file

@ -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;
}

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.
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"`
}

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 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

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")
// 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",

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

@ -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)
}
}

44
source/cpu/cpu.go
View file

@ -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)

4
source/custom/custom.go
View file

@ -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
}

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

@ -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")
}

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
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")
}

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

@ -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")
}

4
source/fake/fake.go
View file

@ -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 {

14
source/kernel/kernel.go
View file

@ -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)

4
source/local/local.go
View file

@ -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)

4
source/memory/memory.go
View file

@ -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

4
source/source_test.go
View file

@ -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)
}
}

10
source/system/system.go
View file

@ -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
}
}
}