From fab0bbaca8d6cf34f131c4426463bf5c76a0477f Mon Sep 17 00:00:00 2001 From: Vishvananda Ishaya Date: Sun, 29 Aug 2010 18:53:47 -0700 Subject: tests pass --- bin/nova-dhcpbridge | 21 ++--- nova/auth/manager.py | 4 +- nova/compute/service.py | 174 +---------------------------------------- nova/db/api.py | 30 +++---- nova/db/sqlalchemy/api.py | 7 ++ nova/endpoint/cloud.py | 2 +- nova/manager.py | 2 +- nova/service.py | 10 +-- nova/tests/cloud_unittest.py | 4 +- nova/tests/compute_unittest.py | 3 +- nova/tests/fake_flags.py | 10 ++- nova/tests/network_unittest.py | 14 ++-- nova/tests/service_unittest.py | 19 +++-- nova/tests/volume_unittest.py | 39 ++++----- nova/volume/driver.py | 5 -- nova/volume/manager.py | 4 +- 16 files changed, 103 insertions(+), 245 deletions(-) diff --git a/bin/nova-dhcpbridge b/bin/nova-dhcpbridge index 6747a3a0e..52ec2d497 100755 --- a/bin/nova-dhcpbridge +++ b/bin/nova-dhcpbridge @@ -34,23 +34,23 @@ from nova import db from nova import flags from nova import rpc from nova import utils -from nova.network import linux_net -from nova.network import service from nova import datastore # for redis_db flag from nova.auth import manager # for auth flags +from nova.network import manager # for network flags FLAGS = flags.FLAGS - def add_lease(_mac, ip_address, _hostname, _interface): """Set the IP that was assigned by the DHCP server.""" if FLAGS.fake_rabbit: logging.debug("leasing ip") - service.VlanNetworkService().lease_fixed_ip(ip_address) + network_manager = utils.import_object(FLAGS.network_manager) + network_manager.lease_fixed_ip(None, ip_address) else: rpc.cast("%s.%s" % (FLAGS.network_topic, FLAGS.node_name), {"method": "lease_fixed_ip", - "args": {"address": ip_address}}) + "args": {"context": None, + "address": ip_address}}) def old_lease(_mac, _ip_address, _hostname, _interface): @@ -62,20 +62,24 @@ def del_lease(_mac, ip_address, _hostname, _interface): """Called when a lease expires.""" if FLAGS.fake_rabbit: logging.debug("releasing ip") - service.VlanNetworkService().release_fixed_ip(ip_address) + network_manager = utils.import_object(FLAGS.network_manager) + network_manager.release_fixed_ip(None, ip_address) else: rpc.cast("%s.%s" % (FLAGS.network_topic, FLAGS.node_name), {"method": "release_fixed_ip", - "args": {"address": ip_address}}) + "args": {"context": None, + "address": ip_address}}) def init_leases(interface): """Get the list of hosts for an interface.""" network_ref = db.network_get_by_bridge(None, interface) - return linux_net.get_dhcp_hosts(None, network_ref['id']) + network_manager = utils.import_object(FLAGS.network_manager) + return network_manager.driver.get_dhcp_hosts(None, network_ref['id']) def main(): + global network_manager """Parse environment and arguments and call the approproate action.""" flagfile = os.environ.get('FLAGFILE', FLAGS.dhcpbridge_flagfile) utils.default_flagfile(flagfile) @@ -93,7 +97,6 @@ def main(): '..', '_trial_temp', 'nova.sqlite')) - print path FLAGS.sql_connection = 'sqlite:///%s' % path #FLAGS.sql_connection = 'mysql://root@localhost/test' action = argv[1] diff --git a/nova/auth/manager.py b/nova/auth/manager.py index a072a143b..62ec3f4e4 100644 --- a/nova/auth/manager.py +++ b/nova/auth/manager.py @@ -252,6 +252,7 @@ class AuthManager(object): __init__ is run every time AuthManager() is called, so we only reset the driver if it is not set or a new driver is specified. """ + self.network_manager = utils.import_object(FLAGS.network_manager) if driver or not getattr(self, 'driver', None): self.driver = utils.import_class(driver or FLAGS.auth_driver) @@ -525,7 +526,8 @@ class AuthManager(object): if project_dict: project = Project(**project_dict) try: - db.network_allocate(context, project.id) + self.network_manager.allocate_network(context, + project.id) except: drv.delete_project(project.id) raise diff --git a/nova/compute/service.py b/nova/compute/service.py index 877246ef6..9bf498d03 100644 --- a/nova/compute/service.py +++ b/nova/compute/service.py @@ -17,182 +17,16 @@ # under the License. """ -Compute Service: - - Runs on each compute host, managing the - hypervisor using the virt module. - +Compute service allows rpc calls to the compute manager and reports state +to the database. """ -import base64 -import logging -import os - -from twisted.internet import defer - -from nova import db -from nova import exception -from nova import flags -from nova import process from nova import service -from nova import utils -from nova.compute import power_state -from nova.network import service as network_service -from nova.virt import connection as virt_connection - - -FLAGS = flags.FLAGS -flags.DEFINE_string('instances_path', utils.abspath('../instances'), - 'where instances are stored on disk') class ComputeService(service.Service): """ - Manages the running instances. + Compute Service automatically passes commands on to the Compute Manager """ - def __init__(self): - """Load configuration options and connect to the hypervisor.""" - super(ComputeService, self).__init__() - self._instances = {} - self._conn = virt_connection.get_connection() - # TODO(joshua): This needs to ensure system state, specifically - # modprobe aoe - - def noop(self): - """Simple test of an AMQP message call.""" - return defer.succeed('PONG') - - def update_state(self, instance_id, context): - # FIXME(ja): include other fields from state? - instance_ref = db.instance_get(context, instance_id) - state = self._conn.get_info(instance_ref.name)['state'] - db.instance_state(context, instance_id, state) - - @defer.inlineCallbacks - @exception.wrap_exception - def run_instance(self, instance_id, context=None, **_kwargs): - """Launch a new instance with specified options.""" - instance_ref = db.instance_get(context, instance_id) - if instance_ref['str_id'] in self._conn.list_instances(): - raise exception.Error("Instance has already been created") - logging.debug("Starting instance %s..." % (instance_id)) - - network_service.setup_compute_network(context, instance_ref['project_id']) - db.instance_update(context, instance_id, {'node_name': FLAGS.node_name}) - - # TODO(vish) check to make sure the availability zone matches - db.instance_state(context, instance_id, power_state.NOSTATE, 'spawning') - - try: - yield self._conn.spawn(instance_ref) - except: - logging.exception("Failed to spawn instance %s" % - instance_ref['str_id']) - db.instance_state(context, instance_id, power_state.SHUTDOWN) - - self.update_state(instance_id, context) - - @defer.inlineCallbacks - @exception.wrap_exception - def terminate_instance(self, instance_id, context=None): - """Terminate an instance on this machine.""" - logging.debug("Got told to terminate instance %s" % instance_id) - instance_ref = db.instance_get(context, instance_id) - - if instance_ref['state'] == power_state.SHUTOFF: - # self.datamodel.destroy() FIXME: RE-ADD? - raise exception.Error('trying to destroy already destroyed' - ' instance: %s' % instance_id) - - db.instance_state( - context, instance_id, power_state.NOSTATE, 'shutting_down') - yield self._conn.destroy(instance_ref) - - # FIXME(ja): should we keep it in a terminated state for a bit? - db.instance_destroy(context, instance_id) - - @defer.inlineCallbacks - @exception.wrap_exception - def reboot_instance(self, instance_id, context=None): - """Reboot an instance on this server. - - KVM doesn't support reboot, so we terminate and restart. - - """ - self.update_state(instance_id, context) - instance_ref = db.instance_get(context, instance_id) - - # FIXME(ja): this is only checking the model state - not state on disk? - if instance_ref['state'] != power_state.RUNNING: - raise exception.Error( - 'trying to reboot a non-running' - 'instance: %s (state: %s excepted: %s)' % - (instance_ref['str_id'], - instance_ref['state'], - power_state.RUNNING)) - - logging.debug('rebooting instance %s' % instance_ref['str_id']) - db.instance_state( - context, instance_id, power_state.NOSTATE, 'rebooting') - yield self._conn.reboot(instance_ref) - self.update_state(instance_id, context) - - @exception.wrap_exception - def get_console_output(self, instance_id, context=None): - """Send the console output for an instance.""" - # FIXME: Abstract this for Xen - - logging.debug("Getting console output for %s" % (instance_id)) - instance_ref = db.instance_get(context, instance_id) - - if FLAGS.connection_type == 'libvirt': - fname = os.path.abspath(os.path.join(FLAGS.instances_path, - instance_ref['str_id'], - 'console.log')) - with open(fname, 'r') as f: - output = f.read() - else: - output = 'FAKE CONSOLE OUTPUT' - - # TODO(termie): this stuff belongs in the API layer, no need to - # munge the data we send to ourselves - output = {"InstanceId" : instance_id, - "Timestamp" : "2", - "output" : base64.b64encode(output)} - return output - - @defer.inlineCallbacks - @exception.wrap_exception - def attach_volume(self, instance_id=None, volume_id=None, mountpoint=None, - context=None): - """Attach a volume to an instance.""" - # TODO(termie): check that instance_id exists - volume_ref = db.volume_get(context, volume_id) - yield self._init_aoe() - yield process.simple_execute( - "sudo virsh attach-disk %s /dev/etherd/%s %s" % - (instance_id, - volume_ref['aoe_device'], - mountpoint.rpartition('/dev/')[2])) - db.volume_attached(context, volume_id) - defer.returnValue(True) - - @defer.inlineCallbacks - @exception.wrap_exception - def detach_volume(self, instance_id, volume_id, context=None): - """Detach a volume from an instance.""" - # despite the documentation, virsh detach-disk just wants the device - # name without the leading /dev/ - # TODO(termie): check that instance_id exists - volume_ref = db.volume_get(context, volume_id) - target = volume_ref['mountpoint'].rpartition('/dev/')[2] - yield process.simple_execute( - "sudo virsh detach-disk %s %s " % (instance_id, target)) - db.volume_detached(context, volume_id) - defer.returnValue(True) + pass - @defer.inlineCallbacks - def _init_aoe(self): - # TODO(vish): these shell calls should move into a different layer. - yield process.simple_execute("sudo aoe-discover") - yield process.simple_execute("sudo aoe-stat") diff --git a/nova/db/api.py b/nova/db/api.py index 699118b16..80583de99 100644 --- a/nova/db/api.py +++ b/nova/db/api.py @@ -123,6 +123,16 @@ def fixed_ip_allocate(context, network_id): return _impl.fixed_ip_allocate(context, network_id) +def fixed_ip_create(context, network_id, address): + """Create a fixed ip from the values dictionary.""" + return _impl.fixed_ip_create(context, network_id, address) + + +def fixed_ip_deallocate(context, address): + """Deallocate a fixed ip by address.""" + return _impl.fixed_ip_deallocate(context, address) + + def fixed_ip_get_by_address(context, address): """Get a fixed ip by address.""" return _impl.fixed_ip_get_by_address(context, address) @@ -133,21 +143,6 @@ def fixed_ip_get_network(context, address): return _impl.fixed_ip_get_network(context, address) -def fixed_ip_lease(context, address): - """Lease a fixed ip by address.""" - return _impl.fixed_ip_lease(context, address) - - -def fixed_ip_release(context, address): - """Un-Lease a fixed ip by address.""" - return _impl.fixed_ip_release(context, address) - - -def fixed_ip_deallocate(context, address): - """Deallocate a fixed ip by address.""" - return _impl.fixed_ip_deallocate(context, address) - - def fixed_ip_instance_associate(context, address, instance_id): """Associate a fixed ip to an instance by address.""" return _impl.fixed_ip_instance_associate(context, address, instance_id) @@ -158,6 +153,11 @@ def fixed_ip_instance_disassociate(context, address): return _impl.fixed_ip_instance_disassociate(context, address) +def fixed_ip_update(context, address, values): + """Create a fixed ip from the values dictionary.""" + return _impl.fixed_ip_update(context, address, values) + + #################### diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py index b95346861..12455530d 100644 --- a/nova/db/sqlalchemy/api.py +++ b/nova/db/sqlalchemy/api.py @@ -149,6 +149,13 @@ def fixed_ip_instance_disassociate(context, address): fixed_ip_ref.save() +def fixed_ip_update(context, address, values): + fixed_ip_ref = fixed_ip_get_by_address(context, address) + for (key, value) in values.iteritems(): + fixed_ip_ref[key] = value + fixed_ip_ref.save() + + ################### diff --git a/nova/endpoint/cloud.py b/nova/endpoint/cloud.py index ceff0f827..8ba10a5bb 100644 --- a/nova/endpoint/cloud.py +++ b/nova/endpoint/cloud.py @@ -60,7 +60,7 @@ class CloudController(object): sent to the other nodes. """ def __init__(self): - self.network_manager = utils.load_object(FLAGS.network_manager) + self.network_manager = utils.import_object(FLAGS.network_manager) self.setup() def __str__(self): diff --git a/nova/manager.py b/nova/manager.py index 4f212a41b..20b58bd13 100644 --- a/nova/manager.py +++ b/nova/manager.py @@ -25,7 +25,7 @@ from nova import flags FLAGS = flags.FLAGS -flags.DEFINE_string('db_driver', 'nova.db.api' +flags.DEFINE_string('db_driver', 'nova.db.api', 'driver to use for volume creation') diff --git a/nova/service.py b/nova/service.py index 59da6f04e..b20e24348 100644 --- a/nova/service.py +++ b/nova/service.py @@ -46,9 +46,10 @@ class Service(object, service.Service): def __init__(self, manager, *args, **kwargs): self.manager = manager - super(self, Service).__init__(*args, **kwargs) + super(Service, self).__init__(*args, **kwargs) def __getattr__(self, key): + print 'getattr' try: super(Service, self).__getattr__(key) except AttributeError: @@ -65,7 +66,7 @@ class Service(object, service.Service): Args: report_interval, defaults to flag bin_name, defaults to basename of executable - topic, defaults to basename - "nova-" part + topic, defaults to bin_name - "nova-" part manager, defaults to FLAGS._manager """ if not report_interval: @@ -77,17 +78,15 @@ class Service(object, service.Service): if not topic: topic = bin_name.rpartition("nova-")[2] if not manager: - manager = FLAGS.get('%s_manager' % topic) + manager = FLAGS.get('%s_manager' % topic, None) manager_ref = utils.import_object(manager) logging.warn("Starting %s node" % topic) service_ref = cls(manager_ref) - conn = rpc.Connection.instance() consumer_all = rpc.AdapterConsumer( connection=conn, topic='%s' % topic, proxy=service_ref) - consumer_node = rpc.AdapterConsumer( connection=conn, topic='%s.%s' % (topic, FLAGS.node_name), @@ -110,6 +109,7 @@ class Service(object, service.Service): @defer.inlineCallbacks def report_state(self, node_name, binary, context=None): """Update the state of this daemon in the datastore.""" + print 'report_state' try: try: daemon_ref = db.daemon_get_by_args(context, node_name, binary) diff --git a/nova/tests/cloud_unittest.py b/nova/tests/cloud_unittest.py index 3501771cc..df2246aae 100644 --- a/nova/tests/cloud_unittest.py +++ b/nova/tests/cloud_unittest.py @@ -27,8 +27,8 @@ from xml.etree import ElementTree from nova import flags from nova import rpc from nova import test +from nova import utils from nova.auth import manager -from nova.compute import service from nova.endpoint import api from nova.endpoint import cloud @@ -53,7 +53,7 @@ class CloudTestCase(test.BaseTestCase): self.injected.append(self.cloud_consumer.attach_to_tornado(self.ioloop)) # set up a service - self.compute = service.ComputeService() + self.compute = utils.import_class(FLAGS.compute_manager) self.compute_consumer = rpc.AdapterConsumer(connection=self.conn, topic=FLAGS.compute_topic, proxy=self.compute) diff --git a/nova/tests/compute_unittest.py b/nova/tests/compute_unittest.py index e85973837..28e51f387 100644 --- a/nova/tests/compute_unittest.py +++ b/nova/tests/compute_unittest.py @@ -27,7 +27,6 @@ from nova import flags from nova import test from nova import utils from nova.auth import manager -from nova.compute import service FLAGS = flags.FLAGS @@ -60,7 +59,7 @@ class ComputeConnectionTestCase(test.TrialTestCase): super(ComputeConnectionTestCase, self).setUp() self.flags(connection_type='fake', fake_storage=True) - self.compute = service.ComputeService() + self.compute = utils.import_object(FLAGS.compute_manager) self.manager = manager.AuthManager() user = self.manager.create_user('fake', 'fake', 'fake') project = self.manager.create_project('fake', 'fake', 'fake') diff --git a/nova/tests/fake_flags.py b/nova/tests/fake_flags.py index 42a13e4e3..3114912ba 100644 --- a/nova/tests/fake_flags.py +++ b/nova/tests/fake_flags.py @@ -20,13 +20,19 @@ from nova import flags FLAGS = flags.FLAGS -FLAGS.connection_type = 'fake' +flags.DECLARE('fake_storage', 'nova.volume.manager') FLAGS.fake_storage = True +FLAGS.connection_type = 'fake' FLAGS.fake_rabbit = True -FLAGS.fake_network = True FLAGS.auth_driver = 'nova.auth.ldapdriver.FakeLdapDriver' +flags.DECLARE('network_size', 'nova.network.manager') +flags.DECLARE('num_networks', 'nova.network.manager') +flags.DECLARE('fake_network', 'nova.network.manager') FLAGS.network_size = 16 FLAGS.num_networks = 5 +FLAGS.fake_network = True +flags.DECLARE('num_shelves', 'nova.volume.manager') +flags.DECLARE('blades_per_shelf', 'nova.volume.manager') FLAGS.num_shelves = 2 FLAGS.blades_per_shelf = 4 FLAGS.verbose = True diff --git a/nova/tests/network_unittest.py b/nova/tests/network_unittest.py index d487c2e45..e3fe01fa2 100644 --- a/nova/tests/network_unittest.py +++ b/nova/tests/network_unittest.py @@ -49,14 +49,15 @@ class NetworkTestCase(test.TrialTestCase): self.manager = manager.AuthManager() self.user = self.manager.create_user('netuser', 'netuser', 'netuser') self.projects = [] - self.service = service.VlanNetworkService() + self.network = utils.import_object(FLAGS.network_manager) + self.context = None for i in range(5): name = 'project%s' % i self.projects.append(self.manager.create_project(name, 'netuser', name)) # create the necessary network data for the project - self.service.set_network_host(self.projects[i].id) + self.network.set_network_host(self.context, self.projects[i].id) instance_id = db.instance_create(None, {'mac_address': utils.generate_mac()}) self.instance_id = instance_id @@ -92,16 +93,17 @@ class NetworkTestCase(test.TrialTestCase): db.floating_ip_get_by_address(None, ip_str) except exception.NotFound: db.floating_ip_create(None, ip_str, FLAGS.node_name) - float_addr = self.service.allocate_floating_ip(self.projects[0].id) + float_addr = self.network.allocate_floating_ip(self.context, + self.projects[0].id) fix_addr = self._create_address(0) self.assertEqual(float_addr, str(pubnet[0])) - self.service.associate_floating_ip(float_addr, fix_addr) + self.network.associate_floating_ip(self.context, float_addr, fix_addr) address = db.instance_get_floating_address(None, self.instance_id) self.assertEqual(address, float_addr) - self.service.disassociate_floating_ip(float_addr) + self.network.disassociate_floating_ip(self.context, float_addr) address = db.instance_get_floating_address(None, self.instance_id) self.assertEqual(address, None) - self.service.deallocate_floating_ip(float_addr) + self.network.deallocate_floating_ip(self.context, float_addr) db.fixed_ip_deallocate(None, fix_addr) def test_allocate_deallocate_fixed_ip(self): diff --git a/nova/tests/service_unittest.py b/nova/tests/service_unittest.py index 0b9d60024..e13fe62d1 100644 --- a/nova/tests/service_unittest.py +++ b/nova/tests/service_unittest.py @@ -30,10 +30,16 @@ from nova import flags from nova import rpc from nova import test from nova import service - +from nova import manager FLAGS = flags.FLAGS +flags.DEFINE_string("fake_manager", "nova.tests.service_unittest.FakeManager", + "Manager for testing") + +class FakeManager(manager.Manager): + """Fake manager for tests""" + pass class ServiceTestCase(test.BaseTestCase): """Test cases for rpc""" @@ -46,12 +52,12 @@ class ServiceTestCase(test.BaseTestCase): self.mox.StubOutWithMock( service.task, 'LoopingCall', use_mock_anything=True) rpc.AdapterConsumer(connection=mox.IgnoreArg(), - topic='run_tests.py', + topic='fake', proxy=mox.IsA(service.Service) ).AndReturn(rpc.AdapterConsumer) rpc.AdapterConsumer(connection=mox.IgnoreArg(), - topic='run_tests.py.%s' % FLAGS.node_name, + topic='fake.%s' % FLAGS.node_name, proxy=mox.IsA(service.Service) ).AndReturn(rpc.AdapterConsumer) @@ -67,7 +73,7 @@ class ServiceTestCase(test.BaseTestCase): rpc.AdapterConsumer.attach_to_twisted() self.mox.ReplayAll() - app = service.Service.create() + app = service.Service.create(bin_name='nova-fake') self.assert_(app) # We're testing sort of weird behavior in how report_state decides @@ -82,7 +88,7 @@ class ServiceTestCase(test.BaseTestCase): 'binary': binary, 'report_count': 0, 'id': 1} - + service.db.__getattr__('report_state') service.db.daemon_get_by_args(None, node_name, binary).AndReturn(daemon_ref) @@ -105,6 +111,7 @@ class ServiceTestCase(test.BaseTestCase): 'report_count': 0, 'id': 1} + service.db.__getattr__('report_state') service.db.daemon_get_by_args(None, node_name, binary).AndRaise(exception.NotFound()) @@ -126,6 +133,7 @@ class ServiceTestCase(test.BaseTestCase): 'report_count': 0, 'id': 1} + service.db.__getattr__('report_state') service.db.daemon_get_by_args(None, node_name, binary).AndRaise(Exception()) @@ -145,6 +153,7 @@ class ServiceTestCase(test.BaseTestCase): 'report_count': 0, 'id': 1} + service.db.__getattr__('report_state') service.db.daemon_get_by_args(None, node_name, binary).AndReturn(daemon_ref) diff --git a/nova/tests/volume_unittest.py b/nova/tests/volume_unittest.py index a03e0e6e3..4504276e2 100644 --- a/nova/tests/volume_unittest.py +++ b/nova/tests/volume_unittest.py @@ -24,8 +24,7 @@ from nova import exception from nova import db from nova import flags from nova import test -from nova.compute import service as compute_service -from nova.volume import service as volume_service +from nova import utils FLAGS = flags.FLAGS @@ -35,10 +34,11 @@ class VolumeTestCase(test.TrialTestCase): def setUp(self): logging.getLogger().setLevel(logging.DEBUG) super(VolumeTestCase, self).setUp() - self.compute = compute_service.ComputeService() + self.compute = utils.import_object(FLAGS.compute_manager) self.flags(connection_type='fake', fake_storage=True) - self.volume = volume_service.VolumeService() + self.volume = utils.import_object(FLAGS.volume_manager) + self.context = None def _create_volume(self, size='0'): @@ -49,15 +49,15 @@ class VolumeTestCase(test.TrialTestCase): vol['availability_zone'] = FLAGS.storage_availability_zone vol['status'] = "creating" vol['attach_status'] = "detached" - return db.volume_create(None, vol) + return db.volume_create(None, vol)['id'] @defer.inlineCallbacks def test_run_create_volume(self): volume_id = self._create_volume() - yield self.volume.create_volume(volume_id) + yield self.volume.create_volume(self.context, volume_id) self.assertEqual(volume_id, db.volume_get(None, volume_id).id) - yield self.volume.delete_volume(volume_id) + yield self.volume.delete_volume(self.context, volume_id) self.assertRaises(exception.NotFound, db.volume_get, None, @@ -70,7 +70,7 @@ class VolumeTestCase(test.TrialTestCase): defer.returnValue(True) try: volume_id = self._create_volume('1001') - yield self.volume.create_volume(volume_id) + yield self.volume.create_volume(self.context, volume_id) self.fail("Should have thrown TypeError") except TypeError: pass @@ -81,14 +81,15 @@ class VolumeTestCase(test.TrialTestCase): total_slots = FLAGS.num_shelves * FLAGS.blades_per_shelf for i in xrange(total_slots): volume_id = self._create_volume() - yield self.volume.create_volume(volume_id) + yield self.volume.create_volume(self.context, volume_id) vols.append(volume_id) volume_id = self._create_volume() - self.assertFailure(self.volume.create_volume(volume_id), + self.assertFailure(self.volume.create_volume(self.context, + volume_id), db.NoMoreBlades) db.volume_destroy(None, volume_id) - for id in vols: - yield self.volume.delete_volume(id) + for volume_id in vols: + yield self.volume.delete_volume(self.context, volume_id) @defer.inlineCallbacks def test_run_attach_detach_volume(self): @@ -96,7 +97,7 @@ class VolumeTestCase(test.TrialTestCase): instance_id = "storage-test" mountpoint = "/dev/sdf" volume_id = self._create_volume() - yield self.volume.create_volume(volume_id) + yield self.volume.create_volume(self.context, volume_id) if FLAGS.fake_tests: db.volume_attached(None, volume_id, instance_id, mountpoint) else: @@ -109,15 +110,16 @@ class VolumeTestCase(test.TrialTestCase): self.assertEqual(vol['instance_id'], instance_id) self.assertEqual(vol['mountpoint'], mountpoint) - self.assertFailure(self.volume.delete_volume(volume_id), exception.Error) + self.assertFailure(self.volume.delete_volume(self.context, volume_id), + exception.Error) if FLAGS.fake_tests: db.volume_detached(None, volume_id) else: - rv = yield self.volume.detach_volume(instance_id, + rv = yield self.compute.detach_volume(instance_id, volume_id) self.assertEqual(vol['status'], "available") - rv = self.volume.delete_volume(volume_id) + rv = self.volume.delete_volume(self.context, volume_id) self.assertRaises(exception.Error, db.volume_get, None, @@ -142,14 +144,13 @@ class VolumeTestCase(test.TrialTestCase): total_slots = FLAGS.num_shelves * FLAGS.blades_per_shelf for i in range(total_slots): volume_id = self._create_volume() - d = self.volume.create_volume(volume_id) + d = self.volume.create_volume(self.context, volume_id) d.addCallback(_check) d.addErrback(self.fail) deferreds.append(d) yield defer.DeferredList(deferreds) for volume_id in volume_ids: - vol = db.volume_get(None, volume_id) - vol.delete() + self.volume.delete_volume(self.context, volume_id) def test_multi_node(self): # TODO(termie): Figure out how to test with two nodes, diff --git a/nova/volume/driver.py b/nova/volume/driver.py index 579472047..e0468b877 100644 --- a/nova/volume/driver.py +++ b/nova/volume/driver.py @@ -39,25 +39,20 @@ flags.DEFINE_string('aoe_eth_dev', 'eth0', class FakeAOEDriver(object): - @defer.inlineCallbacks def create_volume(self, volume_id, size): logging.debug("Fake AOE: create_volume %s, %s", volume_id, size) - @defer.inlineCallbacks def delete_volume(self, volume_id): logging.debug("Fake AOE: delete_volume %s", volume_id) - @defer.inlineCallbacks def create_export(self, volume_id, shelf_id, blade_id): logging.debug("Fake AOE: create_export %s, %s, %s", volume_id, shelf_id, blade_id) - @defer.inlineCallbacks def remove_export(self, volume_id, shelf_id, blade_id): logging.debug("Fake AOE: remove_export %s, %s, %s", volume_id, shelf_id, blade_id) - @defer.inlineCallbacks def ensure_exports(self): logging.debug("Fake AOE: ensure_export") diff --git a/nova/volume/manager.py b/nova/volume/manager.py index 0683703a1..7d8e1aca0 100644 --- a/nova/volume/manager.py +++ b/nova/volume/manager.py @@ -38,7 +38,7 @@ flags.DEFINE_string('storage_availability_zone', 'availability zone of this service') flags.DEFINE_boolean('fake_storage', False, 'Should we make real storage volumes to attach?') -flags.DEFINE_string('volume_driver', 'nova.volume.driver.AOEDriver' +flags.DEFINE_string('volume_driver', 'nova.volume.driver.AOEDriver', 'Driver to use for volume creation') flags.DEFINE_integer('num_shelves', 100, @@ -60,7 +60,7 @@ class AOEManager(manager.Manager): super(AOEManager, self).__init__(*args, **kwargs) def _ensure_blades(self, context): - total_blades = FLAGS.num_shelves, FLAGS.blades_per_shelf + total_blades = FLAGS.num_shelves * FLAGS.blades_per_shelf if self.db.export_device_count(context) >= total_blades: return for shelf_id in xrange(FLAGS.num_shelves): -- cgit