removed the last few references to models.py

7 files changed, 150 insertions, 95 deletions

diff --git a/nova/db/api.py b/nova/db/api.py
index 7b3ded004..536ef1e25 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -26,7 +26,7 @@ FLAGS = flags.FLAGS
 flags.DEFINE_string('db_backend', 'sqlalchemy',
                     'The backend to use for db')
 
-# TODO(vish): where should these flags go
+# TODO(vish): where should these flags go?
 flags.DEFINE_string('network_type',
                     'vlan',
                     'Service Class for Networking')
@@ -41,6 +41,12 @@ flags.DEFINE_string('public_range', '4.4.4.0/24', 'Public IP address block')
 flags.DEFINE_string('private_range', '10.0.0.0/8', 'Private IP address block')
 flags.DEFINE_integer('cnt_vpn_clients', 5,
                         'Number of addresses reserved for vpn clients')
+flags.DEFINE_integer('num_shelves',
+                    100,
+                    'Number of vblade shelves')
+flags.DEFINE_integer('blades_per_shelf',
+                    16,
+                    'Number of vblade blades per shelf')
 
 
 
@@ -102,11 +108,9 @@ def floating_ip_allocate_address(context, node_name, project_id):
     return _impl.floating_ip_allocate_address(context, node_name, project_id)
 
 
-def floating_ip_fixed_ip_associate(context, floating_address, fixed_address):
-    """Associate an floating ip to a fixed_ip by address."""
-    return _impl.floating_ip_fixed_ip_associate(context,
-                                               floating_address,
-                                               fixed_address)
+def floating_ip_create(context, address, host):
+    """Create a floating ip for a given address on the specified host."""
+    return _impl.floating_ip_create(context, address, host)
 
 
 def floating_ip_disassociate(context, address):
@@ -122,6 +126,18 @@ def floating_ip_deallocate(context, address):
     return _impl.floating_ip_deallocate(context, address)
 
 
+def floating_ip_fixed_ip_associate(context, floating_address, fixed_address):
+    """Associate an floating ip to a fixed_ip by address."""
+    return _impl.floating_ip_fixed_ip_associate(context,
+                                               floating_address,
+                                               fixed_address)
+
+
+def floating_ip_get_by_address(context, address):
+    """Get a floating ip by address."""
+    return _impl.floating_ip_get_by_address(context, address)
+
+
 ####################
 
 
@@ -252,6 +268,26 @@ def network_allocate(context, project_id):
     return _impl.network_allocate(context, project_id)
 
 
+def network_count(context):
+    """Return the number of networks."""
+    return _impl.network_count(context)
+
+
+def network_count_allocated_ips(context, network_id):
+    """Return the number of allocated non-reserved ips in the network."""
+    return _impl.network_count_allocated_ips(context, network_id)
+
+
+def network_count_available_ips(context, network_id):
+    """Return the number of available ips in the network."""
+    return _impl.network_count_available_ips(context, network_id)
+
+
+def network_count_reserved_ips(context, network_id):
+    """Return the number of reserved ips in the network."""
+    return _impl.network_count_reserved_ips(context, network_id)
+
+
 def network_create(context, values):
     """Create a network from the values dictionary."""
     return _impl.network_create(context, values)
@@ -355,6 +391,11 @@ def volume_create(context, values):
     return _impl.volume_create(context, values)
 
 
+def volume_ensure_blades(context, num_shelves, blades_per_shelf):
+    """Ensure shelves and blades have been created in the datastore."""
+    return _impl.volume_ensure_blades(context, num_shelves, blades_per_shelf)
+
+
 def volume_destroy(context, volume_id):
     """Destroy the volume or raise if it does not exist."""
     return _impl.volume_destroy(context, volume_id)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 047a6c108..55367cec2 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -66,28 +66,40 @@ def floating_ip_allocate_address(context, node_name, project_id):
     floating_ip_ref['project_id'] = project_id
     session.add(floating_ip_ref)
     session.commit()
-    return floating_ip_ref['ip_str']
+    return floating_ip_ref['str_id']
+
+
+def floating_ip_create(context, address, host):
+    floating_ip_ref = models.FloatingIp()
+    floating_ip_ref['ip_str'] = address
+    floating_ip_ref['node_name'] = host
+    floating_ip_ref.save()
+    return floating_ip_ref
 
 
 def floating_ip_fixed_ip_associate(context, floating_address, fixed_address):
