Adding unit test

6 files changed, 127 insertions, 14 deletions

diff --git a/nova/network/manager.py b/nova/network/manager.py
index 4baea482b..3b53d5d05 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -115,6 +115,7 @@ class NetworkManager(manager.Manager):
     timeout_fixed_ips = True
 
     def __init__(self, network_driver=None, *args, **kwargs):
+        LOG.debug("INIT - network driver:%s", network_driver)
         if not network_driver:
             network_driver = FLAGS.network_driver
         self.driver = utils.import_object(network_driver)
@@ -520,6 +521,7 @@ class VlanManager(NetworkManager):
     def setup_compute_network(self, context, instance_id):
         """Sets up matching network for compute hosts."""
         LOG.debug("ENTERING SETUP COMPUTE NETWORK")
+        LOG.debug("DRIVER:%s",self.driver)
         network_ref = db.network_get_by_instance(context, instance_id)
         self.driver.ensure_vlan_bridge(network_ref['vlan'],
                                        network_ref['bridge'])
diff --git a/nova/network/xenapi_net.py b/nova/network/xenapi_net.py
index 01889f94d..49214764e 100644
--- a/nova/network/xenapi_net.py
+++ b/nova/network/xenapi_net.py
@@ -29,9 +29,12 @@ from nova.virt.xenapi.network_utils import NetworkHelper
 
 LOG = logging.getLogger("nova.xenapi_net")
 
+FLAGS = flags.FLAGS
+
 def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
     """Create a vlan and bridge unless they already exist"""
     #open xenapi session
+    LOG.debug("ENTERING ensure_vlan_bridge in xenapi net")
     url = FLAGS.xenapi_connection_url
     username = FLAGS.xenapi_connection_username
     password = FLAGS.xenapi_connection_password
diff --git a/nova/tests/db/fakes.py b/nova/tests/db/fakes.py
index d760dc456..88daa82c3 100644
--- a/nova/tests/db/fakes.py
+++ b/nova/tests/db/fakes.py
@@ -23,8 +23,9 @@ from nova import db
 from nova import test
 from nova import utils
 
+from nova import log as LOG
 
-def stub_out_db_instance_api(stubs):
+def stub_out_db_instance_api(stubs, injected=True):
     """ Stubs out the db API for creating Instances """
 
     INSTANCE_TYPES = {
@@ -36,6 +37,29 @@ def stub_out_db_instance_api(stubs):
         'm1.xlarge':
             dict(memory_mb=16384, vcpus=8, local_gb=160, flavorid=5)}
 
+    flat_network_fields = {
+        'id': 'fake_flat',
+        'bridge': 'xenbr0',
+        'label': 'fake_flat_network',
+        'netmask': '255.255.255.0',
+        'gateway': '10.0.0.1',
+        'broadcast': '10.0.0.255',
+        'dns': '10.0.0.2',
+        'ra_server': None,
+        'injected': injected}
+
+    vlan_network_fields = {
+        'id': 'fake_vlan',
+        'bridge': 'br111',
+        'label': 'fake_vlan_network',
+        'netmask': '255.255.255.0',
+        'gateway': '10.0.0.1',
+        'broadcast': '10.0.0.255',
+        'dns': '10.0.0.2',
+        'ra_server': None,
+        'vlan': 111,
+        'injected': False}
+
     class FakeModel(object):
         """ Stubs out for model """
         def __init__(self, values):
@@ -81,12 +105,23 @@ def stub_out_db_instance_api(stubs):
         return FakeModel(base_options)
 
     def fake_network_get_by_instance(context, instance_id):
-        fields = {
-            'bridge': 'xenbr0',
-            }
-        return FakeModel(fields)
+        #even instance numbers are on vlan networks
+        if instance_id % 2 == 0:
+            return FakeModel(vlan_network_fields)
+        else: 
+            return FakeModel(flat_network_fields)
+    
+    def fake_network_get_all_by_instance(context, instance_id):
+        l = []
+        #even instance numbers are on vlan networks
+        if instance_id % 2 == 0:
+            l.append(FakeModel(vlan_network_fields))
+        else: 
+            l.append(FakeModel(flat_network_fields))
+        return l
 
     stubs.Set(db, 'instance_create', fake_instance_create)
     stubs.Set(db, 'network_get_by_instance', fake_network_get_by_instance)
