initial copy of curtin net

just add curtin/net as cloudinit/net
and then copy curtin/udev.py as cloudinit/net/udev.py

3 files changed, 890 insertions, 0 deletions

diff --git a/cloudinit/net/__init__.py b/cloudinit/net/__init__.py
new file mode 100644
index 00000000..e5ca050e
--- /dev/null
+++ b/cloudinit/net/__init__.py
@@ -0,0 +1,436 @@
+#   Copyright (C) 2013-2014 Canonical Ltd.
+#
+#   Author: Scott Moser <scott.moser@canonical.com>
+#   Author: Blake Rouse <blake.rouse@canonical.com>
+#
+#   Curtin is free software: you can redistribute it and/or modify it under
+#   the terms of the GNU Affero General Public License as published by the
+#   Free Software Foundation, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   Curtin 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 Affero General Public License for
+#   more details.
+#
+#   You should have received a copy of the GNU Affero General Public License
+#   along with Curtin.  If not, see <http://www.gnu.org/licenses/>.
+
+import errno
+import glob
+import os
+import re
+
+from curtin.log import LOG
+from curtin.udev import generate_udev_rule
+import curtin.util as util
+import curtin.config as config
+from . import network_state
+
+SYS_CLASS_NET = "/sys/class/net/"
+
+NET_CONFIG_OPTIONS = [
+    "address", "netmask", "broadcast", "network", "metric", "gateway",
+    "pointtopoint", "media", "mtu", "hostname", "leasehours", "leasetime",
+    "vendor", "client", "bootfile", "server", "hwaddr", "provider", "frame",
+    "netnum", "endpoint", "local", "ttl",
+    ]
+
+NET_CONFIG_COMMANDS = [
+    "pre-up", "up", "post-up", "down", "pre-down", "post-down",
+    ]
+
+NET_CONFIG_BRIDGE_OPTIONS = [
+    "bridge_ageing", "bridge_bridgeprio", "bridge_fd", "bridge_gcinit",
+    "bridge_hello", "bridge_maxage", "bridge_maxwait", "bridge_stp",
+    ]
+
+
+def sys_dev_path(devname, path=""):
+    return SYS_CLASS_NET + devname + "/" + path
+
+
+def read_sys_net(devname, path, translate=None, enoent=None, keyerror=None):
+    try:
+        contents = ""
+        with open(sys_dev_path(devname, path), "r") as fp:
+            contents = fp.read().strip()
+        if translate is None:
+            return contents
+
+        try:
+            return translate.get(contents)
+        except KeyError:
+            LOG.debug("found unexpected value '%s' in '%s/%s'", contents,
+                      devname, path)
+            if keyerror is not None:
+                return keyerror
+            raise
+    except OSError as e:
+        if e.errno == errno.ENOENT and enoent is not None:
+            return enoent
+        raise
+
+
+def is_up(devname):
+    # The linux kernel says to consider devices in 'unknown'
+    # operstate as up for the purposes of network configuration. See
+    # Documentation/networking/operstates.txt in the kernel source.
+    translate = {'up': True, 'unknown': True, 'down': False}
+    return read_sys_net(devname, "operstate", enoent=False, keyerror=False,
+                        translate=translate)
+
+
+def is_wireless(devname):
+    return os.path.exists(sys_dev_path(devname, "wireless"))
+
+
+def is_connected(devname):
+    # is_connected isn't really as simple as that.  2 is
+    # 'physically connected'. 3 is 'not connected'. but a wlan interface will
+    # always show 3.
+    try:
+        iflink = read_sys_net(devname, "iflink", enoent=False)
+        if iflink == "2":
+            return True
+        if not is_wireless(devname):
+            return False
+        LOG.debug("'%s' is wireless, basing 'connected' on carrier", devname)
+
+        return read_sys_net(devname, "carrier", enoent=False, keyerror=False,
+                            translate={'0': False, '1': True})
+
+    except IOError as e:
+        if e.errno == errno.EINVAL:
+            return False
+        raise
+
+
+def is_physical(devname):
+    return os.path.exists(sys_dev_path(devname, "device"))
+
+
+def is_present(devname):
+    return os.path.exists(sys_dev_path(devname))
+
+
+def get_devicelist():
+    return os.listdir(SYS_CLASS_NET)
+
+
+class ParserError(Exception):
+    """Raised when parser has issue parsing the interfaces file."""
+
+
+def parse_deb_config_data(ifaces, contents, src_dir, src_path):
+    """Parses the file contents, placing result into ifaces.
+
+    '_source_path' is added to every dictionary entry to define which file
+    the configration information came from.
+
+    :param ifaces: interface dictionary
+    :param contents: contents of interfaces file
+    :param src_dir: directory interfaces file was located
+    :param src_path: file path the `contents` was read
+    """
+    currif = None
+    for line in contents.splitlines():
+        line = line.strip()
+        if line.startswith('#'):
+            continue
+        split = line.split(' ')
+        option = split[0]
+        if option == "source-directory":
+            parsed_src_dir = split[1]
+            if not parsed_src_dir.startswith("/"):
+                parsed_src_dir = os.path.join(src_dir, parsed_src_dir)
+            for expanded_path in glob.glob(parsed_src_dir):
+                dir_contents = os.listdir(expanded_path)
+                dir_contents = [
+                    os.path.join(expanded_path, path)
+                    for path in dir_contents
+                    if (os.path.isfile(os.path.join(expanded_path, path)) and
+                        re.match("^[a-zA-Z0-9_-]+$", path) is not None)
+                ]
+                for entry in dir_contents:
+                    with open(entry, "r") as fp:
+                        src_data = fp.read().strip()
+                    abs_entry = os.path.abspath(entry)
+                    parse_deb_config_data(
+                        ifaces, src_data,
+                        os.path.dirname(abs_entry), abs_entry)
+        elif option == "source":
+            new_src_path = split[1]
+            if not new_src_path.startswith("/"):
+                new_src_path = os.path.join(src_dir, new_src_path)
+            for expanded_path in glob.glob(new_src_path):
+                with open(expanded_path, "r") as fp:
+                    src_data = fp.read().strip()
+                abs_path = os.path.abspath(expanded_path)
+                parse_deb_config_data(
+                    ifaces, src_data,
+                    os.path.dirname(abs_path), abs_path)
+        elif option == "auto":
+            for iface in split[1:]:
+                if iface not in ifaces:
+                    ifaces[iface] = {
+                        # Include the source path this interface was found in.
+                        "_source_path": src_path
+                    }
+                ifaces[iface]['auto'] = True
+        elif option == "iface":
+            iface, family, method = split[1:4]
+            if iface not in ifaces:
+                ifaces[iface] = {
+                    # Include the source path this interface was found in.
+                    "_source_path": src_path
+                }
+            elif 'family' in ifaces[iface]:
+                raise ParserError(
+                    "Interface %s can only be defined once. "
+                    "Re-defined in '%s'." % (iface, src_path))
+            ifaces[iface]['family'] = family
+            ifaces[iface]['method'] = method
+            currif = iface
+        elif option == "hwaddress":
+            ifaces[currif]['hwaddress'] = split[1]
+        elif option in NET_CONFIG_OPTIONS:
+            ifaces[currif][option] = split[1]
+        elif option in NET_CONFIG_COMMANDS:
+            if option not in ifaces[currif]:
+                ifaces[currif][option] = []
+            ifaces[currif][option].append(' '.join(split[1:]))
+        elif option.startswith('dns-'):
+            if 'dns' not in ifaces[currif]:
+                ifaces[currif]['dns'] = {}
+            if option == 'dns-search':
+                ifaces[currif]['dns']['search'] = []
+                for domain in split[1:]:
+                    ifaces[currif]['dns']['search'].append(domain)
+            elif option == 'dns-nameservers':
+                ifaces[currif]['dns']['nameservers'] = []
+                for server in split[1:]:
+                    ifaces[currif]['dns']['nameservers'].append(server)
+        elif option.startswith('bridge_'):
+            if 'bridge' not in ifaces[currif]:
+                ifaces[currif]['bridge'] = {}
+            if option in NET_CONFIG_BRIDGE_OPTIONS:
+                bridge_option = option.replace('bridge_', '', 1)
+                ifaces[currif]['bridge'][bridge_option] = split[1]
+            elif option == "bridge_ports":
+                ifaces[currif]['bridge']['ports'] = []
+                for iface in split[1:]:
+                    ifaces[currif]['bridge']['ports'].append(iface)
+            elif option == "bridge_hw" and split[1].lower() == "mac":
+                ifaces[currif]['bridge']['mac'] = split[2]
+            elif option == "bridge_pathcost":
+                if 'pathcost' not in ifaces[currif]['bridge']:
+                    ifaces[currif]['bridge']['pathcost'] = {}
+                ifaces[currif]['bridge']['pathcost'][split[1]] = split[2]
+            elif option == "bridge_portprio":
+                if 'portprio' not in ifaces[currif]['bridge']:
+                    ifaces[currif]['bridge']['portprio'] = {}
+                ifaces[currif]['bridge']['portprio'][split[1]] = split[2]
+        elif option.startswith('bond-'):
+            if 'bond' not in ifaces[currif]:
+                ifaces[currif]['bond'] = {}
+            bond_option = option.replace('bond-', '', 1)
+            ifaces[currif]['bond'][bond_option] = split[1]
+    for iface in ifaces.keys():
+        if 'auto' not in ifaces[iface]:
+            ifaces[iface]['auto'] = False
+
+
+def parse_deb_config(path):
+    """Parses a debian network configuration file."""
+    ifaces = {}
+    with open(path, "r") as fp:
+        contents = fp.read().strip()
+    abs_path = os.path.abspath(path)
+    parse_deb_config_data(
+        ifaces, contents,
+        os.path.dirname(abs_path), abs_path)
+    return ifaces
+
+
+def parse_net_config_data(net_config):
+    """Parses the config, returns NetworkState dictionary
+
+    :param net_config: curtin network config dict
+    """
+    state = None
+    if 'version' in net_config and 'config' in net_config:
+        ns = network_state.NetworkState(version=net_config.get('version'),
+                                        config=net_config.get('config'))
+        ns.parse_config()
+        state = ns.network_state
+
+    return state
+
+
+def parse_net_config(path):
+    """Parses a curtin network configuration file and
+       return network state"""
+    ns = None
+    net_config = config.load_config(path)
+    if 'network' in net_config:
+        ns = parse_net_config_data(net_config.get('network'))
+
+    return ns
+
+
+def render_persistent_net(network_state):
+    ''' Given state, emit udev rules to map
+        mac to ifname
+    '''
+    content = ""
+    interfaces = network_state.get('interfaces')
+    for iface in interfaces.values():
+        # for physical interfaces write out a persist net udev rule
+        if iface['type'] == 'physical' and \
+           'name' in iface and 'mac_address' in iface:
+            content += generate_udev_rule(iface['name'],
+                                          iface['mac_address'])
+
+    return content
+
+
+# TODO: switch valid_map based on mode inet/inet6
+def iface_add_subnet(iface, subnet):
+    content = ""
+    valid_map = [
+        'address',
+        'netmask',
+        'broadcast',
+        'metric',
+        'gateway',
+        'pointopoint',
+        'mtu',
+        'scope',
+        'dns_search',
+        'dns_nameservers',
+    ]
+    for key, value in subnet.items():
+        if value and key in valid_map:
+            if type(value) == list:
+                value = " ".join(value)
+            if '_' in key:
+                key = key.replace('_', '-')
+            content += "    {} {}\n".format(key, value)
+
+    return content
+
+
+# TODO: switch to valid_map for attrs
+def iface_add_attrs(iface):
+    content = ""
+    ignore_map = [
+        'type',
+        'name',
+        'inet',
+        'mode',
+        'index',
+        'subnets',
+    ]
+    if iface['type'] not in ['bond', 'bridge']:
+        ignore_map.append('mac_address')
+
+    for key, value in iface.items():
+        if value and key not in ignore_map:
+            if type(value) == list:
+                value = " ".join(value)
+            content += "    {} {}\n".format(key, value)
+
+    return content
+
+
+def render_route(route):
+    content = "up route add"
+    mapping = {
+        'network': '-net',
+        'netmask': 'netmask',
+        'gateway': 'gw',
+        'metric': 'metric',
+    }
+    for k in ['network', 'netmask', 'gateway', 'metric']:
+        if k in route:
+            content += " %s %s" % (mapping[k], route[k])
+
+    content += '\n'
+    return content
+
+
+def render_interfaces(network_state):
+    ''' Given state, emit etc/network/interfaces content '''
+
+    content = ""
+    interfaces = network_state.get('interfaces')
+    ''' Apply a sort order to ensure that we write out
+        the physical interfaces first; this is critical for
+        bonding
+    '''
+    order = {
+        'physical': 0,
+        'bond': 1,
+        'bridge': 2,
+        'vlan': 3,
+    }
+    content += "auto lo\niface lo inet loopback\n"
+    for dnskey, value in network_state.get('dns', {}).items():
+        if len(value):
+            content += "    dns-{} {}\n".format(dnskey, " ".join(value))
+
+    for iface in sorted(interfaces.values(),
+                        key=lambda k: (order[k['type']], k['name'])):
+        content += "auto {name}\n".format(**iface)
+
+        subnets = iface.get('subnets', {})
+        if subnets:
+            for index, subnet in zip(range(0, len(subnets)), subnets):
+                iface['index'] = index
+                iface['mode'] = subnet['type']
+                if iface['mode'].endswith('6'):
+                    iface['inet'] += '6'
+                elif iface['mode'] == 'static' and ":" in subnet['address']:
+                    iface['inet'] += '6'
+                if iface['mode'].startswith('dhcp'):
+                    iface['mode'] = 'dhcp'
+
+                if index == 0:
+                    content += "iface {name} {inet} {mode}\n".format(**iface)
+                else:
+                    content += "auto {name}:{index}\n".format(**iface)
+                    content += \
+                        "iface {name}:{index} {inet} {mode}\n".format(**iface)
+
+                content += iface_add_subnet(iface, subnet)
+                content += iface_add_attrs(iface)
+                content += "\n"
+        else:
+            content += "iface {name} {inet} {mode}\n".format(**iface)
+            content += iface_add_attrs(iface)
+            content += "\n"
+
+    for route in network_state.get('routes'):
+        content += render_route(route)
+
+    # global replacements until v2 format
+    content = content.replace('mac_address', 'hwaddress')
+    return content
+
+
+def render_network_state(target, network_state):
+    eni = 'etc/network/interfaces'
+    netrules = 'etc/udev/rules.d/70-persistent-net.rules'
+
+    eni = os.path.sep.join((target, eni,))
+    util.ensure_dir(os.path.dirname(eni))
+    with open(eni, 'w+') as f:
+        f.write(render_interfaces(network_state))
+
+    netrules = os.path.sep.join((target, netrules,))
+    util.ensure_dir(os.path.dirname(netrules))
+    with open(netrules, 'w+') as f:
+        f.write(render_persistent_net(network_state))
+
+# vi: ts=4 expandtab syntax=python
diff --git a/cloudinit/net/network_state.py b/cloudinit/net/network_state.py
new file mode 100644
index 00000000..83303317
--- /dev/null
+++ b/cloudinit/net/network_state.py
@@ -0,0 +1,400 @@
+#   Copyright (C) 2013-2014 Canonical Ltd.
+#
+#   Author: Ryan Harper <ryan.harper@canonical.com>
+#
+#   Curtin is free software: you can redistribute it and/or modify it under
+#   the terms of the GNU Affero General Public License as published by the
+#   Free Software Foundation, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   Curtin 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 Affero General Public License for
+#   more details.
+#
+#   You should have received a copy of the GNU Affero General Public License
+#   along with Curtin.  If not, see <http://www.gnu.org/licenses/>.
+
+from curtin.log import LOG
+import curtin.config as curtin_config
+
+NETWORK_STATE_VERSION = 1
+NETWORK_STATE_REQUIRED_KEYS = {
+    1: ['version', 'config', 'network_state'],
+}
+
+
+def from_state_file(state_file):
+    network_state = None
+    state = curtin_config.load_config(state_file)
+    network_state = NetworkState()
+    network_state.load(state)
+
+    return network_state
+
+
+class NetworkState:
+    def __init__(self, version=NETWORK_STATE_VERSION, config=None):
+        self.version = version
+        self.config = config
+        self.network_state = {
+            'interfaces': {},
+            'routes': [],
+            'dns': {
+                'nameservers': [],
+                'search': [],
+            }
+        }
+        self.command_handlers = self.get_command_handlers()
+
+    def get_command_handlers(self):
+        METHOD_PREFIX = 'handle_'
+        methods = filter(lambda x: callable(getattr(self, x)) and
+                         x.startswith(METHOD_PREFIX),  dir(self))
+        handlers = {}
+        for m in methods:
+            key = m.replace(METHOD_PREFIX, '')
+            handlers[key] = getattr(self, m)
+
+        return handlers
+
+    def dump(self):
+        state = {
+            'version': self.version,
+            'config': self.config,
+            'network_state': self.network_state,
+        }
+        return curtin_config.dump_config(state)
+
+    def load(self, state):
+        if 'version' not in state:
+            LOG.error('Invalid state, missing version field')
+            raise Exception('Invalid state, missing version field')
+
+        required_keys = NETWORK_STATE_REQUIRED_KEYS[state['version']]
+        if not self.valid_command(state, required_keys):
+            msg = 'Invalid state, missing keys: {}'.format(required_keys)
+            LOG.error(msg)
+            raise Exception(msg)
+
+        # v1 - direct attr mapping, except version
+        for key in [k for k in required_keys if k not in ['version']]:
+            setattr(self, key, state[key])
+        self.command_handlers = self.get_command_handlers()
+
+    def dump_network_state(self):
+        return curtin_config.dump_config(self.network_state)
+
+    def parse_config(self):
+        # rebuild network state
+        for command in self.config:
+            handler = self.command_handlers.get(command['type'])
+            handler(command)
+
+    def valid_command(self, command, required_keys):
+        if not required_keys:
+            return False
+
+        found_keys = [key for key in command.keys() if key in required_keys]
+        return len(found_keys) == len(required_keys)
+
+    def handle_physical(self, command):
+        '''
+        command = {
+            'type': 'physical',
+            'mac_address': 'c0:d6:9f:2c:e8:80',
+            'name': 'eth0',
+            'subnets': [
+                {'type': 'dhcp4'}
+             ]
+        }
+        '''
+        required_keys = [
+            'name',
+        ]
+        if not self.valid_command(command, required_keys):
+            LOG.warn('Skipping Invalid command: {}'.format(command))
+            LOG.debug(self.dump_network_state())
+            return
+
+        interfaces = self.network_state.get('interfaces')
+        iface = interfaces.get(command['name'], {})
+        for param, val in command.get('params', {}).items():
+            iface.update({param: val})
+        iface.update({
+            'name': command.get('name'),
+            'type': command.get('type'),
+            'mac_address': command.get('mac_address'),
+            'inet': 'inet',
+            'mode': 'manual',
+            'mtu': command.get('mtu'),
+            'address': None,
+            'gateway': None,
+            'subnets': command.get('subnets'),
+        })
+        self.network_state['interfaces'].update({command.get('name'): iface})
+        self.dump_network_state()
+
+    def handle_vlan(self, command):
+        '''
+            auto eth0.222
+            iface eth0.222 inet static
+                    address 10.10.10.1
+                    netmask 255.255.255.0
+                    vlan-raw-device eth0
+        '''
+        required_keys = [
+            'name',
+            'vlan_link',
+            'vlan_id',
+        ]
+        if not self.valid_command(command, required_keys):
+            print('Skipping Invalid command: {}'.format(command))
+            print(self.dump_network_state())
+            return
+
+        interfaces = self.network_state.get('interfaces')
+        self.handle_physical(command)
+        iface = interfaces.get(command.get('name'), {})
+        iface['vlan-raw-device'] = command.get('vlan_link')
+        iface['vlan_id'] = command.get('vlan_id')
+        interfaces.update({iface['name']: iface})
+
+    def handle_bond(self, command):
+        '''
+    #/etc/network/interfaces
+    auto eth0
+    iface eth0 inet manual
+        bond-master bond0
+        bond-mode 802.3ad
+
+    auto eth1
+    iface eth1 inet manual
+        bond-master bond0
+        bond-mode 802.3ad
+
+    auto bond0
+    iface bond0 inet static
+         address 192.168.0.10
+         gateway 192.168.0.1
+         netmask 255.255.255.0
+         bond-slaves none
+         bond-mode 802.3ad
+         bond-miimon 100
+         bond-downdelay 200
+         bond-updelay 200
+         bond-lacp-rate 4
+        '''
+        required_keys = [
+            'name',
+            'bond_interfaces',
+            'params',
+        ]
+        if not self.valid_command(command, required_keys):
+            print('Skipping Invalid command: {}'.format(command))
+            print(self.dump_network_state())
+            return
+
+        self.handle_physical(command)
+        interfaces = self.network_state.get('interfaces')
+        iface = interfaces.get(command.get('name'), {})
+        for param, val in command.get('params').items():
+            iface.update({param: val})
+        iface.update({'bond-slaves': 'none'})
+        self.network_state['interfaces'].update({iface['name']: iface})
+
+        # handle bond slaves
+        for ifname in command.get('bond_interfaces'):
+            if ifname not in interfaces:
+                cmd = {
+                    'name': ifname,
+                    'type': 'bond',
+                }
+                # inject placeholder
+                self.handle_physical(cmd)
+
+            interfaces = self.network_state.get('interfaces')
+            bond_if = interfaces.get(ifname)
+            bond_if['bond-master'] = command.get('name')
+            # copy in bond config into slave
+            for param, val in command.get('params').items():
+                bond_if.update({param: val})
+            self.network_state['interfaces'].update({ifname: bond_if})
+
+    def handle_bridge(self, command):
+        '''
+            auto br0
+            iface br0 inet static
+                    address 10.10.10.1
+                    netmask 255.255.255.0
+                    bridge_ports eth0 eth1
+                    bridge_stp off
+                    bridge_fd 0
+                    bridge_maxwait 0
+
+        bridge_params = [
+            "bridge_ports",
+            "bridge_ageing",
+            "bridge_bridgeprio",
+            "bridge_fd",
+            "bridge_gcint",
+            "bridge_hello",
+            "bridge_hw",
+            "bridge_maxage",
+            "bridge_maxwait",
+            "bridge_pathcost",
+            "bridge_portprio",
+            "bridge_stp",
+            "bridge_waitport",
+        ]
+        '''
+        required_keys = [
+            'name',
+            'bridge_interfaces',
+            'params',
+        ]
+        if not self.valid_command(command, required_keys):
+            print('Skipping Invalid command: {}'.format(command))
+            print(self.dump_network_state())
+            return
+
+        # find one of the bridge port ifaces to get mac_addr
+        # handle bridge_slaves
+        interfaces = self.network_state.get('interfaces')
+        for ifname in command.get('bridge_interfaces'):
+            if ifname in interfaces:
+                continue
+
+            cmd = {
+                'name': ifname,
+            }
+            # inject placeholder
+            self.handle_physical(cmd)
+
+        interfaces = self.network_state.get('interfaces')
+        self.handle_physical(command)
+        iface = interfaces.get(command.get('name'), {})
+        iface['bridge_ports'] = command['bridge_interfaces']
+        for param, val in command.get('params').items():
+            iface.update({param: val})
+
+        interfaces.update({iface['name']: iface})
+
+    def handle_nameserver(self, command):
+        required_keys = [
+            'address',
+        ]
+        if not self.valid_command(command, required_keys):
+            print('Skipping Invalid command: {}'.format(command))
+            print(self.dump_network_state())
+            return
+
+        dns = self.network_state.get('dns')
+        if 'address' in command:
+            addrs = command['address']
+            if not type(addrs) == list:
+                addrs = [addrs]
+            for addr in addrs:
+                dns['nameservers'].append(addr)
+        if 'search' in command:
+            paths = command['search']
+            if not isinstance(paths, list):
+                paths = [paths]
+            for path in paths:
+                dns['search'].append(path)
+
+    def handle_route(self, command):
+        required_keys = [
+            'destination',
+        ]
+        if not self.valid_command(command, required_keys):
+            print('Skipping Invalid command: {}'.format(command))
+            print(self.dump_network_state())
+            return
+
+        routes = self.network_state.get('routes')
+        network, cidr = command['destination'].split("/")
+        netmask = cidr2mask(int(cidr))
+        route = {
+            'network': network,
+            'netmask': netmask,
+            'gateway': command.get('gateway'),
+            'metric': command.get('metric'),
+        }
+        routes.append(route)
+
+
+def cidr2mask(cidr):
+    mask = [0, 0, 0, 0]
+    for i in list(range(0, cidr)):
+        idx = int(i / 8)
+        mask[idx] = mask[idx] + (1 << (7 - i % 8))
+    return ".".join([str(x) for x in mask])
+
+
+if __name__ == '__main__':
+    import sys
+    import random
+    from curtin import net
+
+    def load_config(nc):
+        version = nc.get('version')
+        config = nc.get('config')
+        return (version, config)
+
+    def test_parse(network_config):
+        (version, config) = load_config(network_config)
+        ns1 = NetworkState(version=version, config=config)
+        ns1.parse_config()
+        random.shuffle(config)
+        ns2 = NetworkState(version=version, config=config)
+        ns2.parse_config()
+        print("----NS1-----")
+        print(ns1.dump_network_state())
+        print()
+        print("----NS2-----")
+        print(ns2.dump_network_state())
+        print("NS1 == NS2 ?=> {}".format(
+            ns1.network_state == ns2.network_state))
+        eni = net.render_interfaces(ns2.network_state)
+        print(eni)
+        udev_rules = net.render_persistent_net(ns2.network_state)
+        print(udev_rules)
+
+    def test_dump_and_load(network_config):
+        print("Loading network_config into NetworkState")
+        (version, config) = load_config(network_config)
+        ns1 = NetworkState(version=version, config=config)
+        ns1.parse_config()
+        print("Dumping state to file")
+        ns1_dump = ns1.dump()
+        ns1_state = "/tmp/ns1.state"
+        with open(ns1_state, "w+") as f:
+            f.write(ns1_dump)
+
+        print("Loading state from file")
+        ns2 = from_state_file(ns1_state)
+        print("NS1 == NS2 ?=> {}".format(
+            ns1.network_state == ns2.network_state))
+
+    def test_output(network_config):
+        (version, config) = load_config(network_config)
+        ns1 = NetworkState(version=version, config=config)
+        ns1.parse_config()
+        random.shuffle(config)
+        ns2 = NetworkState(version=version, config=config)
+        ns2.parse_config()
+        print("NS1 == NS2 ?=> {}".format(
+            ns1.network_state == ns2.network_state))
+        eni_1 = net.render_interfaces(ns1.network_state)
+        eni_2 = net.render_interfaces(ns2.network_state)
+        print(eni_1)
+        print(eni_2)
+        print("eni_1 == eni_2 ?=> {}".format(
+            eni_1 == eni_2))
+
+    y = curtin_config.load_config(sys.argv[1])
+    network_config = y.get('network')
+    test_parse(network_config)
+    test_dump_and_load(network_config)
+    test_output(network_config)
diff --git a/cloudinit/net/udev.py b/cloudinit/net/udev.py
new file mode 100644
index 00000000..6435ace0
--- /dev/null
+++ b/cloudinit/net/udev.py
@@ -0,0 +1,54 @@
+#   Copyright (C) 2015 Canonical Ltd.
+#
+#   Author: Ryan Harper <ryan.harper@canonical.com>
+#
+#   Curtin is free software: you can redistribute it and/or modify it under
+#   the terms of the GNU Affero General Public License as published by the
+#   Free Software Foundation, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   Curtin 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 Affero General Public License for
+#   more details.
+#
+#   You should have received a copy of the GNU Affero General Public License
+#   along with Curtin.  If not, see <http://www.gnu.org/licenses/>.
+
+
+def compose_udev_equality(key, value):
+    """Return a udev comparison clause, like `ACTION=="add"`."""
+    assert key == key.upper()
+    return '%s=="%s"' % (key, value)
+
+
+def compose_udev_attr_equality(attribute, value):
+    """Return a udev attribute comparison clause, like `ATTR{type}=="1"`."""
+    assert attribute == attribute.lower()
+    return 'ATTR{%s}=="%s"' % (attribute, value)
+
+
+def compose_udev_setting(key, value):
+    """Return a udev assignment clause, like `NAME="eth0"`."""
+    assert key == key.upper()
+    return '%s="%s"' % (key, value)
+
+
+def generate_udev_rule(interface, mac):
+    """Return a udev rule to set the name of network interface with `mac`.
+
+    The rule ends up as a single line looking something like:
+
+    SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*",
+    ATTR{address}="ff:ee:dd:cc:bb:aa", NAME="eth0"
+    """
+    rule = ', '.join([
+        compose_udev_equality('SUBSYSTEM', 'net'),
+        compose_udev_equality('ACTION', 'add'),
+        compose_udev_equality('DRIVERS', '?*'),
+        compose_udev_attr_equality('address', mac),
+        compose_udev_setting('NAME', interface),
+        ])
+    return '%s\n' % rule
+
+# vi: ts=4 expandtab syntax=python