sriov pkg: add DisablePlugins and GetTotalVFs methods (#801)

pkg/sriov/networknodestate.go

@@ -204,6 +204,19 @@ func (builder *NetworkNodeStateBuilder) GetPciAddress(sriovInterfaceName string)
 	return interf.PciAddress, nil
 }
 
+// GetTotalVFs returns total VFs under the given interface.
+func (builder *NetworkNodeStateBuilder) GetTotalVFs(sriovInterfaceName string) (int, error) {
+	glog.V(100).Infof("Getting totalvfs under interface %s from SriovNetworkNodeState %s",
+		sriovInterfaceName, builder.nodeName)
+
+	interf, err := builder.findInterfaceByName(sriovInterfaceName)
+	if err != nil {
+		return 0, err
+	}
+
+	return interf.TotalVfs, nil
+}
+
 func (builder *NetworkNodeStateBuilder) findInterfaceByName(sriovInterfaceName string) (*srIovV1.InterfaceExt, error) {
 	if valid, err := builder.validate(); !valid {
 		return nil, err

pkg/sriov/networknodestate_test.go

@@ -295,17 +295,16 @@ func TestNetworkNodeStateWaitUntilSyncStatus(t *testing.T) {
 func TestNetworkNodeStateGetNumVFs(t *testing.T) {
 	testCases := []struct {
 		netInterface srIovV1.InterfaceExts
-		upInterface  srIovV1.InterfaceExts
 	}{
 		{
 			netInterface: []srIovV1.InterfaceExt{
-				{Name: "eth1", LinkSpeed: "1000Mb", TotalVfs: 5},
+				{Name: "eth1", LinkSpeed: "1000Mb", NumVfs: 5},
 			},
 		},
 		{
 			netInterface: []srIovV1.InterfaceExt{
-				{Name: "eth1", LinkSpeed: "1000Mb", TotalVfs: 5},
-				{Name: "eth1", LinkSpeed: "1000Mb", TotalVfs: 10},
+				{Name: "eth1", LinkSpeed: "1000Mb", NumVfs: 5},
+				{Name: "eth2", LinkSpeed: "1000Mb", NumVfs: 10},
 			},
 		},
 	}
@@ -328,6 +327,41 @@ func TestNetworkNodeStateGetNumVFs(t *testing.T) {
 	}
 }
 
+func TestNetworkNodeStateGetTotalVFs(t *testing.T) {
+	testCases := []struct {
+		netInterface srIovV1.InterfaceExts
+	}{
+		{
+			netInterface: []srIovV1.InterfaceExt{
+				{Name: "eth1", LinkSpeed: "1000Mb", TotalVfs: 5},
+			},
+		},
+		{
+			netInterface: []srIovV1.InterfaceExt{
+				{Name: "eth1", LinkSpeed: "1000Mb", TotalVfs: 5},
+				{Name: "eth2", LinkSpeed: "1000Mb", TotalVfs: 10},
+			},
+		},
+	}
+
+	for _, testCase := range testCases {
+		networkNodeState := buildNodeNetworkStateWithNics(testCase.netInterface)
+		testSettings := clients.GetTestClients(clients.TestClientParams{
+			K8sMockObjects:  []runtime.Object{networkNodeState},
+			SchemeAttachers: testSchemes,
+		})
+		networkNodeStateBuilder := NewNetworkNodeStateBuilder(testSettings, defaultNodeName, defaultNodeNsName)
+		err := networkNodeStateBuilder.Discover()
+		assert.Nil(t, err)
+
+		for _, netInterface := range testCase.netInterface {
+			totalVFNum, err := networkNodeStateBuilder.GetTotalVFs(netInterface.Name)
+			assert.Nil(t, err)
+			assert.Equal(t, netInterface.TotalVfs, totalVFNum)
+		}
+	}
+}
+
 func TestNetworkNodeStateGetDriverName(t *testing.T) {
 	testCases := []struct {
 		netInterface srIovV1.InterfaceExts

pkg/sriov/operatorconfig.go

@@ -13,12 +13,18 @@ import (
 	"github.com/openshift-kni/eco-goinfra/pkg/clients"
 	k8serrors "k8s.io/apimachinery/pkg/api/errors"
 	metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/utils/strings/slices"
 )
 
 const (
 	sriovOperatorConfigName = "default"
 )
 
+var (
+	// allowedDisablePlugins represents all allowed plugins that could be disabled.
+	allowedDisablePlugins = []string{"mellanox"}
+)
+
 // OperatorConfigBuilder provides a struct for SriovOperatorConfig object from the cluster and
 // a SriovOperatorConfig definition.
 type OperatorConfigBuilder struct {
@@ -237,6 +243,47 @@ func (builder *OperatorConfigBuilder) WithConfigDaemonNodeSelector(
 	return builder
 }
 
+// WithDisablePlugins configures disablePlugins in the SriovOperatorConfig.
+func (builder *OperatorConfigBuilder) WithDisablePlugins(plugins []string) *OperatorConfigBuilder {
+	if valid, _ := builder.validate(); !valid {
+		return builder
+	}
+
+	glog.V(100).Infof("Configuring disablePlugins %v in SriovOperatorConfig object %s",
+		plugins, builder.Definition.Name,
+	)
+
+	var pluginSlice srIovV1.PluginNameSlice
+
+	for _, plugin := range plugins {
+		if !slices.Contains(allowedDisablePlugins, plugin) {
+			glog.V(100).Infof("error to add plugin %s, allowed modes are %v", plugin, allowedDisablePlugins)
+
+			builder.errorMsg = "invalid plugin parameter"
+
+			return builder
+		}
+
+		pluginSlice = append(pluginSlice, srIovV1.PluginNameValue(plugin))
+	}
+
+	builder.Definition.Spec.DisablePlugins = pluginSlice
+
+	return builder
+}
+
+// RemoveDisablePlugins deletes disablePlugins in the SriovOperatorConfig.
+func (builder *OperatorConfigBuilder) RemoveDisablePlugins() *OperatorConfigBuilder {
+	if valid, _ := builder.validate(); !valid {
+		return builder
+	}
+
+	glog.V(100).Infof("Removing disablePlugins in SriovOperatorConfig object %s", builder.Definition.Name)
+	builder.Definition.Spec.DisablePlugins = nil
+
+	return builder
+}
+
 // Update renovates the existing SriovOperatorConfig object with the new definition in builder.
 func (builder *OperatorConfigBuilder) Update() (*OperatorConfigBuilder, error) {
 	if valid, err := builder.validate(); !valid {

pkg/sriov/operatorconfig_test.go

@@ -281,6 +281,58 @@ func TestOperatorConfigWithConfigDaemonNodeSelector(t *testing.T) {
 	}
 }
 
+func TestOperatorConfigWithDisablePlugins(t *testing.T) {
+	testCases := []struct {
+		plugins           []string
+		expectedErrorText string
+	}{
+		{
+			plugins:           []string{"mellanox"},
+			expectedErrorText: "",
+		},
+		{
+			plugins:           []string{"test"},
+			expectedErrorText: "invalid plugin parameter",
+		},
+	}
+
+	for _, testCase := range testCases {
+		testSettings := buildTestClientWithDummyPolicyObject()
+		operatorConfigBuilder := NewOperatorConfigBuilder(testSettings, "testnamespace").
+			WithDisablePlugins(testCase.plugins)
+
+		assert.Equal(t, testCase.expectedErrorText, operatorConfigBuilder.errorMsg)
+
+		if testCase.expectedErrorText == "" {
+			var pluginSlice srIovV1.PluginNameSlice
+			for _, plugin := range testCase.plugins {
+				pluginSlice = append(pluginSlice, srIovV1.PluginNameValue(plugin))
+			}
+
+			assert.Equal(t, pluginSlice,
+				operatorConfigBuilder.Definition.Spec.DisablePlugins)
+		}
+	}
+}
+
+func TestOperatorConfigRemoveDisablePlugins(t *testing.T) {
+	testCases := []struct {
+		testOperatorConfig *OperatorConfigBuilder
+	}{
+		{
+			testOperatorConfig: NewOperatorConfigBuilder(
+				buildTestClientWithDummyOperatorConfigObject(),
+				defaultOperatorConfigNsName).WithDisablePlugins([]string{"mellanox"}),
+		},
+	}
+	for _, testCase := range testCases {
+		operatorConfigBuilder, _ := testCase.testOperatorConfig.Create()
+
+		operatorConfigBuilder.RemoveDisablePlugins()
+		assert.Nil(t, operatorConfigBuilder.Definition.Spec.DisablePlugins)
+	}
+}
+
 func TestOperatorConfigUpdate(t *testing.T) {
 	testCases := []struct {
 		testOperatorConfig *OperatorConfigBuilder