-    floating_ip_ref = models.FloatingIp.find_by_str(floating_address)
+    floating_ip_ref = db.floating_ip_get_by_address(context, floating_address)
     fixed_ip_ref = models.FixedIp.find_by_str(fixed_address)
     floating_ip_ref.fixed_ip = fixed_ip_ref
     floating_ip_ref.save()
 
 
 def floating_ip_disassociate(context, address):
-    floating_ip_ref = models.FloatingIp.find_by_str(address)
-    fixed_ip_address = floating_ip_ref.fixed_ip['ip_str']
+    floating_ip_ref = db.floating_ip_get_by_address(context, address)
+    fixed_ip_address = floating_ip_ref.fixed_ip['str_id']
     floating_ip_ref['fixed_ip'] = None
     floating_ip_ref.save()
     return fixed_ip_address
 
 def floating_ip_deallocate(context, address):
-    floating_ip_ref = models.FloatingIp.find_by_str(address)
+    floating_ip_ref = db.floating_ip_get_by_address(context, address)
     floating_ip_ref['project_id'] = None
     floating_ip_ref.save()
 
+def floating_ip_get_by_address(context, address):
+    return models.FloatingIp.find_by_str(address)
+
+
 ###################
 
 
@@ -264,6 +276,30 @@ def network_allocate(context, project_id):
     return network_id
 
 
+def network_count(context):
+    return models.Network.count()
+
+def network_count_allocated_ips(context, network_id):
+    session = models.NovaBase.get_session()
+    query = session.query(models.FixedIp).filter_by(network_id=network_id)
+    query = query.filter_by(allocated=True)
+    return query.count()
+
+
+def network_count_available_ips(context, network_id):
+    session = models.NovaBase.get_session()
+    query = session.query(models.FixedIp).filter_by(network_id=network_id)
+    query = query.filter_by(allocated=False).filter_by(reserved=False)
+    return query.count()
+
+
+def network_count_reserved_ips(context, network_id):
+    session = models.NovaBase.get_session()
+    query = session.query(models.FixedIp).filter_by(network_id=network_id)
+    query = query.filter_by(reserved=True)
+    return query.count()
+
+
 def network_create(context, values):
     network_ref = models.Network()
     for (key, value) in values.iteritems():
@@ -283,7 +319,7 @@ def network_create_fixed_ips(context, network_id, num_vpn_clients):
     session = models.NovaBase.get_session()
     for i in range(num_ips):
         fixed_ip = models.FixedIp()
-        fixed_ip.ip_str = str(project_net[i])
+        fixed_ip['ip_str'] = str(project_net[i])
         if i < BOTTOM_RESERVED or num_ips - i < TOP_RESERVED:
             fixed_ip['reserved'] = True
         fixed_ip['network'] = network_get(context, network_id)
@@ -310,7 +346,7 @@ def network_get(context, network_id):
     return models.Network.find(network_id)
 
 
-def network_get_associated_fixed_ips(contex, network_id):
+def network_get_associated_fixed_ips(context, network_id):
     session = models.NovaBase.get_session()
     query = session.query(models.FixedIp)
     fixed_ips = query.filter(models.FixedIp.instance_id != None).all()
@@ -367,7 +403,6 @@ def network_set_cidr(context, network_id, cidr):
 
 def network_set_host(context, network_id, host_id):
     session = models.NovaBase.get_session()
-    # FIXME will a second request fail or wait for first to finish?
     query = session.query(models.Network).filter_by(id=network_id)
     network = query.with_lockmode("update").first()
     if not network:
@@ -412,6 +447,9 @@ def queue_get_for(context, topic, physical_node_id):
 
 
 def volume_allocate_shelf_and_blade(context, volume_id):
+    db.volume_ensure_blades(context,
+                            FLAGS.num_shelves,
+                            FLAGS.blades_per_shelf)
     session = models.NovaBase.get_session()
     query = session.query(models.ExportDevice).filter_by(volume=None)
     export_device = query.with_lockmode("update").first()
@@ -456,6 +494,18 @@ def volume_detached(context, volume_id):
     volume_ref.save()
 
 
