Implementation of exclusing pooling, with unit tests.

cmd/sriovdp/manager.go

@@ -103,6 +103,7 @@ func (rm *resourceManager) readConfig() error {
 func (rm *resourceManager) initServers() error {
 	rf := rm.rFactory
 	glog.Infof("number of config: %d\n", len(rm.configList))
+	deviceAllocated := make(map[string]bool)
 	for _, rc := range rm.configList {
 		// Create new ResourcePool
 		glog.Infof("")
@@ -123,7 +124,7 @@ func (rm *resourceManager) initServers() error {
 			glog.Infof("no devices in device pool, skipping creating resource server for %s", rc.ResourceName)
 			continue
 		}
-		rPool, err := rm.rFactory.GetResourcePool(rc, filteredDevices)
+		rPool, err := rm.rFactory.GetResourcePoolExclusive(rc, filteredDevices, deviceAllocated)
 		if err != nil {
 			glog.Errorf("initServers(): error creating ResourcePool with config %+v: %q", rc, err)
 			return err

cmd/sriovdp/manager_test.go

@@ -255,6 +255,9 @@ var _ = Describe("Resource manager", func() {
 					mockedRf := &mocks.ResourceFactory{}
 					mockedRf.On("GetResourcePool", rc, devs).Return(rp, nil).
 						On("GetResourceServer", rp).Return(mockedServer, nil)
+					deviceAllocated := make(map[string]bool)
+					mockedRf.On("GetResourcePoolExclusive", rc, devs, deviceAllocated).Return(rp, nil).
+						On("GetResourceServer", rp).Return(mockedServer, nil)
 
 					dp.On("GetDevices", rc).Return(devs)
 					rm := &resourceManager{

pkg/factory/factory.go

@@ -97,17 +97,28 @@ func (rf *resourceFactory) GetSelector(attr string, values []string) (types.Devi
 
 // GetResourcePool returns an instance of resourcePool
 func (rf *resourceFactory) GetResourcePool(rc *types.ResourceConfig, filteredDevice []types.PciDevice) (types.ResourcePool, error) {
+	return rf.GetResourcePoolExclusive(rc, filteredDevice, make(map[string]bool))
+}
+
+// GetResourcePoolExclusive returns an exclusive resourcePool
+func (rf *resourceFactory) GetResourcePoolExclusive(rc *types.ResourceConfig, filteredDevice []types.PciDevice,
+	deviceAllocated map[string]bool) (types.ResourcePool, error) {
 	devicePool := make(map[string]types.PciDevice)
 	apiDevices := make(map[string]*pluginapi.Device)
 	for _, dev := range filteredDevice {
 		pciAddr := dev.GetPciAddr()
-		devicePool[pciAddr] = dev
-		apiDevices[pciAddr] = dev.GetAPIDevice()
-		glog.Infof("device added: [pciAddr: %s, vendor: %s, device: %s, driver: %s]",
-			dev.GetPciAddr(),
-			dev.GetVendor(),
-			dev.GetDeviceCode(),
-			dev.GetDriver())
+		if !deviceAllocated[pciAddr] {
+			deviceAllocated[pciAddr] = true
+			devicePool[pciAddr] = dev
+			apiDevices[pciAddr] = dev.GetAPIDevice()
+			glog.Infof("device added: [pciAddr: %s, vendor: %s, device: %s, driver: %s]",
+				dev.GetPciAddr(),
+				dev.GetVendor(),
+				dev.GetDeviceCode(),
+				dev.GetDriver())
+		} else {
+			glog.Infof("Cannot add PCI Address [%s]. Already allocated.", pciAddr)
+		}
 	}
 
 	var rPool types.ResourcePool

pkg/factory/factory_test.go

@@ -160,6 +160,116 @@ var _ = Describe("Factory", func() {
 			})
 		})
 	})
+	Describe("getting exclusive resource pool for netdevice", func() {
+		Context("with all types of selectors used and matching devices found", func() {
+			defer utils.UseFakeLinks()()
+			var (
+				rp   types.ResourcePool
+				rp2  types.ResourcePool
+				err  error
+				devs []types.PciDevice
+			)
+			BeforeEach(func() {
+				f := factory.NewResourceFactory("fake", "fake", true)
+				deviceAllocated := make(map[string]bool)
+				devs = make([]types.PciDevice, 4)
+				vendors := []string{"8086", "8086", "8086", "8086"}
+				codes := []string{"1111", "1111", "1111", "1111"}
+				drivers := []string{"iavf", "iavf", "vfio-pci", "vfio-pci"}
+				pciAddr := []string{"0000:03:02.0", "0000:03:02.0", "0000:03:02.0", "0000:03:02.0"}
+				pfNames := []string{"enp2s0f2", "ens0", "eth0", "net2"}
+				rootDevices := []string{"0000:86:00.0", "0000:86:00.1", "0000:86:00.2", "0000:86:00.3"}
+				linkTypes := []string{"ether", "infiniband", "other", "other2"}
+				ddpProfiles := []string{"GTP", "PPPoE", "GTP", "PPPoE"}
+				for i := range devs {
+					d := &mocks.PciNetDevice{}
+					d.On("GetVendor").Return(vendors[i]).
+						On("GetDeviceCode").Return(codes[i]).
+						On("GetDriver").Return(drivers[i]).
+						On("GetPciAddr").Return(pciAddr[i]).
+						On("GetPFName").Return(pfNames[i]).
+						On("GetPfPciAddr").Return(rootDevices[i]).
+						On("GetAPIDevice").Return(&pluginapi.Device{}).
+						On("GetLinkType").Return(linkTypes[i]).
+						On("GetDDPProfiles").Return(ddpProfiles[i])
+					devs[i] = d
+				}
+
+				var selectors json.RawMessage
+				err = selectors.UnmarshalJSON([]byte(`
+						{
+							"vendors": ["8086"],
+							"devices": ["1111"],
+							"drivers": ["iavf","vfio-pci"],
+							"pciAddresses": ["0000:03:02.0"],
+							"pfNames": ["enp2s0f2"],
+							"rootDevices": ["0000:86:00.0"],
+							"linkTypes": ["ether"],
+							"ddpProfiles": ["GTP"]
+						}
+					`),
+				)
+				Expect(err).NotTo(HaveOccurred())
+
+				var selectors2 json.RawMessage
+				err = selectors2.UnmarshalJSON([]byte(`
+						{
+							"vendors": ["8086"],
+							"devices": ["1111"],
+							"drivers": ["iavf","vfio-pci"],
+							"pciAddresses": ["0000:03:02.0"],
+							"pfNames": ["enp2s0f2"],
+							"rootDevices": ["0000:86:00.0"],
+							"linkTypes": ["ether"],
+							"ddpProfiles": ["GTP"]
+						}
+					`),
+				)
+				Expect(err).NotTo(HaveOccurred())
+
+				c := &types.ResourceConfig{
+					ResourceName: "fake",
+					Selectors:    &selectors,
+					DeviceType:   types.NetDeviceType,
+				}
+
+				dp := f.GetDeviceProvider(c.DeviceType)
+				c.SelectorObj, err = f.GetDeviceFilter(c)
+				Expect(err).NotTo(HaveOccurred())
+				filteredDevices, err := dp.GetFilteredDevices(devs, c)
+				Expect(err).NotTo(HaveOccurred())
+				rp, err = f.GetResourcePoolExclusive(c, filteredDevices, deviceAllocated)
+				Expect(err).NotTo(HaveOccurred())
+
+				// Second config definition
+				c2 := &types.ResourceConfig{
+					ResourceName: "fake",
+					Selectors:    &selectors2,
+					DeviceType:   types.NetDeviceType,
+				}
+
+				dp2 := f.GetDeviceProvider(c2.DeviceType)
+				c2.SelectorObj, err = f.GetDeviceFilter(c2)
+				Expect(err).NotTo(HaveOccurred())
+				filteredDevices, err = dp2.GetFilteredDevices(devs, c2)
+				Expect(err).NotTo(HaveOccurred())
+				rp2, err = f.GetResourcePoolExclusive(c2, filteredDevices, deviceAllocated)
+				Expect(err).NotTo(HaveOccurred())
+
+			})
+			It("should return valid exclusive resource pool", func() {
+				Expect(rp).NotTo(BeNil())
+				Expect(rp.GetDevices()).To(HaveLen(1))
+				Expect(rp.GetDevices()).To(HaveKey("0000:03:02.0"))
+				// Check second resource pool to make sure nothing got added to it.
+				Expect(rp2).NotTo(BeNil())
+				Expect(rp2.GetDevices()).To(HaveLen(0))
+			})
+			It("should not fail", func() {
+				Expect(err).NotTo(HaveOccurred())
+			})
+		})
+	})
 	Describe("getting resource pool for accelerator", func() {
 		Context("with all types of selectors used and matching devices found", func() {
 			defer utils.UseFakeLinks()()

pkg/types/types.go

@@ -129,6 +129,7 @@ type ResourceFactory interface {
 	GetDefaultInfoProvider(string, string) DeviceInfoProvider
 	GetSelector(string, []string) (DeviceSelector, error)
 	GetResourcePool(rc *ResourceConfig, deviceList []PciDevice) (ResourcePool, error)
+	GetResourcePoolExclusive(rc *ResourceConfig, deviceList []PciDevice, deviceAllocated map[string]bool) (ResourcePool, error)
 	GetRdmaSpec(string) RdmaSpec
 	GetDeviceProvider(DeviceType) DeviceProvider
 	GetDeviceFilter(*ResourceConfig) (interface{}, error)