merge with trunk

3 files changed, 1251 insertions, 0 deletions

diff --git a/cloudinit/net/__init__.py b/cloudinit/net/__init__.py
new file mode 100644
index 00000000..40929c6e
--- /dev/null
+++ b/cloudinit/net/__init__.py
@@ -0,0 +1,751 @@
+#   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 base64
+import errno
+import glob
+import gzip
+import io
+import os
+import re
+import shlex
+
+from cloudinit import log as logging
+from cloudinit import util
+from .udev import generate_udev_rule
+from . import network_state
+
+LOG = logging.getLogger(__name__)
+
+SYS_CLASS_NET = "/sys/class/net/"
+LINKS_FNAME_PREFIX = "etc/systemd/network/50-cloud-init-"
+
+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",
+    ]
+
+DEFAULT_PRIMARY_INTERFACE = 'eth0'
+
+
+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 = util.read_conf(path)
+    if 'network' in net_config:
+        ns = parse_net_config_data(net_config.get('network'))
+
+    return ns
+
+
+def _load_shell_content(content, add_empty=False, empty_val=None):
+    """Given shell like syntax (key=value\nkey2=value2\n) in content
+       return the data in dictionary form.  If 'add_empty' is True
+       then add entries in to the returned dictionary for 'VAR='
+       variables.  Set their value to empty_val."""
+    data = {}
+    for line in shlex.split(content):
+        key, value = line.split("=", 1)
+        if not value:
+            value = empty_val
+        if add_empty or value:
+            data[key] = value
+
+    return data
+
+
+def _klibc_to_config_entry(content, mac_addrs=None):
+    """Convert a klibc writtent shell content file to a 'config' entry
+    When ip= is seen on the kernel command line in debian initramfs
+    and networking is brought up, ipconfig will populate
+    /run/net-<name>.cfg.
+
+    The files are shell style syntax, and examples are in the tests
+    provided here.  There is no good documentation on this unfortunately.
+
+    DEVICE=<name> is expected/required and PROTO should indicate if
+    this is 'static' or 'dhcp'.
+    """
+
+    if mac_addrs is None:
+        mac_addrs = {}
+
+    data = _load_shell_content(content)
+    try:
+        name = data['DEVICE']
+    except KeyError:
+        raise ValueError("no 'DEVICE' entry in data")
+
+    # ipconfig on precise does not write PROTO
+    proto = data.get('PROTO')
+    if not proto:
+        if data.get('filename'):
+            proto = 'dhcp'
+        else:
+            proto = 'static'
+
+    if proto not in ('static', 'dhcp'):
+        raise ValueError("Unexpected value for PROTO: %s" % proto)
+
+    iface = {
+        'type': 'physical',
+        'name': name,
+        'subnets': [],
+    }
+
+    if name in mac_addrs:
+        iface['mac_address'] = mac_addrs[name]
+
+    # originally believed there might be IPV6* values
+    for v, pre in (('ipv4', 'IPV4'),):
+        # if no IPV4ADDR or IPV6ADDR, then go on.
+        if pre + "ADDR" not in data:
+            continue
+        subnet = {'type': proto}
+
+        # these fields go right on the subnet
+        for key in ('NETMASK', 'BROADCAST', 'GATEWAY'):
+            if pre + key in data:
+                subnet[key.lower()] = data[pre + key]
+
+        dns = []
+        # handle IPV4DNS0 or IPV6DNS0
+        for nskey in ('DNS0', 'DNS1'):
+            ns = data.get(pre + nskey)
+            # verify it has something other than 0.0.0.0 (or ipv6)
+            if ns and len(ns.strip(":.0")):
+                dns.append(data[pre + nskey])
+        if dns:
+            subnet['dns_nameservers'] = dns
+            # add search to both ipv4 and ipv6, as it has no namespace
+            search = data.get('DOMAINSEARCH')
+            if search:
+                if ',' in search:
+                    subnet['dns_search'] = search.split(",")
+                else:
+                    subnet['dns_search'] = search.split()
+
+        iface['subnets'].append(subnet)
+
+    return name, iface
+
+
+def config_from_klibc_net_cfg(files=None, mac_addrs=None):
+    if files is None:
+        files = glob.glob('/run/net*.conf')
+
+    entries = []
+    names = {}
+    for cfg_file in files:
+        name, entry = _klibc_to_config_entry(util.load_file(cfg_file),
+                                             mac_addrs=mac_addrs)
+        if name in names:
+            raise ValueError(
+                "device '%s' defined multiple times: %s and %s" % (
+                    name, names[name], cfg_file))
+
+        names[name] = cfg_file
+        entries.append(entry)
+    return {'config': entries, 'version': 1}
+
+
+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 iface.get('mac_address'):
+            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', 'vlan']:
+        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, indent=""):
+    """ When rendering routes for an iface, in some cases applying a route
+    may result in the route command returning non-zero which produces
+    some confusing output for users manually using ifup/ifdown[1].  To
+    that end, we will optionally include an '|| true' postfix to each
+    route line allowing users to work with ifup/ifdown without using
+    --force option.
+
+    We may at somepoint not want to emit this additional postfix, and
+    add a 'strict' flag to this function.  When called with strict=True,
+    then we will not append the postfix.
+
+    1. http://askubuntu.com/questions/168033/
+             how-to-set-static-routes-in-ubuntu-server
+    """
+    content = ""
+    up = indent + "post-up route add"
+    down = indent + "pre-down route del"
+    eol = " || true\n"
+    mapping = {
+        'network': '-net',
+        'netmask': 'netmask',
+        'gateway': 'gw',
+        'metric': 'metric',
+    }
+    if route['network'] == '0.0.0.0' and route['netmask'] == '0.0.0.0':
+        default_gw = " default gw %s" % route['gateway']
+        content += up + default_gw + eol
+        content += down + default_gw + eol
+    elif route['network'] == '::' and route['netmask'] == 0:
+        # ipv6!
+        default_gw = " -A inet6 default gw %s" % route['gateway']
+        content += up + default_gw + eol
+        content += down + default_gw + eol
+    else:
+        route_line = ""
+        for k in ['network', 'netmask', 'gateway', 'metric']:
+            if k in route:
+                route_line += " %s %s" % (mapping[k], route[k])
+        content += up + route_line + eol
+        content += down + route_line + eol
+
+    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))
+
+    content += "\n"
+    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)
+                for route in subnet.get('routes', []):
+                    content += render_route(route, indent="    ")
+                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 ether')
+    return content
+
+
+def render_network_state(target, network_state, eni="etc/network/interfaces",
+                         links_prefix=LINKS_FNAME_PREFIX,
+                         netrules='etc/udev/rules.d/70-persistent-net.rules'):
+
+    fpeni = os.path.sep.join((target, eni,))
+    util.ensure_dir(os.path.dirname(fpeni))
+    with open(fpeni, 'w+') as f:
+        f.write(render_interfaces(network_state))
+
+    if netrules:
+        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))
+
+    if links_prefix:
+        render_systemd_links(target, network_state, links_prefix)
+
+
+def render_systemd_links(target, network_state,
+                         links_prefix=LINKS_FNAME_PREFIX):
+    fp_prefix = os.path.sep.join((target, links_prefix))
+    for f in glob.glob(fp_prefix + "*"):
+        os.unlink(f)
+
+    interfaces = network_state.get('interfaces')
+    for iface in interfaces.values():
+        if (iface['type'] == 'physical' and 'name' in iface and
+                iface.get('mac_address')):
+            fname = fp_prefix + iface['name'] + ".link"
+            with open(fname, "w") as fp:
+                fp.write("\n".join([
+                    "[Match]",
+                    "MACAddress=" + iface['mac_address'],
+                    "",
+                    "[Link]",
+                    "Name=" + iface['name'],
+                    ""
+                ]))
+
+
+def is_disabled_cfg(cfg):
+    if not cfg or not isinstance(cfg, dict):
+        return False
+    return cfg.get('config') == "disabled"
+
+
+def sys_netdev_info(name, field):
+    if not os.path.exists(os.path.join(SYS_CLASS_NET, name)):
+        raise OSError("%s: interface does not exist in %s" %
+                      (name, SYS_CLASS_NET))
+
+    fname = os.path.join(SYS_CLASS_NET, name, field)
+    if not os.path.exists(fname):
+        raise OSError("%s: could not find sysfs entry: %s" % (name, fname))
+    data = util.load_file(fname)
+    if data[-1] == '\n':
+        data = data[:-1]
+    return data
+
+
+def generate_fallback_config():
+    """Determine which attached net dev is most likely to have a connection and
+       generate network state to run dhcp on that interface"""
+    # by default use eth0 as primary interface
+    nconf = {'config': [], 'version': 1}
+
+    # get list of interfaces that could have connections
+    invalid_interfaces = set(['lo'])
+    potential_interfaces = set(get_devicelist())
+    potential_interfaces = potential_interfaces.difference(invalid_interfaces)
+    # sort into interfaces with carrier, interfaces which could have carrier,
+    # and ignore interfaces that are definitely disconnected
+    connected = []
+    possibly_connected = []
+    for interface in potential_interfaces:
+        try:
+            carrier = int(sys_netdev_info(interface, 'carrier'))
+            if carrier:
+                connected.append(interface)
+                continue
+        except OSError:
+            pass
+        # check if nic is dormant or down, as this may make a nick appear to
+        # not have a carrier even though it could acquire one when brought
+        # online by dhclient
+        try:
+            dormant = int(sys_netdev_info(interface, 'dormant'))
+            if dormant:
+                possibly_connected.append(interface)
+                continue
+        except OSError:
+            pass
+        try:
+            operstate = sys_netdev_info(interface, 'operstate')
+            if operstate in ['dormant', 'down', 'lowerlayerdown', 'unknown']:
+                possibly_connected.append(interface)
+                continue
+        except OSError:
+            pass
+
+    # don't bother with interfaces that might not be connected if there are
+    # some that definitely are
+    if connected:
+        potential_interfaces = connected
+    else:
+        potential_interfaces = possibly_connected
+    # if there are no interfaces, give up
+    if not potential_interfaces:
+        return
+    # if eth0 exists use it above anything else, otherwise get the interface
+    # that looks 'first'
+    if DEFAULT_PRIMARY_INTERFACE in potential_interfaces:
+        name = DEFAULT_PRIMARY_INTERFACE
+    else:
+        name = sorted(potential_interfaces)[0]
+
+    mac = sys_netdev_info(name, 'address')
+    target_name = name
+
+    nconf['config'].append(
+        {'type': 'physical', 'name': target_name,
+         'mac_address': mac, 'subnets': [{'type': 'dhcp'}]})
+    return nconf
+
+
+def _decomp_gzip(blob, strict=True):
+    # decompress blob. raise exception if not compressed unless strict=False.
+    with io.BytesIO(blob) as iobuf:
+        gzfp = None
+        try:
+            gzfp = gzip.GzipFile(mode="rb", fileobj=iobuf)
+            return gzfp.read()
+        except IOError:
+            if strict:
+                raise
+            return blob
+        finally:
+            if gzfp:
+                gzfp.close()
+
+
+def _b64dgz(b64str, gzipped="try"):
+    # decode a base64 string.  If gzipped is true, transparently uncompresss
+    # if gzipped is 'try', then try gunzip, returning the original on fail.
+    try:
+        blob = base64.b64decode(b64str)
+    except TypeError:
+        raise ValueError("Invalid base64 text: %s" % b64str)
+
+    if not gzipped:
+        return blob
+
+    return _decomp_gzip(blob, strict=gzipped != "try")
+
+
+def read_kernel_cmdline_config(files=None, mac_addrs=None, cmdline=None):
+    if cmdline is None:
+        cmdline = util.get_cmdline()
+
+    if 'network-config=' in cmdline:
+        data64 = None
+        for tok in cmdline.split():
+            if tok.startswith("network-config="):
+                data64 = tok.split("=", 1)[1]
+        if data64:
+            return util.load_yaml(_b64dgz(data64))
+
+    if 'ip=' not in cmdline:
+        return None
+
+    if mac_addrs is None:
+        mac_addrs = {k: sys_netdev_info(k, 'address')
+                     for k in get_devicelist()}
+
+    return config_from_klibc_net_cfg(files=files, mac_addrs=mac_addrs)
+
+
+# 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..e32d2cdf
--- /dev/null
+++ b/cloudinit/net/network_state.py
@@ -0,0 +1,446 @@
+#   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 cloudinit import log as logging
+from cloudinit import util
+from cloudinit.util import yaml_dumps as dump_config
+
+LOG = logging.getLogger(__name__)
+
+NETWORK_STATE_VERSION = 1
+NETWORK_STATE_REQUIRED_KEYS = {
+    1: ['version', 'config', 'network_state'],
+}
+
+
+def from_state_file(state_file):
+    network_state = None
+    state = util.read_conf(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 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 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})
+
+        # convert subnet ipv6 netmask to cidr as needed
+        subnets = command.get('subnets')
+        if subnets:
+            for subnet in subnets:
+                if subnet['type'] == 'static':
+                    if 'netmask' in subnet and ':' in subnet['address']:
+                        subnet['netmask'] = mask2cidr(subnet['netmask'])
+                        for route in subnet.get('routes', []):
+                            if 'netmask' in route:
+                                route['netmask'] = mask2cidr(route['netmask'])
+        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': 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
+                    hwaddress ether BC:76:4E:06:96:B3
+                    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])
+
+
+def ipv4mask2cidr(mask):
+    if '.' not in mask:
+        return mask
+    return sum([bin(int(x)).count('1') for x in mask.split('.')])
+
+
+def ipv6mask2cidr(mask):
+    if ':' not in mask:
+        return mask
+
+    bitCount = [0, 0x8000, 0xc000, 0xe000, 0xf000, 0xf800, 0xfc00, 0xfe00,
+                0xff00, 0xff80, 0xffc0, 0xffe0, 0xfff0, 0xfff8, 0xfffc,
+                0xfffe, 0xffff]
+    cidr = 0
+    for word in mask.split(':'):
+        if not word or int(word, 16) == 0:
+            break
+        cidr += bitCount.index(int(word, 16))
+
+    return cidr
+
+
+def mask2cidr(mask):
+    if ':' in mask:
+        return ipv6mask2cidr(mask)
+    elif '.' in mask:
+        return ipv4mask2cidr(mask)
+    else:
+        return mask
+
+
+if __name__ == '__main__':
+    import sys
+    import random
+    from cloudinit 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 = util.read_conf(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