+# NOTE(vish): should this code go up a layer?
+def volume_ensure_blades(context, num_shelves, blades_per_shelf):
+    if models.ExportDevice.count() >= num_shelves * blades_per_shelf:
+        return
+    for shelf_id in xrange(num_shelves):
+        for blade_id in xrange(blades_per_shelf):
+            export_device = models.ExportDevice()
+            export_device.shelf_id = shelf_id
+            export_device.blade_id = blade_id
+            export_device.save()
+
+
 def volume_get(context, volume_id):
     return models.Volume.find(volume_id)
 
diff --git a/nova/tests/compute_unittest.py b/nova/tests/compute_unittest.py
index 44cc6ac15..e85973837 100644
--- a/nova/tests/compute_unittest.py
+++ b/nova/tests/compute_unittest.py
@@ -21,11 +21,11 @@ import time
 from twisted.internet import defer
 from xml.etree import ElementTree
 
+from nova import db
 from nova import exception
 from nova import flags
 from nova import test
 from nova import utils
-from nova import models
 from nova.auth import manager
 from nova.compute import service
 
@@ -69,47 +69,44 @@ class ComputeConnectionTestCase(test.TrialTestCase):
         self.manager.delete_user('fake')
         self.manager.delete_project('fake')
 
-    def create_instance(self):
-        inst = models.Instance(user_id='fake', project_id='fake', image_id='ami-test')
-        inst.save();
-        # TODO(ja): add ami, ari, aki, user_data
-        # inst['reservation_id'] = 'r-fakeres'
-        # inst['launch_time'] = '10'
-        #inst['user_id'] = 'fake'
-        #inst['project_id'] = 'fake'
-        #inst['instance_type'] = 'm1.tiny'
-        #inst['node_name'] = FLAGS.node_name
-        #inst['mac_address'] = utils.generate_mac()
-        #inst['ami_launch_index'] = 0
-        #inst.save()
-        return inst.id
+    def _create_instance(self):
+        inst = {}
+        inst['image_id'] = 'ami-test'
+        inst['reservation_id'] = 'r-fakeres'
+        inst['launch_time'] = '10'
+        inst['user_id'] = 'fake'
+        inst['project_id'] = 'fake'
+        inst['instance_type'] = 'm1.tiny'
+        inst['mac_address'] = utils.generate_mac()
+        inst['ami_launch_index'] = 0
+        return db.instance_create(None, inst)
 
     @defer.inlineCallbacks
     def test_run_describe_terminate(self):
-        instance_id = self.create_instance()
+        instance_id = self._create_instance()
 
         yield self.compute.run_instance(instance_id)
 
-        instances = models.Instance.all()
+        instances = db.instance_get_all(None)
         logging.info("Running instances: %s", instances)
         self.assertEqual(len(instances), 1)
 
         yield self.compute.terminate_instance(instance_id)
 
-        instances = models.Instance.all()
+        instances = db.instance_get_all(None)
         logging.info("After terminating instances: %s", instances)
         self.assertEqual(len(instances), 0)
 
     @defer.inlineCallbacks
     def test_reboot(self):
-        instance_id = self.create_instance()
+        instance_id = self._create_instance()
         yield self.compute.run_instance(instance_id)
         yield self.compute.reboot_instance(instance_id)
         yield self.compute.terminate_instance(instance_id)
 
     @defer.inlineCallbacks
     def test_console_output(self):
-        instance_id = self.create_instance()
+        instance_id = self._create_instance()
         rv = yield self.compute.run_instance(instance_id)
 
         console = yield self.compute.get_console_output(instance_id)
@@ -118,7 +115,7 @@ class ComputeConnectionTestCase(test.TrialTestCase):
 
     @defer.inlineCallbacks
     def test_run_instance_existing(self):
-        instance_id = self.create_instance()
+        instance_id = self._create_instance()
         yield self.compute.run_instance(instance_id)
         self.assertFailure(self.compute.run_instance(instance_id), exception.Error)
         yield self.compute.terminate_instance(instance_id)
