kubectl-nfd: Add NodeFeatureGroup dryrun, validation and test

Signed-off-by: Oleg Zhurakivskyy <oleg.zhurakivskyy@intel.com>

Author: ozhuraki

cmd/kubectl-nfd/subcmd/dryrun.go

@@ -26,34 +26,34 @@ import (
 
 var dryrunCmd = &cobra.Command{
 	Use:   "dryrun",
-	Short: "Process a NodeFeatureRule file against a NodeFeature file",
-	Long:  `Process a NodeFeatureRule file against a local NodeFeature file to dry run the rule against a node before applying it to a cluster`,
+	Short: "Process a NodeFeatureRule or NodeFeatureGroup file against a NodeFeature file",
+	Long:  `Process a NodeFeatureRule or NodeFeatureGroup file against a local NodeFeature file to dry run the rule against a node before applying it to a cluster`,
+	PreRunE: func(cmd *cobra.Command, args []string) error {
+		if rule == "" {
+			return fmt.Errorf("--rule-file must be specified")
+		}
+		return nil
+	},
 	Run: func(cmd *cobra.Command, args []string) {
-		fmt.Printf("Evaluating NodeFeatureRule %q against NodeFeature %q\n", nodefeaturerule, nodefeature)
-		err := kubectlnfd.DryRun(nodefeaturerule, nodefeature)
-		if len(err) > 0 {
-			fmt.Printf("NodeFeatureRule %q is not valid for NodeFeature %q\n", nodefeaturerule, nodefeature)
-			for _, e := range err {
+		fmt.Printf("Evaluating %q against NodeFeature %q\n", rule, nodefeature)
+		errs := kubectlnfd.DryRun(rule, nodefeature)
+		if len(errs) > 0 {
+			fmt.Printf("%q is not valid for NodeFeature %q\n", rule, nodefeature)
+			for _, e := range errs {
 				cmd.PrintErrln(e)
 			}
-			// Return non-zero exit code to indicate failure
 			os.Exit(1)
 		}
-		fmt.Printf("NodeFeatureRule %q is valid for NodeFeature %q\n", nodefeaturerule, nodefeature)
+		fmt.Printf("%q is valid for NodeFeature %q\n", rule, nodefeature)
 	},
 }
 
 func init() {
 	RootCmd.AddCommand(dryrunCmd)
 
-	dryrunCmd.Flags().StringVarP(&nodefeaturerule, "nodefeaturerule-file", "f", "", "Path to the NodeFeatureRule file to validate")
-	dryrunCmd.Flags().StringVarP(&nodefeature, "nodefeature-file", "n", "", "Path to the NodeFeature file to validate against")
-	err := dryrunCmd.MarkFlagRequired("nodefeaturerule-file")
-	if err != nil {
-		panic(err)
-	}
-	err = dryrunCmd.MarkFlagRequired("nodefeature-file")
-	if err != nil {
+	dryrunCmd.Flags().StringVarP(&rule, "rule-file", "f", "", "Path to the NodeFeatureRule or NodeFeatureGroup file to dry run")
+	dryrunCmd.Flags().StringVarP(&nodefeature, "nodefeature-file", "n", "", "Path to the NodeFeature file to dry run against")
+	if err := dryrunCmd.MarkFlagRequired("nodefeature-file"); err != nil {
 		panic(err)
 	}
 }

cmd/kubectl-nfd/subcmd/root.go

@@ -24,8 +24,8 @@ import (
 )
 
 var (
-	// Path to the NodeFeatureRule file to validate
-	nodefeaturerule string
+	// Path to the NodeFeatureRule or NodeFeatureGroup file
+	rule string
 	// Path to the NodeFeature file to run against the NodeFeatureRule
 	nodefeature string
 	// Node to validate against

cmd/kubectl-nfd/subcmd/test.go

@@ -26,32 +26,34 @@ import (
 
 var testCmd = &cobra.Command{
 	Use:   "test",
-	Short: "Test a NodeFeatureRule file against a Node",
-	Long:  `Test a NodeFeatureRule file against a Node to ensure it is valid before applying it to a cluster`,
+	Short: "Test a NodeFeatureRule or NodeFeatureGroup file against a Node",
+	Long:  `Test a NodeFeatureRule or NodeFeatureGroup file against a Node to ensure it is valid before applying it to a cluster`,
+	PreRunE: func(cmd *cobra.Command, args []string) error {
+		if rule == "" {
+			return fmt.Errorf("--rule-file must be specified")
+		}
+		return nil
+	},
 	Run: func(cmd *cobra.Command, args []string) {
-		fmt.Printf("Evaluating NodeFeatureRule against Node %s\n", node)
-		err := kubectlnfd.Test(nodefeaturerule, node, kubeconfig)
-		if len(err) > 0 {
-			fmt.Printf("NodeFeatureRule is not valid for Node %s\n", node)
-			for _, e := range err {
+		fmt.Printf("Evaluating %s against Node %s\n", rule, node)
+		errs := kubectlnfd.Test(rule, node, kubeconfig)
+		if len(errs) > 0 {
+			fmt.Printf("%s is not valid for Node %s\n", rule, node)
+			for _, e := range errs {
 				cmd.PrintErrln(e)
 			}
-			// Return non-zero exit code to indicate failure
 			os.Exit(1)
 		}
-		fmt.Printf("NodeFeatureRule is valid for Node %s\n", node)
+		fmt.Printf("%s is valid for Node %s\n", rule, node)
 	},
 }
 
 func init() {
 	RootCmd.AddCommand(testCmd)
 
-	testCmd.Flags().StringVarP(&nodefeaturerule, "nodefeaturerule-file", "f", "", "Path to the NodeFeatureRule file to validate")
-	testCmd.Flags().StringVarP(&node, "nodename", "n", "", "Node to validate against")
+	testCmd.Flags().StringVarP(&rule, "rule-file", "f", "", "Path to the NodeFeatureRule or NodeFeatureGroup file to test")
+	testCmd.Flags().StringVarP(&node, "nodename", "n", "", "Node to test against")
 	testCmd.Flags().StringVarP(&kubeconfig, "kubeconfig", "k", "", "kubeconfig file to use")
-	if err := testCmd.MarkFlagRequired("nodefeaturerule-file"); err != nil {
-		panic(err)
-	}
 	if err := testCmd.MarkFlagRequired("nodename"); err != nil {
 		panic(err)
 	}

cmd/kubectl-nfd/subcmd/validate.go

@@ -26,29 +26,30 @@ import (
 
 var validateCmd = &cobra.Command{
 	Use:   "validate",
-	Short: "Validate a NodeFeatureRule file",
-	Long:  `Validate a NodeFeatureRule file to ensure it is valid before applying it to a cluster`,
+	Short: "Validate a NodeFeatureRule or NodeFeatureGroup file",
+	Long:  `Validate a NodeFeatureRule or NodeFeatureGroup file to ensure it is valid before applying it to a cluster`,
+	PreRunE: func(cmd *cobra.Command, args []string) error {
+		if rule == "" {
+			return fmt.Errorf("--rule-file must be specified")
+		}
+		return nil
+	},
 	Run: func(cmd *cobra.Command, args []string) {
-		fmt.Printf("Validating NodeFeatureRule %s\n", nodefeaturerule)
-		err := kubectlnfd.ValidateNFR(nodefeaturerule)
-		if len(err) > 0 {
-			fmt.Printf("NodeFeatureRule %s is not valid\n", nodefeaturerule)
-			for _, e := range err {
+		fmt.Printf("Validating %s\n", rule)
+		errs := kubectlnfd.Validate(rule)
+		if len(errs) > 0 {
+			fmt.Printf("%s is not valid\n", rule)
+			for _, e := range errs {
 				cmd.PrintErrln(e)
 			}
-			// Return non-zero exit code to indicate failure
 			os.Exit(1)
 		}
-		fmt.Printf("NodeFeatureRule %s is valid\n", nodefeaturerule)
+		fmt.Printf("%s is valid\n", rule)
 	},
 }
 
 func init() {
 	RootCmd.AddCommand(validateCmd)
 
-	validateCmd.Flags().StringVarP(&nodefeaturerule, "nodefeaturerule-file", "f", "", "Path to the NodeFeatureRule file to validate")
-	err := validateCmd.MarkFlagRequired("nodefeaturerule-file")
-	if err != nil {
-		panic(err)
-	}
+	validateCmd.Flags().StringVarP(&rule, "rule-file", "f", "", "Path to the NodeFeatureRule or NodeFeatureGroup file to validate")
 }

docs/usage/kubectl-plugin.md

@@ -22,7 +22,8 @@ sort: 10
 ## Overview
 
 The `kubectl` plugin `kubectl nfd` can be used to validate/dryrun and test
-NodeFeatureRule objects. It can be installed with the following command:
+NodeFeatureRule and NodeFeatureGroup objects. It can be installed with the
+following command:
 
 ```bash
 git clone https://github.com/kubernetes-sigs/node-feature-discovery
@@ -34,37 +35,60 @@ mv ./bin/kubectl-nfd ${KUBECTL_PATH}
 
 ### Validate
 
-The plugin can be used to validate a NodeFeatureRule object:
+The plugin can be used to validate a NodeFeatureRule or NodeFeatureGroup object.
+The kind is detected automatically from the file content:
 
 ```bash
-kubectl nfd validate -f <nodefeaturerule.yaml>
+kubectl nfd validate -f <nodefeaturerule-or-nodefeaturegroup.yaml>
+```
+
+You can use the example files to try it out:
+
+```bash
+$ kubectl nfd validate -f examples/nodefeaturegroup.yaml
+Validating examples/nodefeaturegroup.yaml
+Validating rule:  kernel version
+Validating rule:  veth kernel module
+examples/nodefeaturegroup.yaml is valid
 ```
 
 ### Test
 
-The plugin can be used to test a NodeFeatureRule object against a node:
+The plugin can be used to test a NodeFeatureRule or NodeFeatureGroup object
+against a node. The kind is detected automatically from the file content:
 
 ```bash
-kubectl nfd test -f <nodefeaturerule.yaml> -n <node-name>
+kubectl nfd test -f <nodefeaturerule-or-nodefeaturegroup.yaml> -n <node-name>
 ```
 
 ### DryRun
 
-The plugin can be used to DryRun a NodeFeatureRule object against a NodeFeature
-file:
+The plugin can be used to dry run a NodeFeatureRule or NodeFeatureGroup object
+against a NodeFeature file. The kind is detected automatically from the file
+content:
 
 ```bash
 kubectl get -n node-feature-discovery nodefeature <nodename> -o yaml > <nodefeature.yaml>
-kubectl nfd dryrun -f <nodefeaturerule.yaml> -n <nodefeature.yaml>
+kubectl nfd dryrun -f <nodefeaturerule-or-nodefeaturegroup.yaml> -n <nodefeature.yaml>
 ```
 
-Or you can use the example NodeFeature file(it is a minimal NodeFeature file):
+For example, using the example files:
 
 ```bash
 $ kubectl nfd dryrun -f examples/nodefeaturerule.yaml -n examples/nodefeature.yaml
-Evaluating NodeFeatureRule "examples/nodefeaturerule.yaml" against NodeFeature "examples/nodefeature.yaml"
+Evaluating "examples/nodefeaturerule.yaml" against NodeFeature "examples/nodefeature.yaml"
 Processing rule:  my sample rule
 *** Labels ***
 vendor.io/my-sample-feature=true
-NodeFeatureRule "examples/nodefeaturerule.yaml" is valid for NodeFeature "examples/nodefeature.yaml"
+"examples/nodefeaturerule.yaml" is valid for NodeFeature "examples/nodefeature.yaml"
+```
+
+```bash
+$ kubectl nfd dryrun -f examples/nodefeaturegroup.yaml -n examples/nodefeature.yaml
+Evaluating "examples/nodefeaturegroup.yaml" against NodeFeature "examples/nodefeature.yaml"
+Processing rule:  kernel version
+Rule "kernel version" did not match
+Processing rule:  veth kernel module
+Rule "veth kernel module" did not match
+"examples/nodefeaturegroup.yaml" is valid for NodeFeature "examples/nodefeature.yaml"
 ```

examples/nodefeaturegroup.yaml

@@ -9,3 +9,8 @@ spec:
         - feature: kernel.version
           matchExpressions:
             major: {op: In, value: ["6"]}
+    - name: "veth kernel module"
+      matchFeatures:
+        - feature: kernel.loadedmodule
+          matchExpressions:
+            veth: {op: Exists}

pkg/kubectl-nfd/dryrun.go

@@ -31,34 +31,51 @@ import (
 	"sigs.k8s.io/node-feature-discovery/pkg/apis/nfd/validate"
 )
 
-func DryRun(nodefeaturerulepath, nodefeaturepath string) []error {
+func processNodeFeatureGroup(nodeFeatureGroup nfdv1alpha1.NodeFeatureGroup, nodeFeature nfdv1alpha1.NodeFeatureSpec) []error {
 	var errs []error
-	nfr := nfdv1alpha1.NodeFeatureRule{}
-	nf := nfdv1alpha1.NodeFeature{}
 
-	nfrFile, err := os.ReadFile(nodefeaturerulepath)
-	if err != nil {
-		return []error{fmt.Errorf("error reading NodeFeatureRule file: %w", err)}
+	for _, rule := range nodeFeatureGroup.Spec.Rules {
+		fmt.Println("Processing rule: ", rule.Name)
+		ruleOut, err := nodefeaturerule.ExecuteGroupRule(&rule, &nodeFeature.Features, true)
+		if err != nil {
+			errs = append(errs, fmt.Errorf("failed to process rule %q: %w", rule.Name, err))
+			continue
+		}
+		if ruleOut.MatchStatus == nil || !ruleOut.MatchStatus.IsMatch {
+			fmt.Printf("Rule %q did not match\n", rule.Name)
+			continue
+		}
+		fmt.Printf("Rule %q matched\n", rule.Name)
+		if len(ruleOut.Vars) > 0 {
+			fmt.Println("***\tVars\t***")
+			for k, v := range ruleOut.Vars {
+				fmt.Printf("%s=%s\n", k, v)
+			}
+		}
 	}
 
-	err = yaml.Unmarshal(nfrFile, &nfr)
-	if err != nil {
-		return []error{fmt.Errorf("error parsing NodeFeatureRule: %w", err)}
-	}
+	return errs
+}
 
+func DryRun(resourcepath, nodefeaturepath string) []error {
 	nfFile, err := os.ReadFile(nodefeaturepath)
 	if err != nil {
-		return []error{fmt.Errorf("error reading NodeFeatureRule file: %w", err)}
+		return []error{fmt.Errorf("error reading NodeFeature file: %w", err)}
 	}
-
-	err = yaml.Unmarshal(nfFile, &nf)
-	if err != nil {
-		return []error{fmt.Errorf("error parsing NodeFeatureRule: %w", err)}
+	nf := nfdv1alpha1.NodeFeature{}
+	if err = yaml.Unmarshal(nfFile, &nf); err != nil {
+		return []error{fmt.Errorf("error parsing NodeFeature: %w", err)}
 	}
 
-	errs = append(errs, processNodeFeatureRule(nfr, nf.Spec)...)
-
-	return errs
+	t := parseRuleFile(resourcepath)
+	switch o := t.(type) {
+	case *nfdv1alpha1.NodeFeatureRule:
+		return processNodeFeatureRule(*o, nf.Spec)
+	case *nfdv1alpha1.NodeFeatureGroup:
+		return processNodeFeatureGroup(*o, nf.Spec)
+	default:
+		return []error{fmt.Errorf("unsupported resource %v: must be NodeFeatureRule or NodeFeatureGroup", t)}
+	}
 }
 
 func processNodeFeatureRule(nodeFeatureRule nfdv1alpha1.NodeFeatureRule, nodeFeature nfdv1alpha1.NodeFeatureSpec) []error {

pkg/kubectl-nfd/test.go

@@ -19,7 +19,6 @@ package kubectlnfd
 import (
 	"context"
 	"fmt"
-	"os"
 	"strings"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -28,29 +27,24 @@ import (
 
 	nfdclientset "sigs.k8s.io/node-feature-discovery/api/generated/clientset/versioned"
 	nfdv1alpha1 "sigs.k8s.io/node-feature-discovery/api/nfd/v1alpha1"
-
-	"sigs.k8s.io/yaml"
 )
 
-func Test(nodefeaturerulepath, nodeName, kubeconfig string) []error {
-	var errs []error
-	var err error
-
+func getNodeFeatures(nodeName, kubeconfig string) (*nfdv1alpha1.NodeFeatureSpec, error) {
 	loadingRules := clientcmd.NewDefaultClientConfigLoadingRules()
 	if kubeconfig != "" {
 		loadingRules.ExplicitPath = kubeconfig
 	}
 	config, err := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(loadingRules, &clientcmd.ConfigOverrides{}).ClientConfig()
 	if err != nil {
-		return []error{fmt.Errorf("error building kubeconfig: %w", err)}
+		return nil, fmt.Errorf("error building kubeconfig: %w", err)
 	}
 
 	nfdClient := nfdclientset.NewForConfigOrDie(config)
 
 	sel := k8sLabels.SelectorFromSet(k8sLabels.Set{nfdv1alpha1.NodeFeatureObjNodeNameLabel: nodeName})
 	list, err := nfdClient.NfdV1alpha1().NodeFeatures(metav1.NamespaceAll).List(context.TODO(), metav1.ListOptions{LabelSelector: sel.String()})
 	if err != nil {
-		return []error{fmt.Errorf("failed to get NodeFeature resources for node %q: %w", nodeName, err)}
+		return nil, fmt.Errorf("failed to get NodeFeature resources for node %q: %w", nodeName, err)
 	}
 	objs := list.Items
 	names := make([]string, len(objs))
@@ -67,19 +61,24 @@ func Test(nodefeaturerulepath, nodeName, kubeconfig string) []error {
 			s.MergeInto(features)
 		}
 	}
+	return features, nil
+}
 
-	nfrFile, err := os.ReadFile(nodefeaturerulepath)
+// Test reads a NodeFeatureRule or NodeFeatureGroup file and evaluates it against
+// the NodeFeature objects of the given node. The kind is detected automatically.
+func Test(resourcepath, nodeName, kubeconfig string) []error {
+	features, err := getNodeFeatures(nodeName, kubeconfig)
 	if err != nil {
-		return []error{fmt.Errorf("error reading NodeFeatureRule file: %w", err)}
+		return []error{err}
 	}
 
-	nfr := nfdv1alpha1.NodeFeatureRule{}
-	err = yaml.Unmarshal(nfrFile, &nfr)
-	if err != nil {
-		return []error{fmt.Errorf("error parsing NodeFeatureRule: %w", err)}
+	t := parseRuleFile(resourcepath)
+	switch o := t.(type) {
+	case *nfdv1alpha1.NodeFeatureRule:
+		return processNodeFeatureRule(*o, *features)
+	case *nfdv1alpha1.NodeFeatureGroup:
+		return processNodeFeatureGroup(*o, *features)
+	default:
+		return []error{fmt.Errorf("unsupported resource %v: must be NodeFeatureRule or NodeFeatureGroup", t)}
 	}
-
-	errs = append(errs, processNodeFeatureRule(nfr, *features)...)
-
-	return errs
 }