Merge lp:~soren/vmbuilder/0.12.network-plugin into lp:vmbuilder

[Soren Hansen]

[Soren Hansen (soren)]

Is the lack of feedback because there are no objections, or because it's so hideous that you don't know where to start? :)

Let's put it this way: If there are no objections by tomorrow (Friday) at 1600 UTC, I'll take the liberty of just going ahead and merging it.

[Soren Hansen (soren)]

Merged, since there were no objections.

review: Approve

=== added directory 'VMBuilder/plugins/network'
=== added file 'VMBuilder/plugins/network/__init__.py'
--- VMBuilder/plugins/network/__init__.py	1970-01-01 00:00:00 +0000
+++ VMBuilder/plugins/network/__init__.py	2010-02-02 16:27:13 +0000
@@ -0,0 +1,115 @@
+#
+#    Uncomplicated VM Builder
+#    Copyright (C) 2007-2009 Canonical Ltd.
+#    
+#    See AUTHORS for list of contributors
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License version 3, as
+#    published by the Free Software Foundation.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#    Virtual network management
+
+import logging
+import re
+import struct
+import socket
+
+from   VMBuilder           import register_plugin
+from   VMBuilder.plugins   import Plugin
+from   VMBuilder.exception import VMBuilderUserError
+
+def validate_mac(mac):
+    valid_mac_address = re.compile("^([0-9a-f]{2}:){5}([0-9a-f]{2})$", re.IGNORECASE)
+    if not valid_mac_address.match(mac):
+        return False
+    else:
+        return True
+
+def numeric_to_dotted_ip(numeric_ip):
+    return socket.inet_ntoa(struct.pack('I', numeric_ip))
+
+def dotted_to_numeric_ip(dotted_ip):
+    try:
+        return struct.unpack('I', socket.inet_aton(dotted_ip))[0] 
+    except socket.error:
+        raise VMBuilderUserError('%s is not a valid ip address' % dotted_ip)
+
+def guess_mask_from_ip(numip):
+    first_octet = numip & 0xFF
+
+    if (first_octet > 0) and (first_octet <= 127):
+        return 0xFF
+    elif (first_octet > 128) and (first_octet < 192):
+        return 0xFFFF
+    elif (first_octet < 224):
+        return 0xFFFFFF
+    else:
+        raise VMBuilderUserError('Could not guess network class of: %s' % numeric_to_dotted_ip(numip))
+
+def calculate_net_address_from_ip_and_netmask(ip, netmask):
+    return ip & netmask
+
+def calculate_broadcast_address_from_ip_and_netmask(net, mask):
+    return net + (mask ^ 0xFFFFFFFF)
+
+def guess_gw_from_ip(ip):
+    return ip + 0x01000000
+
+class NetworkPlugin(Plugin):
+    def preflight_check(self):
+        """
+        Validate the ip configuration given and set defaults
+        """
+
+        logging.debug("ip: %s" % self.vm.ip)
+        
+        if self.vm.mac:
+            if not validate_mac(mac):
+                raise VMBuilderUserError("Malformed MAC address entered: %s" % mac)
+
+        if self.vm.ip != 'dhcp':
+            if self.vm.domain == '':
+                raise VMBuilderUserError('Domain is undefined and host has no domain set.')
+
+            # num* are numeric representations
+            numip = dotted_to_numeric_ip(self.vm.ip)
+            
+            if not self.vm.mask:
+                nummask = guess_mask_from_ip(numip)
+            else:
+                nummask = dotted_to_numeric_ip(self.vm.mask)
+
+            numnet = calculate_net_address_from_ip_and_netmask(numip, nummask)
+
+            if not self.vm.net:
+                self.vm.net = numeric_to_dotted_ip(numnet)
+
+            if not self.vm.bcast:
+                numbcast = calculate_broadcast_address_from_ip_and_netmask(numnet, nummask)
+                self.vm.bcast = numeric_to_dotted_ip(numbcast)
+
+            if not self.vm.gw:
+                numgw = guess_gw_from_ip(numip)
+                self.vm.gw = numeric_to_dotted_ip(numgw)
+
+            if not self.vm.dns:
+                self.vm.dns = self.vm.gw
+
+            self.vm.mask = numeric_to_dotted_ip(nummask)
+
+            logging.debug("net: %s" % self.vm.net)
+            logging.debug("netmask: %s" % self.vm.mask)
+            logging.debug("broadcast: %s" % self.vm.bcast)
+            logging.debug("gateway: %s" % self.vm.gw)
+            logging.debug("dns: %s" % self.vm.dns)
+
+register_plugin(NetworkPlugin)