diff --git a/nova/tests/fake_flags.py b/nova/tests/fake_flags.py
index 543641a1b..42a13e4e3 100644
--- a/nova/tests/fake_flags.py
+++ b/nova/tests/fake_flags.py
@@ -27,6 +27,8 @@ FLAGS.fake_network = True
 FLAGS.auth_driver = 'nova.auth.ldapdriver.FakeLdapDriver'
 FLAGS.network_size = 16
 FLAGS.num_networks = 5
+FLAGS.num_shelves = 2
+FLAGS.blades_per_shelf = 4
 FLAGS.verbose = True
 FLAGS.sql_connection = 'sqlite:///nova.sqlite'
 #FLAGS.sql_connection = 'mysql://root@localhost/test'
diff --git a/nova/tests/network_unittest.py b/nova/tests/network_unittest.py
index c982b18dd..d487c2e45 100644
--- a/nova/tests/network_unittest.py
+++ b/nova/tests/network_unittest.py
@@ -25,7 +25,6 @@ import logging
 from nova import db
 from nova import exception
 from nova import flags
-from nova import models
 from nova import test
 from nova import utils
 from nova.auth import manager
@@ -90,17 +89,13 @@ class NetworkTestCase(test.TrialTestCase):
         pubnet = IPy.IP(flags.FLAGS.public_range)
         ip_str = str(pubnet[0])
         try:
-            floating_ip = models.FloatingIp.find_by_str(ip_str)
+            db.floating_ip_get_by_address(None, ip_str)
         except exception.NotFound:
-            floating_ip = models.FloatingIp()
-            floating_ip.ip_str = ip_str
-            floating_ip.node_name = FLAGS.node_name
-            floating_ip.save()
+            db.floating_ip_create(None, ip_str, FLAGS.node_name)
         float_addr = self.service.allocate_floating_ip(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)
-        # FIXME datamodel abstraction
         address = db.instance_get_floating_address(None, self.instance_id)
         self.assertEqual(address, float_addr)
         self.service.disassociate_floating_ip(float_addr)
@@ -183,8 +178,7 @@ class NetworkTestCase(test.TrialTestCase):
     def test_too_many_networks(self):
         """Ensure error is raised if we run out of networks"""
         projects = []
-        # TODO(vish): use data layer for count
-        networks_left = FLAGS.num_networks - models.Network.count()
+        networks_left = FLAGS.num_networks - db.network_count(None)
         for i in range(networks_left):
             project = self.manager.create_project('many%s' % i, self.user)
             projects.append(project)
@@ -220,9 +214,9 @@ class NetworkTestCase(test.TrialTestCase):
         """
         network = db.project_get_network(None, self.projects[0].id)
         net_size = flags.FLAGS.network_size
-        total_ips = (available_ips(network) +
-                     reserved_ips(network) +
-                     allocated_ips(network))
+        total_ips = (db.network_count_available_ips(None, network['id']) +
+                     db.network_count_reserved_ips(None, network['id']) +
+                     db.network_count_allocated_ips(None, network['id']))
         self.assertEqual(total_ips, net_size)
 
     def test_too_many_addresses(self):
@@ -230,9 +224,9 @@ class NetworkTestCase(test.TrialTestCase):
         """
         network = db.project_get_network(None, self.projects[0].id)
 
-        # Number of availaible ips is len of the available list
 
-        num_available_ips = available_ips(network)
+        num_available_ips = db.network_count_available_ips(None,
+                                                           network['id'])
         addresses = []
         for i in range(num_available_ips):
             project_id = self.projects[0].id
@@ -240,7 +234,8 @@ class NetworkTestCase(test.TrialTestCase):
             addresses.append(address)
             lease_ip(address)
 
