network tests pass again

6 files changed, 83 insertions, 88 deletions

diff --git a/bin/nova-dhcpbridge b/bin/nova-dhcpbridge
index 018293e24..6747a3a0e 100755
--- a/bin/nova-dhcpbridge
+++ b/bin/nova-dhcpbridge
@@ -46,10 +46,6 @@ 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")
-        from nova import models
-        print models.FixedIp.count()
-        print models.Network.count()
-        print FLAGS.sql_connection
         service.VlanNetworkService().lease_fixed_ip(ip_address)
     else:
         rpc.cast("%s.%s" % (FLAGS.network_topic, FLAGS.node_name),
diff --git a/nova/db/api.py b/nova/db/api.py
index a30ec2cd5..2f759cb44 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -138,7 +138,7 @@ def fixed_ip_get_by_address(context, address):
 
 
 def fixed_ip_get_network(context, address):
-    """Get a fixed ip by address."""
+    """Get a network for a fixed ip by address."""
     return _impl.fixed_ip_get_network(context, address)
 
 def fixed_ip_lease(context, address):
@@ -280,12 +280,12 @@ def network_get_associated_fixed_ips(context, network_id):
     """Get all network's ips that have been associated."""
     return _impl.network_get_associated_fixed_ips(context, network_id)
 
+
 def network_get_by_bridge(context, bridge):
     """Get an network or raise if it does not exist."""
     return _impl.network_get_by_bridge(context, bridge)
 
 
-
 def network_get_host(context, network_id):
     """Get host assigned to network or raise"""
     return _impl.network_get_host(context, network_id)
diff --git a/nova/flags.py b/nova/flags.py
index e3feb252d..d4b2b7c3b 100644
--- a/nova/flags.py
+++ b/nova/flags.py
@@ -22,6 +22,7 @@ where they're used.
 """
 
 import getopt
+import os
 import socket
 import sys
 
@@ -34,7 +35,7 @@ class FlagValues(gflags.FlagValues):
     Unknown flags will be ignored when parsing the command line, but the
     command line will be kept so that it can be replayed if new flags are
     defined after the initial parsing.
-    
+
     """
 
     def __init__(self):
@@ -50,7 +51,7 @@ class FlagValues(gflags.FlagValues):
         # leftover args at the end
         sneaky_unparsed_args = {"value": None}
         original_argv = list(argv)
-        
+
         if self.IsGnuGetOpt():
             orig_getopt = getattr(getopt, 'gnu_getopt')
             orig_name = 'gnu_getopt'
@@ -74,14 +75,14 @@ class FlagValues(gflags.FlagValues):
             unparsed_args = sneaky_unparsed_args['value']
             if unparsed_args:
                 if self.IsGnuGetOpt():
-                    args = argv[:1] + unparsed
+                    args = argv[:1] + unparsed_args
                 else:
                     args = argv[:1] + original_argv[-len(unparsed_args):]
             else:
                 args = argv[:1]
         finally:
             setattr(getopt, orig_name, orig_getopt)
-        
+
         # Store the arguments for later, we'll need them for new flags
         # added at runtime
         self.__dict__['__stored_argv'] = original_argv
@@ -92,7 +93,7 @@ class FlagValues(gflags.FlagValues):
     def SetDirty(self, name):
         """Mark a flag as dirty so that accessing it will case a reparse."""
         self.__dict__['__dirty'].append(name)
-    
+
     def IsDirty(self, name):
         return name in self.__dict__['__dirty']
 
@@ -113,12 +114,12 @@ class FlagValues(gflags.FlagValues):
         for k in self.__dict__['__dirty']:
             setattr(self, k, getattr(new_flags, k))
         self.ClearDirty()
-        
+
     def __setitem__(self, name, flag):
         gflags.FlagValues.__setitem__(self, name, flag)
         if self.WasAlreadyParsed():
             self.SetDirty(name)
-    
+
     def __getitem__(self, name):
         if self.IsDirty(name):
             self.ParseNewFlags()
@@ -208,3 +209,7 @@ DEFINE_string('node_availability_zone', 'nova',
 DEFINE_string('node_name', socket.gethostname(),
               'name of this node')
 
+DEFINE_string('sql_connection',
+              'sqlite:///%s/nova.sqlite' % os.path.abspath("./"),
+              'connection string for sql database')
+
diff --git a/nova/models.py b/nova/models.py
index 7ad379814..36d6cf3ad 100644
--- a/nova/models.py
+++ b/nova/models.py
@@ -19,7 +19,6 @@
 """
 SQLAlchemy models for nova data
 """
-import os
 
 from sqlalchemy.orm import relationship, backref, validates, exc
 from sqlalchemy import Table, Column, Integer, String
@@ -34,10 +33,6 @@ FLAGS=flags.FLAGS
 
 Base = declarative_base()
 
-flags.DEFINE_string('sql_connection',
-                    'sqlite:///%s/nova.sqlite' % os.path.abspath("./"),
-                    'connection string for sql database')
-
 class NovaBase(object):
     __table_args__ = {'mysql_engine':'InnoDB'}
     __prefix__ = 'none'
diff --git a/nova/network/service.py b/nova/network/service.py
index de2c7a16c..da2953470 100644
--- a/nova/network/service.py
+++ b/nova/network/service.py
@@ -94,7 +94,6 @@ class BaseNetworkService(service.Service):
         host = db.network_set_host(context,
                                    network_id,
                                    FLAGS.node_name)
-        print 'set host'
         self._on_set_network_host(context, network_id)
         return host
 
@@ -199,7 +198,6 @@ class VlanNetworkService(BaseNetworkService):
     def _on_set_network_host(self, context, network_id):
         """Called when this host becomes the host for a project"""
         network_ref = db.network_get(context, network_id)
-        print 'making the bridge'
         _driver.ensure_vlan_bridge(network_ref['vlan'],
                                    network_ref['bridge'],
                                    network_ref)
diff --git a/nova/tests/network_unittest.py b/nova/tests/network_unittest.py
index d8a398aa4..c982b18dd 100644
--- a/nova/tests/network_unittest.py
+++ b/nova/tests/network_unittest.py
@@ -75,6 +75,15 @@ class NetworkTestCase(test.TrialTestCase):
             self.manager.delete_project(project)
         self.manager.delete_user(self.user)
 
+    def _create_address(self, project_num, instance_id=None):
+        net = db.project_get_network(None, self.projects[project_num].id)
+        fixed_ip = db.fixed_ip_allocate(None, net['id'])
+        address = fixed_ip['str_id']
+        if instance_id is None:
+            instance_id = self.instance_id
+        db.fixed_ip_instance_associate(None, address, instance_id)
+        return address
+
     def test_public_network_association(self):
         """Makes sure that we can allocaate a public ip"""
         # TODO(vish): better way of adding floating ips
@@ -87,89 +96,82 @@ class NetworkTestCase(test.TrialTestCase):
             floating_ip.ip_str = ip_str
             floating_ip.node_name = FLAGS.node_name
             floating_ip.save()
-        eaddress = self.service.allocate_floating_ip(self.projects[0].id)
-        faddress = self.service.allocate_fixed_ip(self.projects[0].id,
-                                                 self.instance_id)
-        self.assertEqual(eaddress, str(pubnet[0]))
-        self.service.associate_floating_ip(eaddress, faddress)
+        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
-        self.assertEqual(floating_ip.fixed_ip.ip_str, faddress)
-        self.service.disassociate_floating_ip(eaddress)
-        self.assertEqual(floating_ip.fixed_ip, None)
-        self.service.deallocate_floating_ip(eaddress)
-        self.service.deallocate_fixed_ip(faddress)
+        address = db.instance_get_floating_address(None, self.instance_id)
+        self.assertEqual(address, float_addr)
+        self.service.disassociate_floating_ip(float_addr)
+        address = db.instance_get_floating_address(None, self.instance_id)
+        self.assertEqual(address, None)
+        self.service.deallocate_floating_ip(float_addr)
+        db.fixed_ip_deallocate(None, fix_addr)
 
     def test_allocate_deallocate_fixed_ip(self):
         """Makes sure that we can allocate and deallocate a fixed ip"""
-        address = self.service.allocate_fixed_ip(self.projects[0].id,
-                                                 self.instance_id)
-        net = db.project_get_network(None, self.projects[0].id)
+        address = self._create_address(0)
         self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
-        issue_ip(address, net.bridge)
-        self.service.deallocate_fixed_ip(address)
+        lease_ip(address)
+        db.fixed_ip_deallocate(None, address)
 
         # Doesn't go away until it's dhcp released
         self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
 
-        release_ip(address, net.bridge)
+        release_ip(address)
         self.assertFalse(is_allocated_in_project(address, self.projects[0].id))
 
     def test_side_effects(self):
         """Ensures allocating and releasing has no side effects"""
-        address = self.service.allocate_fixed_ip(self.projects[0].id,
-                                                 self.instance_id)
-        address2 = self.service.allocate_fixed_ip(self.projects[1].id,
-                                                  self.instance2_id)
-
-        net = db.project_get_network(None, self.projects[0].id)
-        net2 = db.project_get_network(None, self.projects[1].id)
+        address = self._create_address(0)
+        address2 = self._create_address(1, self.instance2_id)
 
         self.assertTrue(is_allocated_in_project(address, self.projects[0].id))
         self.assertTrue(is_allocated_in_project(address2, self.projects[1].id))
         self.assertFalse(is_allocated_in_project(address, self.projects[1].id))
 
         # Addresses are allocated before they're issued
-        issue_ip(address, net.bridge)
-        issue_ip(address2, net2.bridge)
+        lease_ip(address)
+        lease_ip(address2)
 
-        self.service.deallocate_fixed_ip(address)
-        release_ip(address, net.bridge)
+        db.fixed_ip_deallocate(None, address)
+        release_ip(address)
         self.assertFalse(is_allocated_in_project(address, self.projects[0].id))
 
         # First address release shouldn't affect the second
         self.assertTrue(is_allocated_in_project(address2, self.projects[1].id))
 
-        self.service.deallocate_fixed_ip(address2)
-        release_ip(address2, net2.bridge)
+        db.fixed_ip_deallocate(None, address2)
+        release_ip(address2)
         self.assertFalse(is_allocated_in_project(address2, self.projects[1].id))
 
     def test_subnet_edge(self):
         """Makes sure that private ips don't overlap"""
-        first = self.service.allocate_fixed_ip(self.projects[0].id,
-                                               self.instance_id)
+        first = self._create_address(0)
+        lease_ip(first)
         for i in range(1, 5):
             project_id = self.projects[i].id
-            address = self.service.allocate_fixed_ip(project_id, self.instance_id)
-            address2 = self.service.allocate_fixed_ip(project_id, self.instance_id)
-            address3 = self.service.allocate_fixed_ip(project_id, self.instance_id)
-            net = db.project_get_network(None, project_id)
-            issue_ip(address, net.bridge)
-            issue_ip(address2, net.bridge)
-            issue_ip(address3, net.bridge)
+            address = self._create_address(i)
+            address2 = self._create_address(i)
+            address3 = self._create_address(i)
+            lease_ip(address)
+            lease_ip(address2)
+            lease_ip(address3)
             self.assertFalse(is_allocated_in_project(address,
                                                      self.projects[0].id))
             self.assertFalse(is_allocated_in_project(address2,
                                                      self.projects[0].id))
             self.assertFalse(is_allocated_in_project(address3,
                                                      self.projects[0].id))
-            self.service.deallocate_fixed_ip(address)
-            self.service.deallocate_fixed_ip(address2)
-            self.service.deallocate_fixed_ip(address3)
-            release_ip(address, net.bridge)
-            release_ip(address2, net.bridge)
-            release_ip(address3, net.bridge)
-        net = db.project_get_network(None, self.projects[0].id)
-        self.service.deallocate_fixed_ip(first)
+            db.fixed_ip_deallocate(None, address)
+            db.fixed_ip_deallocate(None, address2)
+            db.fixed_ip_deallocate(None, address3)
+            release_ip(address)
+            release_ip(address2)
+            release_ip(address3)
+        release_ip(first)
+        db.fixed_ip_deallocate(None, first)
 
     def test_vpn_ip_and_port_looks_valid(self):
         """Ensure the vpn ip and port are reasonable"""
@@ -196,17 +198,14 @@ class NetworkTestCase(test.TrialTestCase):
 
     def test_ips_are_reused(self):
         """Makes sure that ip addresses that are deallocated get reused"""
-        address = self.service.allocate_fixed_ip(self.projects[0].id,
-                                                 self.instance_id)
-        net = db.project_get_network(None, self.projects[0].id)
-        issue_ip(address, net.bridge)
-        self.service.deallocate_fixed_ip(address)
-        release_ip(address, net.bridge)
-
-        address2 = self.service.allocate_fixed_ip(self.projects[0].id,
-                                                  self.instance_id)
+        address = self._create_address(0)
+        lease_ip(address)
+        db.fixed_ip_deallocate(None, address)
+        release_ip(address)
+
+        address2 = self._create_address(0)
         self.assertEqual(address, address2)
-        self.service.deallocate_fixed_ip(address2)
+        db.fixed_ip_deallocate(None, address2)
 
     def test_available_ips(self):
         """Make sure the number of available ips for the network is correct
@@ -237,19 +236,19 @@ class NetworkTestCase(test.TrialTestCase):
         addresses = []
         for i in range(num_available_ips):
             project_id = self.projects[0].id
-            addresses.append(self.service.allocate_fixed_ip(project_id,
-                                                            self.instance_id))
-            issue_ip(addresses[i],network.bridge)
+            address = self._create_address(0)
+            addresses.append(address)
+            lease_ip(address)
 
         self.assertEqual(available_ips(network), 0)
         self.assertRaises(db.NoMoreAddresses,
-                          self.service.allocate_fixed_ip,
-                          self.projects[0].id,
-                          self.instance_id)
+                          db.fixed_ip_allocate,
+                          None,
+                          network['id'])
 
         for i in range(len(addresses)):
-            self.service.deallocate_fixed_ip(addresses[i])
-            release_ip(addresses[i],network.bridge)
+            db.fixed_ip_deallocate(None, addresses[i])
+            release_ip(addresses[i])
         self.assertEqual(available_ips(network), num_available_ips)
 
 
@@ -287,20 +286,22 @@ def binpath(script):
     return os.path.abspath(os.path.join(__file__, "../../../bin", script))
 
 
-def issue_ip(private_ip, interface):
+def lease_ip(private_ip):
     """Run add command on dhcpbridge"""
+    network_ref = db.fixed_ip_get_network(None, private_ip)
     cmd = "%s add fake %s fake" % (binpath('nova-dhcpbridge'), private_ip)
-    env = {'DNSMASQ_INTERFACE': interface,
+    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
            'TESTING': '1',
            'FLAGFILE': FLAGS.dhcpbridge_flagfile}
     (out, err) = utils.execute(cmd, addl_env=env)
     logging.debug("ISSUE_IP: %s, %s ", out, err)
 
 
-def release_ip(private_ip, interface):
+def release_ip(private_ip):
     """Run del command on dhcpbridge"""
+    network_ref = db.fixed_ip_get_network(None, private_ip)
     cmd = "%s del fake %s fake" % (binpath('nova-dhcpbridge'), private_ip)
-    env = {'DNSMASQ_INTERFACE': interface,
+    env = {'DNSMASQ_INTERFACE': network_ref['bridge'],
            'TESTING': '1',
            'FLAGFILE': FLAGS.dhcpbridge_flagfile}
     (out, err) = utils.execute(cmd, addl_env=env)