LACP support

answerfile.py

@@ -352,36 +352,70 @@ def parseFCoEInterface(self):
 
         return results
 
+    def parseBonding(self, nethw):
+        nodes = getElementsByTagName(self.top_node, ['bonding'])
+        if len(nodes) > 1:
+            raise AnswerfileException("<bonding> must appear only once")
+        if nodes:
+            node = nodes[0]
+            bond_name = getStrAttribute(node, ['name'], mandatory=True)
+            if bond_name != "bond0":
+                raise AnswerfileException("<bonding> name must be 'bond0'")
+
+            bond_mode = getStrAttribute(node, ['mode'], mandatory=True)
+            if bond_mode != "lacp":
+                raise AnswerfileException("<bonding> mode must be 'lacp'")
+
+            bond_members_str = getStrAttribute(node, ['members'], mandatory=True)
+            bond_members = bond_members_str.split(",")
+            if len(bond_members) < 2:
+                raise AnswerfileException("<bonding> members must be at least two")
+            for member in bond_members:
+                if member not in nethw:
+                    raise AnswerfileException("<bonding> member %r not in detected NICs" % (member,))
+
+            netutil.configure_bonding_interface(nethw, bond_name, bond_mode, bond_members)
+
     def parseInterface(self):
         results = {}
         node = getElementsByTagName(self.top_node, ['admin-interface'], mandatory=True)[0]
         nethw = netutil.scanConfiguration()
-        if_hwaddr = None
+        self.parseBonding(nethw)
 
         if_name = getStrAttribute(node, ['name'])
-        if if_name and if_name in nethw:
+        if_hwaddr = getStrAttribute(node, ['hwaddr'])
+        if not (bool(if_name) ^ bool(if_hwaddr)):
+            raise AnswerfileException("<admin-interface> tag must have exactly one of 'name' or 'hwaddr'")
+
+        if if_name:
+            if if_name not in nethw:
+                raise AnswerfileException('<admin-interface name="%s">: unknown interface, have %s' % (
+                    if_name, ", ".join(nethw.keys())))
             if_hwaddr = nethw[if_name].hwaddr
+        elif if_hwaddr:
+            matching_list = [x for x in  nethw.values() if x.hwaddr == if_hwaddr.lower()]
+            if len(matching_list) != 1:
+                raise AnswerfileException('<admin-interface hwaddr="%s">: cannot identify interface, have %s' % (
+                    if_hwaddr, ", ".join(nethw.values())))
+            if_name = matching_list[0].name
         else:
-            if_hwaddr = getStrAttribute(node, ['hwaddr'])
-            if if_hwaddr:
-                matching_list = filter(lambda x: x.hwaddr == if_hwaddr.lower(), nethw.values())
-                if len(matching_list) == 1:
-                    if_name = matching_list[0].name
-        if not if_name and not if_hwaddr:
-             raise AnswerfileException("<admin-interface> tag must have one of 'name' or 'hwaddr'")
+            assert False # previous test protects us
 
+        nic = netutil.NIC({"Kernel name": if_name,
+                           "Assigned MAC": if_hwaddr,
+                           })
         results['net-admin-interface'] = if_name
 
         proto = getStrAttribute(node, ['proto'], mandatory=True)
         if proto == 'static':
             ip = getText(getElementsByTagName(node, ['ip', 'ipaddr'], mandatory=True)[0])
             subnet = getText(getElementsByTagName(node, ['subnet-mask', 'subnet'], mandatory=True)[0])
             gateway = getText(getElementsByTagName(node, ['gateway'], mandatory=True)[0])
-            results['net-admin-configuration'] = NetInterface(NetInterface.Static, if_hwaddr, ip, subnet, gateway, dns=None)
+            results['net-admin-configuration'] = NetInterface(NetInterface.Static, nic, ip, subnet, gateway, dns=None)
         elif proto == 'dhcp':
-            results['net-admin-configuration'] = NetInterface(NetInterface.DHCP, if_hwaddr)
+            results['net-admin-configuration'] = NetInterface(NetInterface.DHCP, nic)
         else:
-            results['net-admin-configuration'] = NetInterface(None, if_hwaddr)
+            results['net-admin-configuration'] = NetInterface(None, nic)
 
         protov6 = getStrAttribute(node, ['protov6'])
         if protov6 == 'static':

backend.py

