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,50 @@ 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 nodefeaturerule == "" && nodefeaturegroup == "" {
+			return fmt.Errorf("at least one of --nodefeaturerule-file or --nodefeaturegroup-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 {
-				cmd.PrintErrln(e)
+		if nodefeaturerule != "" {
+			fmt.Printf("Evaluating NodeFeatureRule %q against NodeFeature %q\n", nodefeaturerule, nodefeature)
+			errs := kubectlnfd.DryRun(nodefeaturerule, nodefeature)
+			if len(errs) > 0 {
+				fmt.Printf("NodeFeatureRule %q is not valid for NodeFeature %q\n", nodefeaturerule, nodefeature)
+				for _, e := range errs {
+					cmd.PrintErrln(e)
+				}
+				os.Exit(1)
 			}
-			// Return non-zero exit code to indicate failure
-			os.Exit(1)
+			fmt.Printf("NodeFeatureRule %q is valid for NodeFeature %q\n", nodefeaturerule, nodefeature)
+		}
+
+		if nodefeaturegroup != "" {
+			fmt.Printf("Evaluating NodeFeatureGroup %q against NodeFeature %q\n", nodefeaturegroup, nodefeature)
+			errs := kubectlnfd.DryRunNFG(nodefeaturegroup, nodefeature)
+			if len(errs) > 0 {
+				fmt.Printf("NodeFeatureGroup %q is not valid for NodeFeature %q\n", nodefeaturegroup, nodefeature)
+				for _, e := range errs {
+					cmd.PrintErrln(e)
+				}
+				os.Exit(1)
+			}
+			fmt.Printf("NodeFeatureGroup %q is valid for NodeFeature %q\n", nodefeaturegroup, nodefeature)
 		}
-		fmt.Printf("NodeFeatureRule %q is valid for NodeFeature %q\n", nodefeaturerule, 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(&nodefeaturerule, "nodefeaturerule-file", "f", "", "Path to the NodeFeatureRule file to dry run")
+	dryrunCmd.Flags().StringVarP(&nodefeaturegroup, "nodefeaturegroup-file", "g", "", "Path to the 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

@@ -26,6 +26,8 @@ import (
 var (
 	// Path to the NodeFeatureRule file to validate
 	nodefeaturerule string
+	// Path to the NodeFeatureGroup file to validate
+	nodefeaturegroup 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,50 @@ 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 nodefeaturerule == "" && nodefeaturegroup == "" {
+			return fmt.Errorf("at least one of --nodefeaturerule-file or --nodefeaturegroup-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 {
-				cmd.PrintErrln(e)
+		if nodefeaturerule != "" {
+			fmt.Printf("Evaluating NodeFeatureRule against Node %s\n", node)
+			errs := kubectlnfd.Test(nodefeaturerule, node, kubeconfig)
+			if len(errs) > 0 {
+				fmt.Printf("NodeFeatureRule is not valid for Node %s\n", node)
+				for _, e := range errs {
+					cmd.PrintErrln(e)
+				}
+				os.Exit(1)
 			}
-			// Return non-zero exit code to indicate failure
-			os.Exit(1)
+			fmt.Printf("NodeFeatureRule is valid for Node %s\n", node)
+		}
+
+		if nodefeaturegroup != "" {
+			fmt.Printf("Evaluating NodeFeatureGroup against Node %s\n", node)
+			errs := kubectlnfd.TestNFG(nodefeaturegroup, node, kubeconfig)
+			if len(errs) > 0 {
+				fmt.Printf("NodeFeatureGroup is not valid for Node %s\n", node)
+				for _, e := range errs {
+					cmd.PrintErrln(e)
+				}
+				os.Exit(1)
+			}
+			fmt.Printf("NodeFeatureGroup is valid for Node %s\n", node)
 		}
-		fmt.Printf("NodeFeatureRule is valid for Node %s\n", 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(&nodefeaturerule, "nodefeaturerule-file", "f", "", "Path to the NodeFeatureRule file to test")
+	testCmd.Flags().StringVarP(&nodefeaturegroup, "nodefeaturegroup-file", "g", "", "Path to the 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,46 @@ 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 nodefeaturerule == "" && nodefeaturegroup == "" {
+			return fmt.Errorf("at least one of --nodefeaturerule-file or --nodefeaturegroup-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 {
-				cmd.PrintErrln(e)
+		if nodefeaturerule != "" {
+			fmt.Printf("Validating NodeFeatureRule %s\n", nodefeaturerule)
+			errs := kubectlnfd.ValidateNFR(nodefeaturerule)
+			if len(errs) > 0 {
+				fmt.Printf("NodeFeatureRule %s is not valid\n", nodefeaturerule)
+				for _, e := range errs {
+					cmd.PrintErrln(e)
+				}
+				os.Exit(1)
+			}
+			fmt.Printf("NodeFeatureRule %s is valid\n", nodefeaturerule)
+		}
+
+		if nodefeaturegroup != "" {
+			fmt.Printf("Validating NodeFeatureGroup %s\n", nodefeaturegroup)
+			errs := kubectlnfd.ValidateNFG(nodefeaturegroup)
+			if len(errs) > 0 {
+				fmt.Printf("NodeFeatureGroup %s is not valid\n", nodefeaturegroup)
+				for _, e := range errs {
+					cmd.PrintErrln(e)
+				}
+				os.Exit(1)
 			}
-			// Return non-zero exit code to indicate failure
-			os.Exit(1)
+			fmt.Printf("NodeFeatureGroup %s is valid\n", nodefeaturegroup)
 		}
-		fmt.Printf("NodeFeatureRule %s is valid\n", nodefeaturerule)
 	},
 }
 
 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(&nodefeaturegroup, "nodefeaturegroup-file", "g", "", "Path to the 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
@@ -40,6 +41,29 @@ The plugin can be used to validate a NodeFeatureRule object:
 kubectl nfd validate -f <nodefeaturerule.yaml>
 ```
 
+The plugin can also be used to validate a NodeFeatureGroup object:
+
+```bash
+kubectl nfd validate -g <nodefeaturegroup.yaml>
+```
+
+Both flags can be combined to validate a NodeFeatureRule and a
+NodeFeatureGroup in a single invocation:
+
+```bash
+kubectl nfd validate -f <nodefeaturerule.yaml> -g <nodefeaturegroup.yaml>
+```
+
+You can use the example files to try it out:
+
+```bash
+$ kubectl nfd validate -g examples/nodefeaturegroup.yaml
+Validating NodeFeatureGroup examples/nodefeaturegroup.yaml
+Validating rule:  kernel version
+Validating rule:  veth kernel module
+NodeFeatureGroup examples/nodefeaturegroup.yaml is valid
+```
+
 ### Test
 
 The plugin can be used to test a NodeFeatureRule object against a node:
@@ -48,6 +72,19 @@ The plugin can be used to test a NodeFeatureRule object against a node:
 kubectl nfd test -f <nodefeaturerule.yaml> -n <node-name>
 ```
 
+The plugin can also be used to test a NodeFeatureGroup object against a node:
+
+```bash
+kubectl nfd test -g <nodefeaturegroup.yaml> -n <node-name>
+```
+
+Both flags can be combined to test a NodeFeatureRule and a NodeFeatureGroup
+against the same node in a single invocation:
+
+```bash
+kubectl nfd test -f <nodefeaturerule.yaml> -g <nodefeaturegroup.yaml> -n <node-name>
+```
+
 ### DryRun
 
 The plugin can be used to DryRun a NodeFeatureRule object against a NodeFeature
@@ -58,6 +95,21 @@ kubectl get -n node-feature-discovery nodefeature <nodename> -o yaml > <nodefeat
 kubectl nfd dryrun -f <nodefeaturerule.yaml> -n <nodefeature.yaml>
 ```
 
+The plugin can also be used to DryRun a NodeFeatureGroup object against a
+NodeFeature file:
+
+```bash
+kubectl get -n node-feature-discovery nodefeature <nodename> -o yaml > <nodefeature.yaml>
+kubectl nfd dryrun -g <nodefeaturegroup.yaml> -n <nodefeature.yaml>
+```
+
+Both flags can be combined to dry run a NodeFeatureRule and a NodeFeatureGroup
+against the same NodeFeature file in a single invocation:
+
+```bash
+kubectl nfd dryrun -f <nodefeaturerule.yaml> -g <nodefeaturegroup.yaml> -n <nodefeature.yaml>
+```
+
 Or you can use the example NodeFeature file(it is a minimal NodeFeature file):
 
 ```bash
@@ -68,3 +120,13 @@ Processing rule:  my sample rule
 vendor.io/my-sample-feature=true
 NodeFeatureRule "examples/nodefeaturerule.yaml" is valid for NodeFeature "examples/nodefeature.yaml"
 ```
+
+```bash
+$ kubectl nfd dryrun -g examples/nodefeaturegroup.yaml -n examples/nodefeature.yaml
+Evaluating NodeFeatureGroup "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
+NodeFeatureGroup "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,6 +31,55 @@ import (
 	"sigs.k8s.io/node-feature-discovery/pkg/apis/nfd/validate"
 )
 
+func DryRunNFG(nodefeaturegrouppath, nodefeaturepath string) []error {
+	nfg := nfdv1alpha1.NodeFeatureGroup{}
+	nf := nfdv1alpha1.NodeFeature{}
+
+	nfgFile, err := os.ReadFile(nodefeaturegrouppath)
+	if err != nil {
+		return []error{fmt.Errorf("error reading NodeFeatureGroup file: %w", err)}
+	}
+	if err = yaml.Unmarshal(nfgFile, &nfg); err != nil {
+		return []error{fmt.Errorf("error parsing NodeFeatureGroup: %w", err)}
+	}
+
+	nfFile, err := os.ReadFile(nodefeaturepath)
+	if err != nil {
+		return []error{fmt.Errorf("error reading NodeFeature file: %w", err)}
+	}
+	if err = yaml.Unmarshal(nfFile, &nf); err != nil {
+		return []error{fmt.Errorf("error parsing NodeFeature: %w", err)}
+	}
+
+	return processNodeFeatureGroup(nfg, nf.Spec)
+}
+
+func processNodeFeatureGroup(nodeFeatureGroup nfdv1alpha1.NodeFeatureGroup, nodeFeature nfdv1alpha1.NodeFeatureSpec) []error {
+	var errs []error
+
+	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)
+			}
+		}
+	}
+
+	return errs
+}
+
 func DryRun(nodefeaturerulepath, nodefeaturepath string) []error {
 	var errs []error
 	nfr := nfdv1alpha1.NodeFeatureRule{}