-        self.assertEqual(available_ips(network), 0)
+        self.assertEqual(db.network_count_available_ips(None,
+                                                        network['id']), 0)
         self.assertRaises(db.NoMoreAddresses,
                           db.fixed_ip_allocate,
                           None,
@@ -249,27 +244,10 @@ class NetworkTestCase(test.TrialTestCase):
         for i in range(len(addresses)):
             db.fixed_ip_deallocate(None, addresses[i])
             release_ip(addresses[i])
-        self.assertEqual(available_ips(network), num_available_ips)
-
-
-# FIXME move these to abstraction layer
-def available_ips(network):
-    session = models.NovaBase.get_session()
-    query = session.query(models.FixedIp).filter_by(network_id=network.id)
-    query = query.filter_by(allocated=False).filter_by(reserved=False)
-    return query.count()
-
-def allocated_ips(network):
-    session = models.NovaBase.get_session()
-    query = session.query(models.FixedIp).filter_by(network_id=network.id)
-    query = query.filter_by(allocated=True)
-    return query.count()
-
-def reserved_ips(network):
-    session = models.NovaBase.get_session()
-    query = session.query(models.FixedIp).filter_by(network_id=network.id)
-    query = query.filter_by(reserved=True)
-    return query.count()
+        self.assertEqual(db.network_count_available_ips(None,
+                                                        network['id']),
+                         num_available_ips)
+
 
 def is_allocated_in_project(address, project_id):
     """Returns true if address is in specified project"""
diff --git a/nova/tests/volume_unittest.py b/nova/tests/volume_unittest.py
index e6b7b07ce..a03e0e6e3 100644
--- a/nova/tests/volume_unittest.py
+++ b/nova/tests/volume_unittest.py
@@ -23,7 +23,6 @@ from twisted.internet import defer
 from nova import exception
 from nova import db
 from nova import flags
-from nova import models
 from nova import test
 from nova.compute import service as compute_service
 from nova.volume import service as volume_service
@@ -40,20 +39,7 @@ class VolumeTestCase(test.TrialTestCase):
         self.flags(connection_type='fake',
                    fake_storage=True)
         self.volume = volume_service.VolumeService()
-        self.total_slots = 10
-        # FIXME this should test actual creation method
-        self.devices = []
-        for i in xrange(self.total_slots):
-            export_device = models.ExportDevice()
-            export_device.shelf_id = 0
-            export_device.blade_id = i
-            export_device.save()
-            self.devices.append(export_device)
-
-    def tearDown(self):
-        super(VolumeTestCase, self).tearDown()
-        for device in self.devices:
-            device.delete()
+
 
     def _create_volume(self, size='0'):
         vol = {}
@@ -69,11 +55,13 @@ class VolumeTestCase(test.TrialTestCase):
     def test_run_create_volume(self):
         volume_id = self._create_volume()
         yield self.volume.create_volume(volume_id)
-        self.assertEqual(volume_id,
-                         models.Volume.find(volume_id).id)
+        self.assertEqual(volume_id, db.volume_get(None, volume_id).id)
 
         yield self.volume.delete_volume(volume_id)
-        self.assertRaises(exception.NotFound, models.Volume.find, volume_id)
+        self.assertRaises(exception.NotFound,
+                          db.volume_get,
+                          None,
+                          volume_id)
 
     @defer.inlineCallbacks
     def test_too_big_volume(self):
@@ -90,7 +78,8 @@ class VolumeTestCase(test.TrialTestCase):
     @defer.inlineCallbacks
     def test_too_many_volumes(self):
         vols = []
-        for i in xrange(self.total_slots):
+        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)
             vols.append(volume_id)
@@ -150,7 +139,8 @@ class VolumeTestCase(test.TrialTestCase):
             shelf_blades.append(shelf_blade)
             logging.debug("got %s" % shelf_blade)
         deferreds = []
-        for i in range(self.total_slots):
+        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.addCallback(_check)
@@ -158,7 +148,7 @@ class VolumeTestCase(test.TrialTestCase):
             deferreds.append(d)
         yield defer.DeferredList(deferreds)
         for volume_id in volume_ids:
-            vol = models.Volume.find(volume_id)
+            vol = db.volume_get(None, volume_id)
             vol.delete()
 
     def test_multi_node(self):
diff --git a/nova/volume/service.py b/nova/volume/service.py
index fbafd3fb5..7f6747577 100644
--- a/nova/volume/service.py
+++ b/nova/volume/service.py
@@ -43,9 +43,6 @@ flags.DEFINE_string('aoe_eth_dev', 'eth0',
 flags.DEFINE_string('aoe_export_dir',
                     '/var/lib/vblade-persist/vblades',
                     'AoE directory where exports are created')
-flags.DEFINE_integer('blades_per_shelf',
-                    16,
-                    'Number of AoE blades per shelf')
 flags.DEFINE_string('storage_availability_zone',
                     'nova',
                     'availability zone of this service')