@@ -1503,6 +1503,10 @@ def configureNetworking(mounts, admin_iface, admin_bridge, admin_config, hn_conf
                 print >>mc, "IPv6_GATEWAY='%s'" % admin_config.ipv6_gateway
         if admin_config.vlan:
             print >>mc, "VLAN='%d'" % admin_config.vlan
+        if admin_config.bond_mode is not None:
+            print >>mc, "BOND_MODE='%s'" % admin_config.bond_mode
+            print >>mc, "BOND_MEMBERS='%s'" % ','.join(admin_config.bond_members)
+
         mc.close()
 
     if network_backend == constants.NETWORK_BACKEND_VSWITCH:

doc/answerfile.txt

@@ -174,6 +174,14 @@ Common Elements
     Specifies additional devices to be included in the local SR.
 
 
+  <bonding name="bond0" mode="lacp" members="eth,eth[,eth]*"/>
+
+    Join given ethernet interfaces using LACP bonding.  Name of
+    resulting interface must be "bond0".  It can be then be used with
+
+      <admin-interface name="bond0"/>
+
+
   <admin-interface name="eth"/> | <admin-interface hwaddr="mac"/>
 
     Specifies the initial management interface.

doc/parameters.txt

@@ -122,29 +122,37 @@ Installer
     Proceed with installation/upgrade.
 
 
-  --answerfile=ans
+  --answerfile=url
 
     Read answerfile and perform a non-interactive installation
     reporting status using screens.
 
 
-  --rt_answerfile=ans
+  --rt_answerfile=url
 
     Read answerfile and perform a non-interactive installation
     reporting status to the console as text.
 
 
-  --answerfile_generator=script
+  --answerfile_generator=url
 
     Retrieve script, run it and use the output of it as an answerfile.
 
 
-  --answerfile_device[D]=eth|mac|all | --network_device=eth|mac|all
+  --network_device=eth|mac|lacp:members=eth,eth[,eth]*|all
+  --answerfile_device[D]=...
 
     Bring up networking on the given interface to allow access to
     answerfiles.
 
-    Default: all
+    Specification of LACP bonding configures a bond0 interfaces with
+    given members.
+
+    Default: "all" if a non-local URL is specified for any of the above
+    answerfile parameters, else no device is started
+
+    --answerfile_device is a deprecated alias, and accepts the same
+      parameters as --network_device.
 
 
   --map_netdev=eth:d|s:mac|pci[[index]]|ppn

init

@@ -51,23 +51,33 @@ def configureNetworking(ui, device, config):
 
     nethw = netutil.scanConfiguration()
     netcfg = {}
-    for i in nethw:
-        if (device == i or device == nethw[i].hwaddr) and mode == 'static':
-            netcfg[i] = NetInterface(NetInterface.Static, nethw[i].hwaddr,
-                                     config_dict['ip'], config_dict['netmask'],
-                                     config_dict['gateway'], config_dict['dns'],
-                                     config_dict['domain'], config_dict['vlan'])
+
+    if device.startswith("lacp:"):
+        bond_mode, bond_config = device.split(":", 1)
+        device = "bond0"
+        assert bond_config.startswith("members=")
+        k, v = bond_config.split("=", 1)
+        bond_members = v.split(",")
+        netutil.configure_bonding_interface(nethw, device, "lacp", bond_members)
+
+    for devname, nic in nethw.items():
+        if (device == devname or device == nic.hwaddr) and mode == 'static':
+            netcfg[devname] = NetInterface(NetInterface.Static, nic,
+                                           config_dict['ip'], config_dict['netmask'],
+                                           config_dict['gateway'], config_dict['dns'],
+                                           config_dict['domain'], config_dict['vlan'],
+                                           bond_mode=nic.bond_mode, bond_members=nic.bond_members)
         else:
-            netcfg[i] = NetInterface(NetInterface.DHCP, nethw[i].hwaddr,
-                                     vlan=config_dict['vlan'])
+            netcfg[devname] = NetInterface(NetInterface.DHCP, nic,
+                                           vlan=config_dict['vlan'])
 
     netutil.writeNetInterfaceFiles(netcfg)
     netutil.writeResolverFile(netcfg, '/etc/resolv.conf')
 
     iface_to_start = []
     if device == 'all':
         iface_to_start.extend(netcfg.keys())
-    elif device.startswith('eth'):
+    elif device.startswith('eth') or device.startswith('bond'):
         if device in nethw:
             iface_to_start.append(device)
     else: