openstack
/
nova
Code Issues Proposed changes

Clean up the naming of PCI python modules 

Something that has been bothering me when looking at the PCI code is
that the modules in /nova/pci/ unnecessarily were prefixed with pci_.
For instance, nova/pci/pci_device.py, whereas all other module directory
organizations for all other code in Nova uses the directory name to
demarcate a submodule.

This patch simply gets the nova/pci/ modules in-line with the standard
set everywhere else in Nova and cuts off the pci_ prefix from the module
names.

Change-Id: Ia5ca13f674f15b41e22b8488efe44eb926e5e4eb
This commit is contained in:
Jay Pipes 2014-10-16 00:04:42 -04:00
parent fe7065fa54
commit d9169614e4
32 changed files with 152 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
nova/compute/api.py
View File

@ -63,7 +63,7 @@ from nova.objects import quotas as quotas_obj
from nova.objects import security_group as security_group_obj
from nova.openstack.common import log as logging
from nova.openstack.common import uuidutils
from nova.pci import pci_request
from nova.pci import request as pci_request
import nova.policy
from nova import quota
from nova import rpc

2
nova/compute/resource_tracker.py
View File

@ -36,7 +36,7 @@ from nova.i18n import _
from nova import objects
from nova.objects import base as obj_base
from nova.openstack.common import log as logging
from nova.pci import pci_manager
from nova.pci import manager as pci_manager
from nova import rpc
from nova.scheduler import client as scheduler_client
from nova import utils

6
nova/network/neutronv2/api.py
View File

