Supporting networks with multiple PIFs.

pep8 fixes
unit tests passed

5 files changed, 142 insertions, 14 deletions

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index f5efac0ae..c1cbff7d8 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -291,7 +291,6 @@ def update_dhcp(context, network_id):
     if a dnsmasq instance is already running then send a HUP
     signal causing it to reload, otherwise spawn a new instance
     """
-    LOG.debug("ENTERING update_dhcp - DHCP script:%s",FLAGS.dhcpbridge)
     network_ref = db.network_get(context, network_id)
 
     conffile = _dhcp_file(network_ref['bridge'], 'conf')
diff --git a/nova/network/manager.py b/nova/network/manager.py
index 6ba0f2e18..85209e69f 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -499,7 +499,7 @@ class VlanManager(NetworkManager):
     def setup_compute_network(self, context, instance_id):
         """Sets up matching network for compute hosts."""
         network_ref = db.network_get_by_instance(context, instance_id)
-        #TODO: the xenapi driver will create a xenserver network if necessary here
+        #xenapi driver will create a xen network if necessary here
         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
new file mode 100644
index 000000000..289dbd71f
--- /dev/null
+++ b/nova/network/xenapi_net.py
@@ -0,0 +1,130 @@
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+"""
+Implements vlans, bridges, and iptables rules using linux utilities.
+"""
+
+import os
+
+from nova import db
+from nova import exception
+from nova import flags
+from nova import log as logging
+from nova import utils
+from nova.virt.xenapi_conn import XenAPISession
+from nova.virt.xenapi.network_utils import NetworkHelper
+
+LOG = logging.getLogger("nova.xenapi_net")
+
+FLAGS = flags.FLAGS
+flags.DEFINE_string('vlan_interface', 'eth0',
+                    'network device for vlans')
+
+
+def metadata_forward():
+    pass
+
+
+def init_host():
+    pass
+
+
+def bind_floating_ip(floating_ip, check_exit_code=True):
+    pass
+
+
+def unbind_floating_ip(floating_ip):
+    pass
+
+
+def ensure_vlan_forward(public_ip, port, private_ip):
+    pass
+
+
+def ensure_floating_forward(floating_ip, fixed_ip):
+    pass
+
+
+def remove_floating_forward(floating_ip, fixed_ip):
+    pass
+
+
+def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
+    """Create a vlan and bridge unless they already exist"""
+    #open xenapi session
+    url = FLAGS.xenapi_connection_url
+    username = FLAGS.xenapi_connection_username
+    password = FLAGS.xenapi_connection_password
+    session = XenAPISession(url, username, password)
+    #check whether bridge already exists
+    #retrieve network whose name_label is "bridge"
+    network_ref = NetworkHelper.find_network_with_name_label(session, bridge)
+    if network_ref == None:
+        #if bridge does not exists
+        #1 - create network
+        description = "network for nova bridge %s" % bridge
+        network_rec = {
+                       'name_label': bridge,
+                       'name_description': description,
+                       'other_config': {},
+                       }
+        network_ref = session.call_xenapi('network.create', network_rec)
+        #2 - find PIF for VLAN
+        expr = 'field "device" = "%s" and \
+                field "VLAN" = "-1"' % FLAGS.vlan_interface
+        pifs = session.call_xenapi('PIF.get_all_records_where', expr)
+        pif_ref = None
+        #multiple PIF are ok: we are dealing with a pool
+        if len(pifs) == 0:
+            raise Exception(
+                  _('Found no PID for device %s') % FLAGS.vlan_interface)
+        #3 - create vlan for network
+        for pif_ref in pifs.keys():
+            session.call_xenapi('VLAN.create', pif_ref,
+                                str(vlan_num), network_ref)
+    else:
+        #check VLAN tag is appropriate
+        network_rec = session.call_xenapi('network.get_record', network_ref)
+        #retrieve PIFs from network
+        for pif_ref in network_rec['PIFs']:
+            #retrieve VLAN from PIF
+            pif_rec = session.call_xenapi('PIF.get_record', pif_ref)
+            pif_vlan = int(pif_rec['VLAN'])
+            #raise an exception if VLAN <> vlan_num
+            if pif_vlan != vlan_num:
+                raise Exception(_("PIF %(pif_rec['uuid'])s for network "
+                                  "%(bridge)s has VLAN id %(pif_vlan)d."
+                                  "Expected %(vlan_num)d") % locals())
+
+
+def ensure_vlan(vlan_num):
+    pass
+
+
+def ensure_bridge(bridge, interface, net_attrs=None):
+    pass
+
+
+def get_dhcp_hosts(context, network_id):
+    pass
+
+
+def update_dhcp(context, network_id):
+    pass
+
+
+def update_ra(context, network_id):
+    pass
diff --git a/nova/virt/xenapi/network_utils.py b/nova/virt/xenapi/network_utils.py
index 8f7806e6c..c4ee8a6be 100644
--- a/nova/virt/xenapi/network_utils.py
+++ b/nova/virt/xenapi/network_utils.py
@@ -28,10 +28,9 @@ class NetworkHelper(HelperBase):
     """
     The class that wraps the helper methods together.
     """
-    
-    
+
     @classmethod
-    def find_network_with_name_label(cls,session,name_label):
+    def find_network_with_name_label(cls, session, name_label):
         networks = session.call_xenapi('network.get_by_name_label', name_label)
         if len(networks) == 1:
             return networks[0]
@@ -39,9 +38,8 @@ class NetworkHelper(HelperBase):
             raise Exception(_('Found non-unique network'
                               ' for name_label %s') % name_label)
         else:
-            return None       
-    
-    
+            return None
+
     @classmethod
     def find_network_with_bridge(cls, session, bridge):
         """Return the network on which the bridge is attached, if found."""
@@ -53,4 +51,4 @@ class NetworkHelper(HelperBase):
             raise Exception(_('Found non-unique network'
                               ' for bridge %s') % bridge)
         else:
-            raise Exception(_('Found no network for bridge %s') % bridge)       
+            raise Exception(_('Found no network for bridge %s') % bridge)
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index b5c5e082e..a0dbd1411 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -70,18 +70,19 @@ class VMOps(object):
         #this will return the bridge name in nova db
         bridge = db.network_get_by_instance(context.get_admin_context(),
                                             instance['id'])['bridge']
-                                            
+
         #this will return the appropriate network
         #TODO: avoid unnecessary call to find_network_with_bridge
         #when VLAN manager is being used (and not just use an if)
-        network_ref = None 
-        try: 
+        network_ref = None
+        try:
             network_ref = \
                 NetworkHelper.find_network_with_bridge(self._session, bridge)
         except:
-            #try to get name with name_label 
+            #try to get name with name_label
             network_ref = \
-                NetworkHelper.find_network_with_name_label(self._session,bridge)
+                NetworkHelper.find_network_with_name_label(self._session,
+                                                           bridge)
 
         user = AuthManager().get_user(instance.user_id)
         project = AuthManager().get_project(instance.project_id)