Fixed flat network manager with network index gone.

Both managers use ips created through nova manage.

Use of project_get_network is minimized to make way for managers that
would prefer to use cluste or host based ips instead of project based ips.

bin/nova-manage

@@ -375,11 +375,14 @@ class FloatingIpCommands(object):
 class NetworkCommands(object):
     """Class for managing networks."""
 
-    def create(self, num_networks=None, network_size=None,
+    def create(self, fixed_range=None, num_networks=None,
-               vlan_start=None, vpn_start=None):
+               network_size=None, vlan_start=None, vpn_start=None):
-        """Creates floating ips for host by range
+        """Creates fixed ips for host by range
-        arguments: [num_networks=FLAG], [network_size=FLAG],
+        arguments: [fixed_range=FLAG], [num_networks=FLAG],
-                   [vlan_start=FLAG, vpn_start=FLAG]"""
+                   [network_size=FLAG], [vlan_start=FLAG],
+                   [vpn_start=FLAG]"""
+        if not fixed_range:
+            fixed_range = FLAGS.fixed_range
         if not num_networks:
             num_networks = FLAGS.num_networks
         if not network_size:
@@ -388,9 +391,10 @@ class NetworkCommands(object):
             vlan_start = FLAGS.vlan_start
         if not vpn_start:
             vpn_start = FLAGS.vpn_start
-        net_manager = network_manager.VlanManager()
+        net_manager = utils.import_object(FLAGS.network_manager)
-        net_manager.create_networks(None, int(num_networks), int(network_size),
+        net_manager.create_networks(None, fixed_range, int(num_networks),
-                                    int(vlan_start), int(vpn_start))
+                                    int(network_size), int(vlan_start),
+                                    int(vpn_start))
 
 CATEGORIES = [
     ('user', UserCommands),

nova/test.py

@@ -63,7 +63,9 @@ class TrialTestCase(unittest.TestCase):
         #             now that we have some required db setup for the system
         #             to work properly.
         if db.network_count(None) != 5:
-            network_manager.VlanManager().create_networks(None, 5, 16,
+            network_manager.VlanManager().create_networks(None,
+                                                          FLAGS.fixed_range,
+                                                          5, 16,
                                                           FLAGS.vlan_start,
                                                           FLAGS.vpn_start)
 

nova/tests/compute_unittest.py

@@ -40,7 +40,8 @@ class ComputeTestCase(test.TrialTestCase):
     def setUp(self):  # pylint: disable-msg=C0103
         logging.getLogger().setLevel(logging.DEBUG)
         super(ComputeTestCase, self).setUp()
-        self.flags(connection_type='fake')
+        self.flags(connection_type='fake',
+                   network_manager='nova.network.manager.FlatManager')
         self.compute = utils.import_object(FLAGS.compute_manager)
         self.manager = manager.AuthManager()
         self.user = self.manager.create_user('fake', 'fake', 'fake')

nova/tests/network_unittest.py

@@ -52,11 +52,14 @@ class NetworkTestCase(test.TrialTestCase):
         self.context = context.APIRequestContext(project=None, user=self.user)
         for i in range(5):
             name = 'project%s' % i
-            self.projects.append(self.manager.create_project(name,
+            project = self.manager.create_project(name, 'netuser', name)
-                                                             'netuser',
+            self.projects.append(project)
-                                                             name))
             # create the necessary network data for the project
-            self.network.set_network_host(self.context, self.projects[i].id)
+            self.context.project = project
+            network_ref = self.network.get_network(self.context)
+            if not network_ref['host']:
+                self.network.set_network_host(self.context, network_ref['id'])
+        self.context.project = None
         instance_ref = db.instance_create(None,
                                          {'mac_address': utils.generate_mac()})
         self.instance_id = instance_ref['id']
@@ -84,7 +87,7 @@ class NetworkTestCase(test.TrialTestCase):
     def test_public_network_association(self):
         """Makes sure that we can allocaate a public ip"""
         # TODO(vish): better way of adding floating ips
-        pubnet = IPy.IP(flags.FLAGS.public_range)
+        pubnet = IPy.IP(flags.FLAGS.floating_range)
         address = str(pubnet[0])
         try:
             db.floating_ip_get_by_address(None, address)

nova/tests/scheduler_unittest.py

@@ -75,6 +75,7 @@ class SimpleDriverTestCase(test.TrialTestCase):
         self.flags(connection_type='fake',
                    max_cores=4,
                    max_gigabytes=4,
+                   network_manager='nova.network.manager.FlatManager',
                    volume_driver='nova.volume.driver.FakeAOEDriver',
                    scheduler_driver='nova.scheduler.simple.SimpleScheduler')
         self.scheduler = manager.SchedulerManager()