@ -35,9 +35,9 @@ from nova import objects
from nova.openstack.common import lockutils
from nova.openstack.common import log as logging
from nova.openstack.common import uuidutils
from nova.pci import pci_manager
from nova.pci import pci_request
from nova.pci import pci_whitelist
from nova.pci import manager as pci_manager
from nova.pci import request as pci_request
from nova.pci import whitelist as pci_whitelist
neutron_opts = [
cfg.StrOpt('url',

0
nova/pci/pci_device.py → nova/pci/device.py
View File

12
nova/pci/pci_devspec.py → nova/pci/devspec.py Executable file → Normal file
View File

@ -17,7 +17,7 @@ import re
from oslo.serialization import jsonutils
from nova import exception
from nova.pci import pci_utils
from nova.pci import utils
MAX_VENDOR_ID = 0xFFFF
MAX_PRODUCT_ID = 0xFFFF
@ -69,12 +69,12 @@ class PciAddress(object):
def _check_physical_function(self):
if ANY in (self.domain, self.bus, self.slot, self.func):
return
self.is_physical_function = pci_utils.is_physical_function(self)
self.is_physical_function = utils.is_physical_function(self)
def _init_address_fields(self, pci_addr):
if self.is_physical_function:
(self.domain, self.bus, self.slot,
self.func) = pci_utils.get_pci_address_fields(pci_addr)
self.func) = utils.get_pci_address_fields(pci_addr)
return
dbs, sep, func = pci_addr.partition('.')
if func:
@ -112,12 +112,12 @@ class PciAddress(object):
if not pci_phys_addr:
return False
domain, bus, slot, func = (
pci_utils.get_pci_address_fields(pci_phys_addr))
utils.get_pci_address_fields(pci_phys_addr))
return (self.domain == domain and self.bus == bus and
self.slot == slot and self.func == func)
else:
domain, bus, slot, func = (
pci_utils.get_pci_address_fields(pci_addr))
utils.get_pci_address_fields(pci_addr))
conditions = [
self.domain in (ANY, domain),
self.bus in (ANY, bus),
@ -149,7 +149,7 @@ class PciDeviceSpec(object):
raise exception.PciDeviceInvalidDeviceName()
if not self.address:
if self.dev_name:
self.address, pf = pci_utils.get_function_by_ifname(
self.address, pf = utils.get_function_by_ifname(
self.dev_name)
if not self.address:
raise exception.PciDeviceNotFoundById(id=self.dev_name)

18
nova/pci/pci_manager.py → nova/pci/manager.py
View File

@ -23,8 +23,8 @@ from nova import exception
from nova.i18n import _
from nova import objects
from nova.openstack.common import log as logging
from nova.pci import pci_device
from nova.pci import pci_stats
from nova.pci import device
from nova.pci import stats
LOG = logging.getLogger(__name__)
@ -52,7 +52,7 @@ class PciDevTracker(object):
super(PciDevTracker, self).__init__()
self.stale = {}
self.node_id = node_id
self.stats = pci_stats.PciDeviceStats()
self.stats = stats.PciDeviceStats()
if node_id:
self.pci_devs = list(
objects.PciDeviceList.get_by_compute_node(context, node_id))
@ -107,7 +107,7 @@ class PciDevTracker(object):
for existed in self.pci_devs:
if existed['address'] in exist_addrs - new_addrs:
try:
pci_device.remove(existed)
device.remove(existed)
except exception.PciDeviceInvalidStatus as e:
LOG.warn(_("Trying to remove device with %(status)s "
"ownership %(instance_uuid)s because of "
@ -140,7 +140,7 @@ class PciDevTracker(object):
# by force in future.
self.stale[new_value['address']] = new_value
else:
pci_device.update_device(existed, new_value)
device.update_device(existed, new_value)
for dev in [dev for dev in devices if
dev['address'] in new_addrs - exist_addrs]:
@ -158,18 +158,18 @@ class PciDevTracker(object):
if not devs:
raise exception.PciDeviceRequestFailed(pci_requests)
for dev in devs:
pci_device.claim(dev, instance)
device.claim(dev, instance)
return devs
def _allocate_instance(self, instance, devs):
for dev in devs:
pci_device.allocate(dev, instance)
device.allocate(dev, instance)
def _free_device(self, dev, instance=None):
pci_device.free(dev, instance)
device.free(dev, instance)
stale = self.stale.pop(dev['address'], None)
if stale:
pci_device.update_device(dev, stale)
device.update_device(dev, stale)
self.stats.add_device(dev)
def _free_instance(self, instance):

6
nova/pci/pci_request.py → nova/pci/request.py
View File

@ -46,7 +46,7 @@ import six
from nova import exception
from nova import objects
from nova.openstack.common import log as logging
from nova.pci import pci_utils
from nova.pci import utils
pci_alias_opts = [
cfg.MultiStrOpt('pci_alias',
@ -91,11 +91,11 @@ _ALIAS_SCHEMA = {
},
"product_id": {
"type": "string",
"pattern": pci_utils.PCI_VENDOR_PATTERN,
"pattern": utils.PCI_VENDOR_PATTERN,
},
"vendor_id": {
"type": "string",
"pattern": pci_utils.PCI_VENDOR_PATTERN,
"pattern": utils.PCI_VENDOR_PATTERN,
},
"device_type": {
"type": "string",

8
nova/pci/pci_stats.py → nova/pci/stats.py
View File

@ -21,8 +21,8 @@ from oslo.serialization import jsonutils
from nova import exception
from nova.i18n import _LE
from nova.openstack.common import log as logging
from nova.pci import pci_utils
from nova.pci import pci_whitelist
from nova.pci import utils
from nova.pci import whitelist
LOG = logging.getLogger(__name__)
@ -81,7 +81,7 @@ class PciDeviceStats(object):
"""
# Don't add a device that doesn't have a matching device spec.
# This can happen during initial sync up with the controller
devspec = pci_whitelist.get_pci_device_devspec(dev)
devspec = whitelist.get_pci_device_devspec(dev)
if not devspec:
return
tags = devspec.get_tags()
@ -174,7 +174,7 @@ class PciDeviceStats(object):
@staticmethod
def _filter_pools_for_spec(pools, request_specs):
return [pool for pool in pools
if pci_utils.pci_device_prop_match(pool, request_specs)]
if utils.pci_device_prop_match(pool, request_specs)]
def _apply_request(self, pools, request):
count = request.count

0
nova/pci/pci_utils.py → nova/pci/utils.py
View File

4
nova/pci/pci_whitelist.py → nova/pci/whitelist.py
View File

@ -17,7 +17,7 @@
from oslo.config import cfg
from nova.openstack.common import log as logging
from nova.pci import pci_devspec
from nova.pci import devspec
pci_opts = [cfg.MultiStrOpt('pci_passthrough_whitelist',
default=[],
@ -46,7 +46,7 @@ class PciHostDevicesWhiteList(object):
"""Parse and validate the pci whitelist from the nova config."""
specs = []
for jsonspec in whitelists:
spec = pci_devspec.PciDeviceSpec(jsonspec)
spec = devspec.PciDeviceSpec(jsonspec)
specs.append(spec)
return specs

2
nova/scheduler/host_manager.py
View File

@ -30,7 +30,7 @@ from nova import db
from nova import exception
from nova.i18n import _, _LW
from nova.openstack.common import log as logging
from nova.pci import pci_stats
from nova.pci import stats as pci_stats
from nova.scheduler import filters
from nova.scheduler import weights
from nova.virt import hardware

6
nova/tests/api/openstack/compute/plugins/v3/test_pci.py
View File

@ -22,7 +22,7 @@ from nova import context
from nova import db
from nova import exception
from nova import objects
from nova.pci import pci_device
from nova.pci import device
from nova import test
from nova.tests.api.openstack import fakes
from nova.tests.objects import test_pci_device
@ -60,8 +60,8 @@ class PciServerControllerTest(test.NoDBTestCase):
}]}
self._create_fake_instance()
self._create_fake_pci_device()
pci_device.claim(self.pci_device, self.inst)
pci_device.allocate(self.pci_device, self.inst)
device.claim(self.pci_device, self.inst)
device.allocate(self.pci_device, self.inst)
def _create_fake_instance(self):
self.inst = objects.Instance()

4
nova/tests/compute/test_claims.py
View File

@ -26,9 +26,9 @@ from nova.compute import claims
from nova import db
from nova import exception
from nova import objects
from nova.pci import pci_manager
from nova.pci import manager as pci_manager
from nova import test
from nova.tests.pci import pci_fakes
from nova.tests.pci import fakes as pci_fakes
from nova.virt import hardware

2
nova/tests/compute/test_resource_tracker.py
View File

@ -35,7 +35,7 @@ from nova import rpc
from nova import test
from nova.tests.compute.monitors import test_monitors
from nova.tests.objects import test_migration
from nova.tests.pci import pci_fakes
from nova.tests.pci import fakes as pci_fakes
from nova.virt import driver
from nova.virt import hardware

2
nova/tests/fake_network.py
View File

@ -29,7 +29,7 @@ from nova.network import rpcapi as network_rpcapi
from nova import objects
from nova.objects import base as obj_base
from nova.objects import virtual_interface as vif_obj
from nova.pci import pci_device
from nova.pci import device as pci_device
from nova.tests.objects import test_fixed_ip
from nova.tests.objects import test_instance_info_cache
from nova.tests.objects import test_pci_device

4
nova/tests/network/test_neutronv2.py
View File

@ -36,8 +36,8 @@ from nova.network.neutronv2 import api as neutronapi
from nova.network.neutronv2 import constants
from nova import objects
from nova.openstack.common import policy as common_policy
from nova.pci import pci_manager
from nova.pci import pci_whitelist
from nova.pci import manager as pci_manager
from nova.pci import whitelist as pci_whitelist
from nova import policy
from nova import test
from nova.tests import fake_instance

4
nova/tests/pci/pci_fakes.py → nova/tests/pci/fakes.py
View File

@ -17,13 +17,13 @@ import functools
import mock
from nova.pci import pci_whitelist
from nova.pci import whitelist
def fake_pci_whitelist():
devspec = mock.Mock()
devspec.get_tags.return_value = None
patcher = mock.patch.object(pci_whitelist, 'get_pci_device_devspec',
patcher = mock.patch.object(whitelist, 'get_pci_device_devspec',
return_value=devspec)
patcher.start()
return patcher

47
nova/tests/pci/test_pci_device.py → nova/tests/pci/test_device.py
View File

@ -15,9 +15,8 @@
from nova import context
from nova import exception
from nova.objects import instance
from nova.objects import pci_device as pci_device_obj
from nova.pci import pci_device
from nova import objects
from nova.pci import device
from nova import test
@ -45,16 +44,16 @@ class PciDeviceTestCase(test.TestCase):
def setUp(self):
super(PciDeviceTestCase, self).setUp()
self.ctxt = context.get_admin_context()
self.inst = instance.Instance()
self.inst = objects.Instance()
self.inst.uuid = 'fake-inst-uuid'
self.inst.pci_devices = pci_device_obj.PciDeviceList()
self.devobj = pci_device_obj.PciDevice._from_db_object(
self.inst.pci_devices = objects.PciDeviceList()
self.devobj = objects.PciDevice._from_db_object(
self.ctxt,
pci_device_obj.PciDevice(),
objects.PciDevice(),
dev_dict)
def test_claim_device(self):
pci_device.claim(self.devobj, self.inst)
device.claim(self.devobj, self.inst)
self.assertEqual(self.devobj.status, 'claimed')
self.assertEqual(self.devobj.instance_uuid,
self.inst.uuid)
@ -63,11 +62,11 @@ class PciDeviceTestCase(test.TestCase):
def test_claim_device_fail(self):
self.devobj.status = 'allocated'
self.assertRaises(exception.PciDeviceInvalidStatus,
pci_device.claim, self.devobj, self.inst)
device.claim, self.devobj, self.inst)
def test_allocate_device(self):
pci_device.claim(self.devobj, self.inst)
pci_device.allocate(self.devobj, self.inst)
device.claim(self.devobj, self.inst)
device.allocate(self.devobj, self.inst)
self.assertEqual(self.devobj.status, 'allocated')
self.assertEqual(self.devobj.instance_uuid, 'fake-inst-uuid')
self.assertEqual(len(self.inst.pci_devices), 1)
@ -77,29 +76,29 @@ class PciDeviceTestCase(test.TestCase):
def test_allocacte_device_fail_status(self):
self.devobj.status = 'removed'
self.assertRaises(exception.PciDeviceInvalidStatus,
pci_device.allocate,
device.allocate,
self.devobj,
self.inst)
def test_allocacte_device_fail_owner(self):
inst_2 = instance.Instance()
inst_2 = objects.Instance()
inst_2.uuid = 'fake-inst-uuid-2'
pci_device.claim(self.devobj, self.inst)
device.claim(self.devobj, self.inst)
self.assertRaises(exception.PciDeviceInvalidOwner,
pci_device.allocate,
device.allocate,
self.devobj, inst_2)
def test_free_claimed_device(self):
pci_device.claim(self.devobj, self.inst)
pci_device.free(self.devobj, self.inst)
device.claim(self.devobj, self.inst)
device.free(self.devobj, self.inst)
self.assertEqual(self.devobj.status, 'available')
self.assertIsNone(self.devobj.instance_uuid)
def test_free_allocated_device(self):
pci_device.claim(self.devobj, self.inst)
pci_device.allocate(self.devobj, self.inst)
device.claim(self.devobj, self.inst)
device.allocate(self.devobj, self.inst)
self.assertEqual(len(self.inst.pci_devices), 1)
pci_device.free(self.devobj, self.inst)
device.free(self.devobj, self.inst)
self.assertEqual(len(self.inst.pci_devices), 0)
self.assertEqual(self.devobj.status, 'available')
self.assertIsNone(self.devobj.instance_uuid)
@ -107,14 +106,14 @@ class PciDeviceTestCase(test.TestCase):
def test_free_device_fail(self):
self.devobj.status = 'removed'
self.assertRaises(exception.PciDeviceInvalidStatus,
pci_device.free, self.devobj)
device.free, self.devobj)
def test_remove_device(self):
pci_device.remove(self.devobj)
device.remove(self.devobj)
self.assertEqual(self.devobj.status, 'removed')
self.assertIsNone(self.devobj.instance_uuid)
def test_remove_device_fail(self):
pci_device.claim(self.devobj, self.inst)
device.claim(self.devobj, self.inst)
self.assertRaises(exception.PciDeviceInvalidStatus,
pci_device.remove, self.devobj)
device.remove, self.devobj)

66
nova/tests/pci/test_pci_devspec.py → nova/tests/pci/test_devspec.py
View File

@ -15,8 +15,8 @@
import mock
from nova import exception
from nova.objects import pci_device
from nova.pci import pci_devspec
from nova import objects
from nova.pci import devspec
from nova import test
dev = {"vendor_id": "8086",
@ -29,76 +29,76 @@ class PciAddressTestCase(test.NoDBTestCase):
def test_wrong_address(self):
pci_info = ('{"vendor_id": "8086", "address": "*: *: *.6",' +
'"product_id": "5057", "physical_network": "hr_net"}')
pci = pci_devspec.PciDeviceSpec(pci_info)
pci = devspec.PciDeviceSpec(pci_info)
self.assertFalse(pci.match(dev))
def test_address_too_big(self):
pci_info = ('{"address": "0000:0a:0b:00.5", ' +
'"physical_network": "hr_net"}')
self.assertRaises(exception.PciDeviceWrongAddressFormat,
pci_devspec.PciDeviceSpec, pci_info)
devspec.PciDeviceSpec, pci_info)
def test_address_invalid_character(self):
pci_info = '{"address": "0000:h4.12:6", "physical_network": "hr_net"}'
self.assertRaises(exception.PciDeviceWrongAddressFormat,
pci_devspec.PciDeviceSpec, pci_info)
devspec.PciDeviceSpec, pci_info)
def test_max_func(self):
pci_info = (('{"address": "0000:0a:00.%s", ' +
'"physical_network": "hr_net"}') %
(pci_devspec.MAX_FUNC + 1))
(devspec.MAX_FUNC + 1))
exc = self.assertRaises(exception.PciDeviceInvalidAddressField,
pci_devspec.PciDeviceSpec, pci_info)
devspec.PciDeviceSpec, pci_info)
msg = ('Invalid PCI Whitelist: '
'The PCI address 0000:0a:00.%s has an invalid function.'
% (pci_devspec.MAX_FUNC + 1))
% (devspec.MAX_FUNC + 1))
self.assertEqual(msg, unicode(exc))
def test_max_domain(self):
pci_info = ('{"address": "%x:0a:00.5", "physical_network":"hr_net"}'
% (pci_devspec.MAX_DOMAIN + 1))
% (devspec.MAX_DOMAIN + 1))
exc = self.assertRaises(exception.PciConfigInvalidWhitelist,
pci_devspec.PciDeviceSpec, pci_info)
devspec.PciDeviceSpec, pci_info)
msg = ('Invalid PCI devices Whitelist config invalid domain %x'
% (pci_devspec.MAX_DOMAIN + 1))
% (devspec.MAX_DOMAIN + 1))
self.assertEqual(msg, unicode(exc))
def test_max_bus(self):
pci_info = ('{"address": "0000:%x:00.5", "physical_network":"hr_net"}'
% (pci_devspec.MAX_BUS + 1))
% (devspec.MAX_BUS + 1))
exc = self.assertRaises(exception.PciConfigInvalidWhitelist,
pci_devspec.PciDeviceSpec, pci_info)
devspec.PciDeviceSpec, pci_info)
msg = ('Invalid PCI devices Whitelist config invalid bus %x'
% (pci_devspec.MAX_BUS + 1))
% (devspec.MAX_BUS + 1))
self.assertEqual(msg, unicode(exc))
def test_max_slot(self):
pci_info = ('{"address": "0000:0a:%x.5", "physical_network":"hr_net"}'
% (pci_devspec.MAX_SLOT + 1))
% (devspec.MAX_SLOT + 1))
exc = self.assertRaises(exception.PciConfigInvalidWhitelist,
pci_devspec.PciDeviceSpec, pci_info)
devspec.PciDeviceSpec, pci_info)
msg = ('Invalid PCI devices Whitelist config invalid slot %x'
% (pci_devspec.MAX_SLOT + 1))
% (devspec.MAX_SLOT + 1))
self.assertEqual(msg, unicode(exc))
def test_address_is_undefined(self):
pci_info = '{"vendor_id":"8086", "product_id":"5057"}'
pci = pci_devspec.PciDeviceSpec(pci_info)
pci = devspec.PciDeviceSpec(pci_info)
self.assertTrue(pci.match(dev))
def test_partial_address(self):
pci_info = '{"address":":0a:00.", "physical_network":"hr_net"}'
pci = pci_devspec.PciDeviceSpec(pci_info)
pci = devspec.PciDeviceSpec(pci_info)
dev = {"vendor_id": "1137",
"product_id": "0071",
"address": "0000:0a:00.5",
"phys_function": "0000:0a:00.0"}
self.assertTrue(pci.match(dev))
@mock.patch('nova.pci.pci_utils.is_physical_function', return_value = True)
@mock.patch('nova.pci.utils.is_physical_function', return_value = True)
def test_address_is_pf(self, mock_is_physical_function):
pci_info = '{"address":"0000:0a:00.0", "physical_network":"hr_net"}'
pci = pci_devspec.PciDeviceSpec(pci_info)
pci = devspec.PciDeviceSpec(pci_info)
self.assertTrue(pci.match(dev))
@ -106,34 +106,34 @@ class PciDevSpecTestCase(test.NoDBTestCase):
def test_spec_match(self):
pci_info = ('{"vendor_id": "8086","address": "*: *: *.5",' +
'"product_id": "5057", "physical_network": "hr_net"}')
pci = pci_devspec.PciDeviceSpec(pci_info)
pci = devspec.PciDeviceSpec(pci_info)
self.assertTrue(pci.match(dev))
def test_invalid_vendor_id(self):
pci_info = ('{"vendor_id": "8087","address": "*: *: *.5", ' +
'"product_id": "5057", "physical_network": "hr_net"}')
pci = pci_devspec.PciDeviceSpec(pci_info)
pci = devspec.PciDeviceSpec(pci_info)
self.assertFalse(pci.match(dev))
def test_vendor_id_out_of_range(self):
pci_info = ('{"vendor_id": "80860", "address": "*:*:*.5", ' +
'"product_id": "5057", "physical_network": "hr_net"}')
exc = self.assertRaises(exception.PciConfigInvalidWhitelist,
pci_devspec.PciDeviceSpec, pci_info)
devspec.PciDeviceSpec, pci_info)
self.assertEqual("Invalid PCI devices Whitelist config "
"invalid vendor_id 80860", unicode(exc))
def test_invalid_product_id(self):
pci_info = ('{"vendor_id": "8086","address": "*: *: *.5", ' +
'"product_id": "5056", "physical_network": "hr_net"}')
pci = pci_devspec.PciDeviceSpec(pci_info)
pci = devspec.PciDeviceSpec(pci_info)
self.assertFalse(pci.match(dev))
def test_product_id_out_of_range(self):
pci_info = ('{"vendor_id": "8086","address": "*:*:*.5", ' +
'"product_id": "50570", "physical_network": "hr_net"}')
exc = self.assertRaises(exception.PciConfigInvalidWhitelist,
pci_devspec.PciDeviceSpec, pci_info)
devspec.PciDeviceSpec, pci_info)
self.assertEqual("Invalid PCI devices Whitelist config "
"invalid product_id 50570", unicode(exc))
@ -141,28 +141,28 @@ class PciDevSpecTestCase(test.NoDBTestCase):
pci_info = ('{"devname": "eth0", "vendor_id":"8086", ' +
'"address":"*:*:*.5", "physical_network": "hr_net"}')
self.assertRaises(exception.PciDeviceInvalidDeviceName,
pci_devspec.PciDeviceSpec, pci_info)
devspec.PciDeviceSpec, pci_info)
@mock.patch('nova.pci.pci_utils.get_function_by_ifname',
@mock.patch('nova.pci.utils.get_function_by_ifname',
return_value = ("0000:0a:00.0", True))
def test_by_name(self, mock_get_function_by_ifname):
pci_info = '{"devname": "eth0", "physical_network": "hr_net"}'
pci = pci_devspec.PciDeviceSpec(pci_info)
pci = devspec.PciDeviceSpec(pci_info)
self.assertTrue(pci.match(dev))
@mock.patch('nova.pci.pci_utils.get_function_by_ifname',
@mock.patch('nova.pci.utils.get_function_by_ifname',
return_value = (None, False))
def test_invalid_name(self, mock_get_function_by_ifname):
pci_info = '{"devname": "lo", "physical_network": "hr_net"}'
exc = self.assertRaises(exception.PciDeviceNotFoundById,
pci_devspec.PciDeviceSpec, pci_info)
devspec.PciDeviceSpec, pci_info)
self.assertEqual('PCI device lo not found', unicode(exc))
def test_pci_obj(self):
pci_info = ('{"vendor_id": "8086","address": "*:*:*.5", ' +
'"product_id": "5057", "physical_network": "hr_net"}')
pci = pci_devspec.PciDeviceSpec(pci_info)
pci = devspec.PciDeviceSpec(pci_info)
pci_dev = {
'compute_node_id': 1,
'address': '0000:00:00.5',
@ -172,5 +172,5 @@ class PciDevSpecTestCase(test.NoDBTestCase):
'extra_k1': 'v1',
}
pci_obj = pci_device.PciDevice.create(pci_dev)
pci_obj = objects.PciDevice.create(pci_dev)
self.assertTrue(pci.match_pci_obj(pci_obj))

16
nova/tests/pci/test_pci_manager.py → nova/tests/pci/test_manager.py
View File

@ -23,11 +23,11 @@ from nova import context
from nova import db
from nova import exception
from nova import objects
from nova.pci import pci_device
from nova.pci import pci_manager
from nova.pci import device
from nova.pci import manager
from nova import test
from nova.tests.api.openstack import fakes
from nova.tests.pci import pci_fakes
from nova.tests.pci import fakes as pci_fakes
fake_pci = {
@ -111,7 +111,7 @@ class PciDevTrackerTestCase(test.TestCase):
patcher = pci_fakes.fake_pci_whitelist()
self.addCleanup(patcher.stop)
self._create_fake_instance()
self.tracker = pci_manager.PciDevTracker(1)
self.tracker = manager.PciDevTracker(1)
def test_pcidev_tracker_create(self):
self.assertEqual(len(self.tracker.pci_devs), 3)
@ -122,7 +122,7 @@ class PciDevTrackerTestCase(test.TestCase):
self.assertEqual(self.tracker.node_id, 1)
def test_pcidev_tracker_create_no_nodeid(self):
self.tracker = pci_manager.PciDevTracker()
self.tracker = manager.PciDevTracker()
self.assertEqual(len(self.tracker.pci_devs), 0)
def test_set_hvdev_new_dev(self):
@ -260,13 +260,13 @@ class PciDevTrackerTestCase(test.TestCase):
self.assertEqual(len(self.tracker.pci_devs), 3)
dev = self.tracker.pci_devs[0]
self.update_called = 0
pci_device.remove(dev)
device.remove(dev)
self.tracker.save(ctxt)
self.assertEqual(len(self.tracker.pci_devs), 2)
self.assertEqual(self.destroy_called, 1)
def test_set_compute_node_id(self):
self.tracker = pci_manager.PciDevTracker()
self.tracker = manager.PciDevTracker()
fake_pci_devs = [copy.deepcopy(fake_pci), copy.deepcopy(fake_pci_1),
copy.deepcopy(fake_pci_2)]
self.tracker.set_hvdevs(fake_pci_devs)
@ -360,5 +360,5 @@ class PciGetInstanceDevs(test.TestCase):
self.stubs.Set(objects.Instance, 'obj_load_attr', _fake_obj_load_attr)
self.load_attr_called = False
pci_manager.get_instance_pci_devs(inst)
manager.get_instance_pci_devs(inst)
self.assertEqual(self.load_attr_called, True)

24
nova/tests/pci/test_pci_request.py → nova/tests/pci/test_request.py
View File

@ -16,7 +16,7 @@
"""Tests for PCI request."""
from nova import exception
from nova.pci import pci_request as pci_request
from nova.pci import request
from nova import test
@ -56,7 +56,7 @@ _fake_alias3 = """{
class AliasTestCase(test.NoDBTestCase):
def test_good_alias(self):
self.flags(pci_alias=[_fake_alias1])
als = pci_request._get_alias_from_config()
als = request._get_alias_from_config()
self.assertIsInstance(als['QuicAssist'], list)
expect_dict = {
"capability_type": "pci",
@ -68,7 +68,7 @@ class AliasTestCase(test.NoDBTestCase):
def test_multispec_alias(self):
self.flags(pci_alias=[_fake_alias1, _fake_alias11])
als = pci_request._get_alias_from_config()
als = request._get_alias_from_config()
self.assertIsInstance(als['QuicAssist'], list)
expect_dict1 = {
"capability_type": "pci",
@ -89,7 +89,7 @@ class AliasTestCase(test.NoDBTestCase):
def test_wrong_type_aliase(self):
self.flags(pci_alias=[_fake_alias2])
self.assertRaises(exception.PciInvalidAlias,
pci_request._get_alias_from_config)
request._get_alias_from_config)
def test_wrong_product_id_aliase(self):
self.flags(pci_alias=[
@ -101,7 +101,7 @@ class AliasTestCase(test.NoDBTestCase):
"device_type": "NIC"
}"""])
self.assertRaises(exception.PciInvalidAlias,
pci_request._get_alias_from_config)
request._get_alias_from_config)
def test_wrong_vendor_id_aliase(self):
self.flags(pci_alias=[
@ -113,7 +113,7 @@ class AliasTestCase(test.NoDBTestCase):
"device_type": "NIC"
}"""])
self.assertRaises(exception.PciInvalidAlias,
pci_request._get_alias_from_config)
request._get_alias_from_config)
def test_wrong_cap_type_aliase(self):
self.flags(pci_alias=[
@ -125,7 +125,7 @@ class AliasTestCase(test.NoDBTestCase):
"device_type": "NIC"
}"""])
self.assertRaises(exception.PciInvalidAlias,
pci_request._get_alias_from_config)
request._get_alias_from_config)
def test_dup_aliase(self):
self.flags(pci_alias=[
@ -145,7 +145,7 @@ class AliasTestCase(test.NoDBTestCase):
}"""])
self.assertRaises(
exception.PciInvalidAlias,
pci_request._get_alias_from_config)
request._get_alias_from_config)
def _verify_result(self, expected, real):
exp_real = zip(expected, real)
@ -169,7 +169,7 @@ class AliasTestCase(test.NoDBTestCase):
'capability_type': 'pci'}],
'alias_name': 'IntelNIC'}, ]
requests = pci_request._translate_alias_to_requests(
requests = request._translate_alias_to_requests(
"QuicAssist : 3, IntelNIC: 1")
self.assertEqual(set([p['count'] for p in requests]), set([1, 3]))
self._verify_result(expect_request, requests)
@ -177,7 +177,7 @@ class AliasTestCase(test.NoDBTestCase):
def test_aliase_2_request_invalid(self):
self.flags(pci_alias=[_fake_alias1, _fake_alias3])
self.assertRaises(exception.PciRequestAliasNotDefined,
pci_request._translate_alias_to_requests,
request._translate_alias_to_requests,
"QuicAssistX : 3")
def test_get_pci_requests_from_flavor(self):
@ -197,7 +197,7 @@ class AliasTestCase(test.NoDBTestCase):
flavor = {'extra_specs': {"pci_passthrough:alias":
"QuicAssist:3, IntelNIC: 1"}}
requests = pci_request.get_pci_requests_from_flavor(flavor)
requests = request.get_pci_requests_from_flavor(flavor)
self.assertEqual(set([1, 3]),
set([p.count for p in requests.requests]))
self._verify_result(expect_request, requests.requests)
@ -205,5 +205,5 @@ class AliasTestCase(test.NoDBTestCase):
def test_get_pci_requests_from_flavor_no_extra_spec(self):
self.flags(pci_alias=[_fake_alias1, _fake_alias3])
flavor = {}
requests = pci_request.get_pci_requests_from_flavor(flavor)
requests = request.get_pci_requests_from_flavor(flavor)
self.assertEqual([], requests.requests)

18
nova/tests/pci/test_pci_stats.py → nova/tests/pci/test_stats.py
View File

@ -18,10 +18,10 @@ from oslo.serialization import jsonutils
from nova import exception
from nova import objects
from nova.pci import pci_stats as pci
from nova.pci import pci_whitelist
from nova.pci import stats
from nova.pci import whitelist
from nova import test
from nova.tests.pci import pci_fakes
from nova.tests.pci import fakes
fake_pci_1 = {
'compute_node_id': 1,
@ -65,9 +65,9 @@ class PciDeviceStatsTestCase(test.NoDBTestCase):
def setUp(self):
super(PciDeviceStatsTestCase, self).setUp()
self.pci_stats = pci.PciDeviceStats()
self.pci_stats = stats.PciDeviceStats()
# The following two calls need to be made before adding the devices.
patcher = pci_fakes.fake_pci_whitelist()
patcher = fakes.fake_pci_whitelist()
self.addCleanup(patcher.stop)
self._create_fake_devs()
@ -92,7 +92,7 @@ class PciDeviceStatsTestCase(test.NoDBTestCase):
def test_json_creat(self):
m = jsonutils.dumps(self.pci_stats)
new_stats = pci.PciDeviceStats(m)
new_stats = stats.PciDeviceStats(m)
self.assertEqual(len(new_stats.pools), 2)
self.assertEqual(set([d['count'] for d in new_stats]),
@ -141,19 +141,19 @@ class PciDeviceStatsTestCase(test.NoDBTestCase):
pci_requests_multiple)
@mock.patch.object(pci_whitelist, 'get_pci_devices_filter')
@mock.patch.object(whitelist, 'get_pci_devices_filter')
class PciDeviceStatsWithTagsTestCase(test.NoDBTestCase):
def setUp(self):
super(PciDeviceStatsWithTagsTestCase, self).setUp()
self.pci_stats = pci.PciDeviceStats()
self.pci_stats = stats.PciDeviceStats()
self._create_whitelist()
def _create_whitelist(self):
white_list = ['{"vendor_id":"1137","product_id":"0071",'
'"address":"*:0a:00.*","physical_network":"physnet1"}',
'{"vendor_id":"1137","product_id":"0072"}']
self.pci_wlist = pci_whitelist.PciHostDevicesWhiteList(white_list)
self.pci_wlist = whitelist.PciHostDevicesWhiteList(white_list)
def _create_pci_devices(self):
self.pci_tagged_devices = []

16
nova/tests/pci/test_pci_utils.py → nova/tests/pci/test_utils.py
View File

@ -15,7 +15,7 @@
# under the License.
from nova import exception
from nova.pci import pci_utils
from nova.pci import utils
from nova import test
@ -26,36 +26,36 @@ class PciDeviceMatchTestCase(test.NoDBTestCase):
'device_id': 'd1'}
def test_single_spec_match(self):
self.assertTrue(pci_utils.pci_device_prop_match(
self.assertTrue(utils.pci_device_prop_match(
self.fake_pci_1, [{'vendor_id': 'v1', 'device_id': 'd1'}]))
def test_multiple_spec_match(self):
self.assertTrue(pci_utils.pci_device_prop_match(
self.assertTrue(utils.pci_device_prop_match(
self.fake_pci_1,
[{'vendor_id': 'v1', 'device_id': 'd1'},
{'vendor_id': 'v3', 'device_id': 'd3'}]))
def test_spec_dismatch(self):
self.assertFalse(pci_utils.pci_device_prop_match(
self.assertFalse(utils.pci_device_prop_match(
self.fake_pci_1,
[{'vendor_id': 'v4', 'device_id': 'd4'},
{'vendor_id': 'v3', 'device_id': 'd3'}]))
def test_spec_extra_key(self):
self.assertFalse(pci_utils.pci_device_prop_match(
self.assertFalse(utils.pci_device_prop_match(
self.fake_pci_1,
[{'vendor_id': 'v1', 'device_id': 'd1', 'wrong_key': 'k1'}]))
class PciDeviceAddressParserTestCase(test.NoDBTestCase):
def test_parse_address(self):
self.parse_result = pci_utils.parse_address("0000:04:12.6")
self.parse_result = utils.parse_address("0000:04:12.6")
self.assertEqual(self.parse_result, ('0000', '04', '12', '6'))
def test_parse_address_wrong(self):
self.assertRaises(exception.PciDeviceWrongAddressFormat,
pci_utils.parse_address, "0000:04.12:6")
utils.parse_address, "0000:04.12:6")
def test_parse_address_invalid_character(self):
self.assertRaises(exception.PciDeviceWrongAddressFormat,
pci_utils.parse_address, "0000:h4.12:6")
utils.parse_address, "0000:h4.12:6")

14
nova/tests/pci/test_pci_whitelist.py → nova/tests/pci/test_whitelist.py
View File

@ -13,7 +13,7 @@
# License for the specific language governing permissions and limitations
# under the License.
from nova.pci import pci_whitelist
from nova.pci import whitelist
from nova import test
@ -30,28 +30,28 @@ dev_dict = {
class PciHostDevicesWhiteListTestCase(test.NoDBTestCase):
def test_whitelist(self):
white_list = '{"product_id":"0001", "vendor_id":"8086"}'
parsed = pci_whitelist.PciHostDevicesWhiteList([white_list])
parsed = whitelist.PciHostDevicesWhiteList([white_list])
self.assertEqual(1, len(parsed.specs))
def test_whitelist_empty(self):
parsed = pci_whitelist.PciHostDevicesWhiteList()
parsed = whitelist.PciHostDevicesWhiteList()
self.assertFalse(parsed.device_assignable(dev_dict))
def test_whitelist_multiple(self):
wl1 = '{"product_id":"0001", "vendor_id":"8086"}'
wl2 = '{"product_id":"0002", "vendor_id":"8087"}'
parsed = pci_whitelist.PciHostDevicesWhiteList([wl1, wl2])
parsed = whitelist.PciHostDevicesWhiteList([wl1, wl2])
self.assertEqual(2, len(parsed.specs))
def test_device_assignable(self):
white_list = '{"product_id":"0001", "vendor_id":"8086"}'
parsed = pci_whitelist.PciHostDevicesWhiteList([white_list])
parsed = whitelist.PciHostDevicesWhiteList([white_list])
self.assertIsNotNone(parsed.device_assignable(dev_dict))
def test_device_assignable_multiple(self):
white_list_1 = '{"product_id":"0001", "vendor_id":"8086"}'
white_list_2 = '{"product_id":"0002", "vendor_id":"8087"}'
parsed = pci_whitelist.PciHostDevicesWhiteList(
parsed = whitelist.PciHostDevicesWhiteList(
[white_list_1, white_list_2])
self.assertIsNotNone(parsed.device_assignable(dev_dict))
dev_dict1 = dev_dict.copy()
@ -62,5 +62,5 @@ class PciHostDevicesWhiteListTestCase(test.NoDBTestCase):
def test_get_pci_devices_filter(self):
white_list_1 = '{"product_id":"0001", "vendor_id":"8086"}'
self.flags(pci_passthrough_whitelist=[white_list_1])
pci_filter = pci_whitelist.get_pci_devices_filter()
pci_filter = whitelist.get_pci_devices_filter()
self.assertIsNotNone(pci_filter.device_assignable(dev_dict))

2
nova/tests/scheduler/test_host_filters.py
View File

@ -30,7 +30,7 @@ from nova import context
from nova import db
from nova import objects
from nova.objects import base as obj_base
from nova.pci import pci_stats
from nova.pci import stats as pci_stats
from nova.scheduler import filters
from nova.scheduler.filters import extra_specs_ops
from nova.scheduler.filters import ram_filter

4
nova/tests/virt/libvirt/test_driver.py
View File

@ -57,7 +57,7 @@ from nova.openstack.common import lockutils
from nova.openstack.common import loopingcall
from nova.openstack.common import processutils
from nova.openstack.common import uuidutils
from nova.pci import pci_manager
from nova.pci import manager as pci_manager
from nova import test
from nova.tests import fake_block_device
from nova.tests import fake_instance
@ -7560,7 +7560,7 @@ class LibvirtConnTestCase(test.NoDBTestCase):
block_device_info)
@mock.patch('nova.openstack.common.loopingcall.FixedIntervalLoopingCall')
@mock.patch('nova.pci.pci_manager.get_instance_pci_devs')
@mock.patch('nova.pci.manager.get_instance_pci_devs')
@mock.patch('nova.virt.libvirt.LibvirtDriver._prepare_pci_devices_for_use')
@mock.patch('nova.virt.libvirt.LibvirtDriver._create_domain_and_network')
@mock.patch('nova.virt.libvirt.LibvirtDriver._create_images_and_backing')

2
nova/tests/virt/xenapi/test_vmops.py
View File

@ -21,7 +21,7 @@ from nova.compute import task_states
from nova import context
from nova import exception
from nova import objects
from nova.pci import pci_manager
from nova.pci import manager as pci_manager
from nova import test
from nova.tests import fake_instance
from nova.tests.virt.xenapi import stubs

2
nova/virt/libvirt/config.py
View File

@ -30,7 +30,7 @@ from oslo.utils import units
from nova import exception
from nova.openstack.common import log as logging
from nova.pci import pci_utils
from nova.pci import utils as pci_utils
from nova.virt import hardware

2
nova/virt/libvirt/designer.py
View File

@ -19,7 +19,7 @@ This module provides helper APIs for populating the config.py
classes based on common operational needs / policies
"""
from nova.pci import pci_utils
from nova.pci import utils as pci_utils
def set_vif_guest_frontend_config(conf, mac, model, driver):

6
nova/virt/libvirt/driver.py
View File

@ -81,9 +81,9 @@ from nova.openstack.common import fileutils
from nova.openstack.common import log as logging
from nova.openstack.common import loopingcall
from nova.openstack.common import processutils
from nova.pci import pci_manager
from nova.pci import pci_utils
from nova.pci import pci_whitelist
from nova.pci import manager as pci_manager
from nova.pci import utils as pci_utils
from nova.pci import whitelist as pci_whitelist
from nova import rpc
from nova import utils
from nova import version

2
nova/virt/xenapi/host.py
View File

@ -32,7 +32,7 @@ from nova import exception
from nova.i18n import _
from nova import objects
from nova.openstack.common import log as logging
from nova.pci import pci_whitelist
from nova.pci import whitelist as pci_whitelist
from nova.virt.xenapi import pool_states
from nova.virt.xenapi import vm_utils

2
nova/virt/xenapi/vmops.py
View File

@ -45,7 +45,7 @@ from nova import exception
from nova.i18n import _
from nova import objects
from nova.openstack.common import log as logging
from nova.pci import pci_manager
from nova.pci import manager as pci_manager
from nova import utils
from nova.virt import configdrive
from nova.virt import driver as virt_driver