=== modified file 'VMBuilder/vm.py'
--- VMBuilder/vm.py	2009-12-08 22:27:46 +0000
+++ VMBuilder/vm.py	2010-02-02 16:27:13 +0000
@@ -272,62 +272,6 @@
             self.distro.set_defaults()
             self.hypervisor.set_defaults()
 
-
-    def ip_defaults(self):
-        """
-        is called to validate the ip configuration given and set defaults
-        """
-
-        logging.debug("ip: %s" % self.ip)
-        
-        if self.mac:
-            valid_mac_address = re.compile("([0-9a-f]{2}:){5}([0-9a-f]{2})", re.IGNORECASE)
-            if not valid_mac_address.search(self.mac):
-                raise VMBuilderUserError("Malformed MAC address entered: %s" % self.mac)
-            else:
-                logging.debug("Valid mac given: %s" % self.mac)
-
-        if self.ip != 'dhcp':
-            if self.domain == '':
-                raise VMBuilderUserError('Domain is undefined and host has no domain set.')
-
-            try:
-                numip = struct.unpack('I', socket.inet_aton(self.ip))[0] 
-            except socket.error:
-                raise VMBuilderUserError('%s is not a valid ip address' % self.ip)
-             
-            if not self.mask:
-                ipclass = numip & 0xFF
-                if (ipclass > 0) and (ipclass <= 127):
-                    mask = 0xFF
-                elif (ipclass > 128) and (ipclass < 192):
-                    mask = 0xFFFF
-                elif (ipclass < 224):
-                    mask = 0xFFFFFF
-                else:
-                    raise VMBuilderUserError('The class of the ip address specified (%s) does not seem right' % self.ip)
-            else:
-                mask = struct.unpack('I', socket.inet_aton(self.mask))[0]
-
-            numnet = numip & mask
-
-            if not self.net:
-                self.net = socket.inet_ntoa( struct.pack('I', numnet ) )
-            if not self.bcast:
-                self.bcast = socket.inet_ntoa( struct.pack('I', numnet + (mask ^ 0xFFFFFFFF)))
-            if not self.gw:
-                self.gw = socket.inet_ntoa( struct.pack('I', numnet + 0x01000000 ) )
-            if not self.dns:
-                self.dns = self.gw
-
-            self.mask = socket.inet_ntoa( struct.pack('I', mask ) )
-
-            logging.debug("net: %s" % self.net)
-            logging.debug("netmask: %s" % self.mask)
-            logging.debug("broadcast: %s" % self.bcast)
-            logging.debug("gateway: %s" % self.gw)
-            logging.debug("dns: %s" % self.dns)
-
     def create_directory_structure(self):
         """Creates the directory structure where we'll be doing all the work
 
@@ -423,7 +367,6 @@
             if '-' in opt:
                 raise VMBuilderUserError('You specified a "%s" config option in a config file, but that is not valid. Perhaps you meant "%s"?' % (opt, opt.replace('-', '_')))
 
-        self.ip_defaults()
         self.call_hooks('preflight_check')
 
         # Check repository availability

=== added file 'test/network_tests.py'
--- test/network_tests.py	1970-01-01 00:00:00 +0000
+++ test/network_tests.py	2010-02-02 16:27:13 +0000
@@ -0,0 +1,95 @@
+#
+#    Uncomplicated VM Builder
+#    Copyright (C) 2007-2009 Canonical Ltd.
+#    
+#    See AUTHORS for list of contributors
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License version 3, as
+#    published by the Free Software Foundation.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+import unittest
+
+from VMBuilder.exception import VMBuilderUserError
+from VMBuilder.plugins import network
+
+class TestNetworkPlugin(unittest.TestCase):
+    def test_validate_mac(self):
+        valid_macs = ['11:22:33:44:55:66',
+                      'ff:ff:ff:ff:ff:ff',
+                      '00:00:00:00:00:00']
+        invalid_macs = ['g1:22:33:44:55:66',
+                        '11:ff:ff:ff:ff:ff:ff',
+                        'ffffffffffff']
+        for mac in valid_macs:
+            self.assertTrue(network.validate_mac(mac), '%s was not considered a valid MAC address' % mac)
+        for mac in invalid_macs:
+            self.assertFalse(network.validate_mac(mac), '%s was not considered an invalid MAC address' % mac)
+
+    def test_dotted_to_numeric_ip(self):
+        valid_ips = ['192.168.1.1',
+                     '1.1.1.1',
+                     '10.0.0.1',
+                     '255.255.255.255']
+
+        invalid_ips = ['this is not a valid IP',
+                       '256.1.1.1']
+
+        for ip in valid_ips:
+            self.assertTrue(network.dotted_to_numeric_ip(ip), '%s was considered a valid IP address' % ip)
+        for ip in invalid_ips:
+            self.assertRaises(VMBuilderUserError, network.dotted_to_numeric_ip, ip)
+
+    def test_guess_mask_from_ip(self):
+        known_correct_values = [('10.0.0.1', 0xFF),
+                                ('127.0.0.1', 0xFF),
+                                ('172.17.0.1', 0xFFFF),
+                                ('192.168.1.1', 0xFFFFFF)]
+        
+        for ip, nummask in known_correct_values:
+            numip = network.dotted_to_numeric_ip(ip)
+            self.assertEqual(network.guess_mask_from_ip(numip), nummask, "Incorrect netmask guessed")
+
+        self.assertRaises(VMBuilderUserError, network.guess_mask_from_ip, network.dotted_to_numeric_ip('230.0.0.0'))
+
+    def test_calculate_net_address_from_ip_and_netmask(self):
+        known_correct_values = [(('192.168.1.1', '255.255.255.0'), '192.168.1.0'),
+                                (('192.168.1.1', '255.255.0.0'),   '192.168.0.0'),
+                                (('192.168.1.1', '255.0.0.0'),       '192.0.0.0'),
+                                (('192.168.1.1', '255.242.255.0'), '192.160.1.0'),
+                                (('192.168.1.1', '0.255.255.0'),     '0.168.1.0')]
+
+        for ((ip, netmask), expected_network) in known_correct_values:
+            numip               = network.dotted_to_numeric_ip(ip)
+            numnetmask          = network.dotted_to_numeric_ip(netmask)
+            self.assertEqual(network.calculate_net_address_from_ip_and_netmask(numip, numnetmask),
+                             network.dotted_to_numeric_ip(expected_network))
+
+    def test_calculate_broadcast_address_from_ip_and_netmask(self):
+        known_correct_values = [(('192.168.1.0', '255.255.255.0'), '192.168.1.255'),
+                                (('192.168.0.0', '255.255.0.0'),   '192.168.255.255'),
+                                (('192.0.0.0', '255.0.0.0'),       '192.255.255.255'),
+                                (('192.160.1.0', '255.242.255.0'), '192.173.1.255'),
+                                (('0.168.1.0', '0.255.255.0'),   '255.168.1.255')]
+
+        for ((ip, netmask), expected_bcast) in known_correct_values:
+            numip               = network.dotted_to_numeric_ip(ip)
+            numnetmask          = network.dotted_to_numeric_ip(netmask)
+            guessed_broadcast   = network.calculate_broadcast_address_from_ip_and_netmask(numip, numnetmask)
+            self.assertEqual(guessed_broadcast,
+                             network.dotted_to_numeric_ip(expected_bcast),
+                             "%s %s made %s, but expected %s" % (ip,
+                                                                 netmask,
+                                                                 network.numeric_to_dotted_ip(guessed_broadcast),
+                                                                 expected_bcast))
+
+    def test_ip_conversion(self):
+        for x in xrange(256*256):
+            self.assertEqual(x*x, network.dotted_to_numeric_ip(network.numeric_to_dotted_ip(x*x)))