+    stubs.Set(db, 'network_get_all_by_instance', fake_network_get_all_by_instance)
     stubs.Set(db, 'instance_type_get_all', fake_instance_type_get_all)
     stubs.Set(db, 'instance_type_get_by_name', fake_instance_type_get_by_name)
diff --git a/nova/tests/test_xenapi.py b/nova/tests/test_xenapi.py
index 26fad39d1..2cdc84882 100644
--- a/nova/tests/test_xenapi.py
+++ b/nova/tests/test_xenapi.py
@@ -165,6 +165,7 @@ class XenAPIVMTestCase(test.TestCase):
         FLAGS.xenapi_connection_password = 'test_pass'
         xenapi_fake.reset()
         xenapi_fake.create_local_srs()
+        xenapi_fake.create_local_pifs()
         db_fakes.stub_out_db_instance_api(self.stubs)
         xenapi_fake.create_network('fake', FLAGS.flat_network_bridge)
         stubs.stubout_session(self.stubs, stubs.FakeSessionForVMTests)
@@ -252,6 +253,9 @@ class XenAPIVMTestCase(test.TestCase):
 
         # Check that the VM is running according to XenAPI.
         self.assertEquals(vm['power_state'], 'Running')
+        
+        # Check that VM network is consistent with nova network
+        LOG.debug("VM INFO - NETWORK:%s", vm_info)
 
     def _test_spawn(self, image_id, kernel_id, ramdisk_id,
                     instance_type="m1.large"):
@@ -301,13 +305,25 @@ class XenAPIVMTestCase(test.TestCase):
 
     def test_spawn_vlanmanager(self):
         self.flags(xenapi_image_service = 'glance',
-                   network_manager='nova.network.manager.VlanManager',
-                   network_driver='nova.network.xenapi_net')
+                   network_manager = 'nova.network.manager.VlanManager',
+                   network_driver = 'nova.network.xenapi_net',
+                   vlan_interface = 'fake0')
         LOG.debug("Self.network:%s",self.network)
+        LOG.debug("network driver:%s",FLAGS.network_driver)
+        fake_instance_id = 2
+        network_bk=self.network
+        #ensure we use xenapi_net driver
+        self.network = utils.import_object(FLAGS.network_manager)
+        self.network.setup_compute_network(None, fake_instance_id)
         self._test_spawn(glance_stubs.FakeGlance.IMAGE_MACHINE,
                          glance_stubs.FakeGlance.IMAGE_KERNEL,
                          glance_stubs.FakeGlance.IMAGE_RAMDISK)
-        pass 
+        url = FLAGS.xenapi_connection_url
+        username = FLAGS.xenapi_connection_username
+        password = FLAGS.xenapi_connection_password
+        session = xenapi_conn.XenAPISession(url, username, password)
+        
+        self.network = network_bk
     
     def tearDown(self):
         super(XenAPIVMTestCase, self).tearDown()
diff --git a/nova/virt/xenapi/fake.py b/nova/virt/xenapi/fake.py
index ba12d4d3a..2e8cd9c5c 100644
--- a/nova/virt/xenapi/fake.py
+++ b/nova/virt/xenapi/fake.py
@@ -61,7 +61,7 @@ from nova import log as logging
 
 
 _CLASSES = ['host', 'network', 'session', 'SR', 'VBD',\
-            'PBD', 'VDI', 'VIF', 'VM', 'task']
+            'PBD', 'VDI', 'VIF', 'PIF', 'VM', 'VLAN', 'task']
 
 _db_content = {}
 
@@ -103,7 +103,6 @@ def create_vm(name_label, status,
         'is_control_domain': is_control_domain,
         })
 
-
 def destroy_vm(vm_ref):
     vm_rec = _db_content['VM'][vm_ref]
 
@@ -178,6 +177,12 @@ def create_task(name_label):
         })
 
 
+def create_local_pifs():
+    """Adds a PIF for each to the local database with VLAN=-1.  
+       Do this one per host."""
+    for host_ref in _db_content['host'].keys():
+        _create_local_pif(host_ref)
+
 def create_local_srs():
     """Create an SR that looks like the one created on the local disk by
     default by the XenServer installer.  Do this one per host."""
@@ -204,8 +209,18 @@ def _create_local_sr(host_ref):
     _db_content['SR'][sr_ref]['PBDs'] = [pbd_ref]
     return sr_ref
 
+def _create_local_pif(host_ref):
+    pif_ref= _create_object('PIF', {
+        'name-label': 'Fake PIF',
+        'MAC': '00:11:22:33:44:55',
+        'physical': True,
+        'VLAN': -1,
+        'device': 'fake0',
+        'host_uuid': host_ref,
+        })
 
 def _create_object(table, obj):
+    LOG.debug("ENTERING _create_object:%s", obj)
     ref = str(uuid.uuid4())
     obj['uuid'] = str(uuid.uuid4())
     _db_content[table][ref] = obj
@@ -228,6 +243,24 @@ def _create_sr(table, obj):
     return sr_ref
 
 
+def _create_vlan(pif_ref, vlan_num, network_ref):
+    LOG.debug("ENTERING FAKE CREATE VLAN")
+    pif_rec = get_record('PIF', pif_ref)
+    vlan_pif_ref = _create_object('PIF', {
+        'name-label': 'Fake VLAN PIF',
+        'MAC': '00:11:22:33:44:55',
+        'physical': True,
+        'VLAN': vlan_num,
+        'device': pif_rec['device'],
+        'host_uuid': pif_rec['host_uuid'],
+        })
+    return _create_object('VLAN', {
+        'tagged-pif': pif_ref,
+        'untagged-pif': vlan_pif_ref,
+        'tag': vlan_num
+        })
+
+
 def get_all(table):
     return _db_content[table].keys()
 
@@ -235,7 +268,6 @@ def get_all(table):
 def get_all_records(table):
     return _db_content[table]
 
-
 def get_record(table, ref):
     if ref in _db_content[table]:
         return _db_content[table].get(ref)
@@ -286,6 +318,26 @@ class SessionBase(object):
         rec['currently_attached'] = False
         rec['device'] = ''
 
+    def PIF_get_all_records_where(self, _1,_2):
+        # TODO (salvatore-orlando):filter table on _2 
+        return _db_content['PIF']
+
+    def VM_get_xenstore_data(self, _1, vm_ref):
+        return _db_content['VM'][vm_ref].get('xenstore_data', '')
+    
+    def VM_remove_from_xenstore_data(self, _1, vm_ref, key):
+        db_ref = _db_content['VM'][vm_ref]
+        if not 'xenstore_data' in db_ref:
+            return
+        db_ref['xenstore_data'][key] = None
+    
+    
+    def VM_add_to_xenstore_data(self, _1, vm_ref, key, value):
+        db_ref = _db_content['VM'][vm_ref]
+        if not 'xenstore_data' in db_ref:
+            db_ref['xenstore_data'] = {}
+        db_ref['xenstore_data'][key] = value
+
     def host_compute_free_memory(self, _1, ref):
         #Always return 12GB available
         return 12 * 1024 * 1024 * 1024
@@ -431,12 +483,17 @@ class SessionBase(object):
     def _create(self, name, params):
         self._check_session(params)
         is_sr_create = name == 'SR.create'
+        LOG.debug("NAME:%s",name)
+        is_vlan_create = name == 'VLAN.create'
         # Storage Repositories have a different API
-        expected = is_sr_create and 10 or 2
+        expected = is_sr_create and 10 or is_vlan_create and 4 or 2
         self._check_arg_count(params, expected)
         (cls, _) = name.split('.')
         ref = is_sr_create and \
-            _create_sr(cls, params) or _create_object(cls, params[1])
+              _create_sr(cls, params) or \
+              is_vlan_create and \
+              _create_vlan(params[1],params[2],params[3]) or \
+              _create_object(cls, params[1])
 
         # Call hook to provide any fixups needed (ex. creating backrefs)
         after_hook = 'after_%s_create' % cls
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index 0813c3db4..4bfef20f3 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -772,7 +772,7 @@ class VMOps(object):
             if network_ref:
                 try:
                     device = "1" if instance._rescue else "0"
-                except AttributeError:
+                except (AttributeError, KeyError):
                     device = "0"
 
                 VMHelper.create_vif(