Merge pull request intel#345 from bart0sh/PR0077-test-coverage-fpga-plugin

fpga plugin: increase test coverage

Author: Dmitry Rozhkov

cmd/fpga_plugin/fpga_plugin.go

@@ -48,6 +48,9 @@ const (
 // When the device's firmware crashes the driver reports these values
 unhealthyAfuID = "ffffffffffffffffffffffffffffffff"
 unhealthyInterfaceID = "ffffffffffffffffffffffffffffffff"
+
+// Frequency of device scans
+scanFrequency = 5 * time.Second
 )
 
 type getDevTreeFunc func(devices []device) dpapi.DeviceTree
@@ -172,17 +175,36 @@ type devicePlugin struct {
 ignoreAfuIDs bool
 ignoreEmptyRegions bool
 annotationValue string
+
+scanTicker *time.Ticker
+scanDone chan bool
 }
 
 // newDevicePlugin returns new instance of devicePlugin
-func newDevicePlugin(mode string) (*devicePlugin, error) {
-if _, err := os.Stat(sysfsDirectoryOPAE); os.IsNotExist(err) {
-if _, err = os.Stat(sysfsDirectoryDFL); os.IsNotExist(err) {
-return nil, fmt.Errorf("kernel driver is not loaded: neither %s nor %s sysfs entry exists", sysfsDirectoryOPAE, sysfsDirectoryDFL)
+func newDevicePlugin(mode string, rootPath string) (*devicePlugin, error) {
+var dp *devicePlugin
+var err error
+
+sysfsPathOPAE := path.Join(rootPath, sysfsDirectoryOPAE)
+devfsPath := path.Join(rootPath, devfsDirectory)
+if _, err = os.Stat(sysfsPathOPAE); os.IsNotExist(err) {
+sysfsPathDFL := path.Join(rootPath, sysfsDirectoryDFL)
+if _, err = os.Stat(sysfsPathDFL); os.IsNotExist(err) {
+return nil, fmt.Errorf("kernel driver is not loaded: neither %s nor %s sysfs entry exists", sysfsPathOPAE, sysfsPathDFL)
 }
-return newDevicePluginDFL(sysfsDirectoryDFL, devfsDirectory, mode)
+dp, err = newDevicePluginDFL(sysfsPathDFL, devfsPath, mode)
+} else {
+dp, err = newDevicePluginOPAE(sysfsPathOPAE, devfsPath, mode)
+}
+
+if err != nil {
+return nil, err
 }
-return newDevicePluginOPAE(sysfsDirectoryOPAE, devfsDirectory, mode)
+
+dp.scanTicker = time.NewTicker(scanFrequency)
+dp.scanDone = make(chan bool, 1) // buffered as we may send to it before Scan starts receiving from it
+
+return dp, nil
 }
 
 func (dp *devicePlugin) PostAllocate(response *pluginapi.AllocateResponse) error {
@@ -200,6 +222,7 @@ func (dp *devicePlugin) PostAllocate(response *pluginapi.AllocateResponse) error
 
 // Scan starts scanning FPGA devices on the host
 func (dp *devicePlugin) Scan(notifier dpapi.Notifier) error {
+defer dp.scanTicker.Stop()
 for {
 devTree, err := dp.scanFPGAs()
 if err != nil {
@@ -208,7 +231,11 @@ func (dp *devicePlugin) Scan(notifier dpapi.Notifier) error {
 
 notifier.Notify(devTree)
 
-time.Sleep(5 * time.Second)
+select {
+case <-dp.scanDone:
+return nil
+case <-dp.scanTicker.C:
+}
 }
 }
 
@@ -374,7 +401,7 @@ func main() {
 modeMessage = ""
 }
 
-plugin, err := newDevicePlugin(mode)
+plugin, err := newDevicePlugin(mode, "")
 if err != nil {
 fatal(err)
 }

cmd/fpga_plugin/fpga_plugin_test.go

@@ -25,6 +25,7 @@ import (
 pluginapi "k8s.io/kubelet/pkg/apis/deviceplugin/v1beta1"
 
 "github.com/intel/intel-device-plugins-for-kubernetes/pkg/debug"
+dpapi "github.com/intel/intel-device-plugins-for-kubernetes/pkg/deviceplugin"
 )
 
 func init() {
@@ -81,3 +82,157 @@ func TestPostAllocate(t *testing.T) {
 t.Fatalf("Set wrong annotation %s", annotation)
 }
 }
+
+func TestNewDevicePlugin(t *testing.T) {
+root, err := ioutil.TempDir("", "test_new_device_plugin")
+if err != nil {
+t.Fatalf("can't create temporary directory: %+v", err)
+}
+defer os.RemoveAll(root)
+
+tcases := []struct {
+name string
+mode string
+sysfs string
+sysfsdirs []string
+expectedErr bool
+}{
+{
+name: "valid OPAE af mode",
+mode: afMode,
+sysfs: path.Join(root, "sys", "class", "fpga"),
+sysfsdirs: []string{"intel-fpga-dev.0"},
+expectedErr: false,
+},
+{
+name: "valid DFL af mode",
+mode: afMode,
+sysfs: path.Join(root, "sys", "class", "fpga_region"),
+sysfsdirs: []string{"dfl-port.0"},
+expectedErr: false,
+},
+{
+name: "invalid: af mode: driver is not loaded",
+mode: afMode,
+sysfs: root,
+expectedErr: true,
+},
+{
+name: "invalid: region mode: driver is not loaded",
+mode: regionMode,
+sysfs: root,
+expectedErr: true,
+},
+{
+name: "invalid: regionDevel mode: driver is not loaded",
+mode: regionDevelMode,
+sysfs: root,
+expectedErr: true,
+},
+}
+
+for _, tc := range tcases {
+t.Run(tc.name, func(t *testing.T) {
+err = createTestDirs("", tc.sysfs, nil, tc.sysfsdirs, nil)
+if err != nil {
+t.Fatal(err)
+}
+
+_, err := newDevicePlugin(tc.mode, root)
+if tc.expectedErr && err == nil {
+t.Error("unexpected success")
+}
+if !tc.expectedErr && err != nil {
+t.Errorf("unexpected error: %+v", err)
+}
+
+err = os.RemoveAll(path.Join(root, "sys"))
+if err != nil {
+t.Fatalf("Failed to remove fake sysfs directory: %+v", err)
+}
+})
+}
+}
+
+// fakeNotifier implements Notifier interface.
+type fakeNotifier struct {
+scanDone chan bool
+}
+
+// Notify stops plugin Scan
+func (n *fakeNotifier) Notify(newDeviceTree dpapi.DeviceTree) {
+n.scanDone <- true
+}
+
+func TestScan(t *testing.T) {
+root, err := ioutil.TempDir("", "test_new_device_plugin")
+if err != nil {
+t.Fatalf("can't create temporary directory: %+v", err)
+}
+defer os.RemoveAll(root)
+
+devfs := path.Join(root, "dev")
+
+tcases := []struct {
+name string
+mode string
+sysfs string
+devfsdirs []string
+sysfsdirs []string
+sysfsfiles map[string][]byte
+expectedErr bool
+}{
+{
+name: "valid OPAE scan",
+mode: afMode,
+sysfs: path.Join(root, "sys", "class", "fpga"),
+sysfsdirs: []string{
+"intel-fpga-dev.0/intel-fpga-port.0",
+"intel-fpga-dev.0/intel-fpga-fme.0/pr",
+"intel-fpga-dev.1/intel-fpga-port.1",
+"intel-fpga-dev.1/intel-fpga-fme.1/pr",
+},
+sysfsfiles: map[string][]byte{
+"intel-fpga-dev.0/intel-fpga-port.0/afu_id": []byte("d8424dc4a4a3c413f89e433683f9040b\n"),
+"intel-fpga-dev.1/intel-fpga-port.1/afu_id": []byte("d8424dc4a4a3c413f89e433683f9040b\n"),
+"intel-fpga-dev.0/intel-fpga-fme.0/pr/interface_id": []byte("ce48969398f05f33946d560708be108a\n"),
+"intel-fpga-dev.1/intel-fpga-fme.1/pr/interface_id": []byte("ce48969398f05f33946d560708be108a\n"),
+},
+devfsdirs: []string{
+"intel-fpga-port.0", "intel-fpga-fme.0",
+"intel-fpga-port.1", "intel-fpga-fme.1",
+},
+expectedErr: false,
+},
+}
+
+for _, tc := range tcases {
+t.Run(tc.name, func(t *testing.T) {
+err = createTestDirs(devfs, tc.sysfs, tc.devfsdirs, tc.sysfsdirs, tc.sysfsfiles)
+if err != nil {
+t.Fatal(err)
+}
+
+plugin, err := newDevicePlugin(tc.mode, root)
+if err != nil {
+t.Fatalf("failed to create a device plugin: %+v", err)
+}
+
+err = plugin.Scan(&fakeNotifier{plugin.scanDone})
+
+if tc.expectedErr && err == nil {
+t.Error("unexpected success")
+}
+if !tc.expectedErr && err != nil {
+t.Errorf("unexpected error: %+v", err)
+}
+
+for _, dir := range []string{"sys", "dev"} {
+err = os.RemoveAll(path.Join(root, dir))
+if err != nil {
+t.Fatalf("Failed to remove fake sysfs directory: %+v", err)
+}
+}
+})
+}
+}