Merge lp:~raharper/curtin/iodo_network_rebase_v2 into lp:~curtin-dev/curtin/trunk

[Ryan Harper]

vmtest: Add network testing

Update the base vmtests class to handle network tests. If the
class configration includes a network section, parse and use it
to extend the VM launch and run commands.

[lp:~raharper/curtin/iodo_network_rebase_v2]

256. By Ryan Harper on 2015-08-31

Handle when we don't have network config. Fix bug in expected_interfaces method.

257. By Ryan Harper on 2015-09-02

from trunk

258. By Ryan Harper on 2015-09-02

Inject versioned network config

Use the same dictionary layout as storage, including a version field and then
a config dict within the outer Network config. Fix example files. Adjust
loading of data and fixup unittests.

=== added file 'curtin/commands/apply_net.py'
--- curtin/commands/apply_net.py	1970-01-01 00:00:00 +0000
+++ curtin/commands/apply_net.py	2015-09-02 14:28:32 +0000
@@ -0,0 +1,96 @@
+#   Copyright (C) 2015 Canonical Ltd.
+#
+#   Author: Ryan Harper <[e-mail]>
+#
+#   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 os
+import sys
+
+import curtin.net as net
+import curtin.util as util
+from . import populate_one_subcmd
+
+
+def apply_net(target, network_state=None, network_config=None):
+    if network_state is None and network_config is None:
+        msg = "Must provide at least config or state"
+        sys.stderr.write(msg + "\n")
+        raise Exception(msg)
+
+    if target is None:
+        msg = "Must provide target"
+        sys.stderr.write(msg + "\n")
+        raise Exception(msg)
+
+    if network_state:
+        ns = net.network_state.from_state_file(network_state)
+    elif network_config:
+        ns = net.parse_net_config(network_config)
+
+    net.render_network_state(target=target, network_state=ns)
+
+
+def apply_net_main(args):
+    #  curtin apply_net [--net-state=/config/netstate.yml] [--target=/]
+    #                   [--net-config=/config/maas_net.yml]
+    state = util.load_command_environment()
+
+    if args.target is not None:
+        state['target'] = args.target
+
+    if args.net_state is not None:
+        state['network_state'] = args.net_state
+
+    if args.net_config is not None:
+        state['network_config'] = args.net_config
+
+    if state['target'] is None:
+        sys.stderr.write("Unable to find target.  "
+                         "Use --target or set TARGET_MOUNT_POINT\n")
+        sys.exit(2)
+
+    if not state['network_config'] and not state['network_state']:
+        sys.stderr.write("Must provide at least config or state\n")
+        sys.exit(2)
+
+    apply_net(target=state['target'],
+              network_state=state['network_state'],
+              network_config=state['network_config'])
+
+    sys.exit(0)
+
+
+CMD_ARGUMENTS = (
+    ((('-s', '--net-state'),
+     {'help': ('file to read containing network state. '
+               'defaults to env["OUTPUT_NETWORK_STATE"]'),
+      'metavar': 'NETSTATE', 'action': 'store',
+      'default': os.environ.get('OUTPUT_NETWORK_STATE')}),
+     (('-t', '--target'),
+      {'help': ('target filesystem root to add swap file to. '
+                'default is env["TARGET_MOUNT_POINT"]'),
+       'metavar': 'TARGET', 'action': 'store',
+       'default': os.environ.get('TARGET_MOUNT_POINT')}),
+     (('-c', '--net-config'),
+      {'help': ('file to read containing curtin network config.'
+                'defaults to env["OUTPUT_NETWORK_CONFIG"]'),
+       'metavar': 'NETCONFIG', 'action': 'store',
+       'default': os.environ.get('OUTPUT_NETWORK_CONFIG')})))
+
+
+def POPULATE_SUBCMD(parser):
+    populate_one_subcmd(parser, CMD_ARGUMENTS, apply_net_main)
+
+# vi: ts=4 expandtab syntax=python

=== modified file 'curtin/commands/block_meta.py'
--- curtin/commands/block_meta.py	2015-08-27 20:27:04 +0000
+++ curtin/commands/block_meta.py	2015-09-02 14:28:32 +0000
@@ -21,7 +21,7 @@
 from curtin.log import LOG
 
 from . import populate_one_subcmd
-from curtin.commands.net_meta import compose_udev_equality
+from curtin.udev import compose_udev_equality
 
 import glob
 import os

=== modified file 'curtin/commands/curthooks.py'
--- curtin/commands/curthooks.py	2015-08-11 16:56:18 +0000
+++ curtin/commands/curthooks.py	2015-09-02 14:28:32 +0000
@@ -30,6 +30,7 @@
 from curtin.log import LOG
 from curtin import swap
 from curtin import util
+from curtin import net
 
 from . import populate_one_subcmd
 
@@ -407,6 +408,33 @@
                 'etc/mdadm/mdadm.conf']))
 
 
+def apply_networking(target, state):
+    netstate = state.get('network_state')
+    netconf = state.get('network_config')
+    interfaces = state.get('interfaces')
+
+    def is_valid_src(infile):
+        with open(infile, 'r') as fp:
+            content = fp.read()
+            if len(content.split('\n')) > 1:
+                return True
+        return False
+
+    ns = None
+    if is_valid_src(netstate):
+        LOG.debug("applying network_state")
+        ns = net.network_state.from_state_file(netstate)
+    elif is_valid_src(netconf):
+        LOG.debug("applying network_config")
+        ns = net.parse_net_config(netconf)
+
+    if ns is not None:
+        net.render_network_state(target=target, network_state=ns)
+    else:
+        LOG.debug("copying interfaces")
+        copy_interfaces(interfaces, target)
+
+
 def copy_interfaces(interfaces, target):
     if not interfaces:
         LOG.warn("no interfaces file to copy!")
@@ -597,7 +625,7 @@
 
     add_swap(cfg, target, state.get('fstab'))
 
-    copy_interfaces(state.get('interfaces'), target)
+    apply_networking(target, state)
     copy_fstab(state.get('fstab'), target)
 
     detect_and_handle_multipath(cfg, target)

=== modified file 'curtin/commands/install.py'
--- curtin/commands/install.py	2015-08-27 14:27:20 +0000
+++ curtin/commands/install.py	2015-09-02 14:28:32 +0000
@@ -56,6 +56,7 @@
     'curthooks_commands': {'builtin': ['curtin', 'curthooks']},
     'late_commands': {'builtin': []},
     'network_commands': {'builtin': ['curtin', 'net-meta', 'auto']},
+    'apply_net_commands': {'builtin': []},
     'install': {'log_file': INSTALL_LOG},
 }
 
@@ -89,6 +90,8 @@
         for p in (state_d, target_d, scratch_d):
             os.mkdir(p)
 
+        netconf_f = os.path.join(state_d, 'network_config')
+        netstate_f = os.path.join(state_d, 'network_state')
         interfaces_f = os.path.join(state_d, 'interfaces')
         config_f = os.path.join(state_d, 'config')
         fstab_f = os.path.join(state_d, 'fstab')
@@ -97,7 +100,7 @@
             json.dump(config, fp)
 
         # just touch these files to make sure they exist
-        for f in (interfaces_f, config_f, fstab_f):
+        for f in (interfaces_f, config_f, fstab_f, netconf_f, netstate_f):
             with open(f, "ab") as fp:
                 pass
 
@@ -105,6 +108,8 @@
         self.target = target_d
         self.top = top_d
         self.interfaces = interfaces_f
+        self.netconf = netconf_f
+        self.netstate = netstate_f
         self.fstab = fstab_f
         self.config = config
         self.config_file = config_f
@@ -112,6 +117,8 @@
     def env(self):
         return ({'WORKING_DIR': self.scratch, 'OUTPUT_FSTAB': self.fstab,
                  'OUTPUT_INTERFACES': self.interfaces,
+                 'OUTPUT_NETWORK_CONFIG': self.netconf,
+                 'OUTPUT_NETWORK_STATE': self.netstate,
                  'TARGET_MOUNT_POINT': self.target,
                  'CONFIG': self.config_file})
 

=== modified file 'curtin/commands/main.py'
--- curtin/commands/main.py	2015-08-11 20:23:35 +0000
+++ curtin/commands/main.py	2015-09-02 14:28:32 +0000
@@ -26,9 +26,9 @@
 from .. import config
 from ..reporter import (events, update_configuration)
 
-SUB_COMMAND_MODULES = ['block-meta', 'curthooks', 'extract', 'hook',
-                       'in-target', 'install', 'mkfs', 'net-meta', 'pack',
-                       'swap']
+SUB_COMMAND_MODULES = ['apply_net', 'block-meta', 'curthooks', 'extract',
+                       'hook', 'in-target', 'install', 'mkfs', 'net-meta',
+                       'pack', 'swap']
 
 
 def add_subcmd(subparser, subcmd):

=== modified file 'curtin/commands/net_meta.py'
--- curtin/commands/net_meta.py	2015-08-07 15:49:19 +0000
+++ curtin/commands/net_meta.py	2015-09-02 14:28:32 +0000
@@ -21,6 +21,7 @@
 
 from curtin import net
 import curtin.util as util
+import curtin.config as config
 
 from . import populate_one_subcmd
 
@@ -72,24 +73,6 @@
 
 
 def interfaces_custom(args):
-    content = '\n'.join(
-        [("# Autogenerated interfaces from net-meta custom mode"),
-         "",
-         "# The loopback network interface",
-         "auto lo",
-         "iface lo inet loopback",
-         "",
-         ])
-
-    command_handlers = {
-        'physical': handle_physical,
-        'vlan': handle_vlan,
-        'bond': handle_bond,
-        'bridge': handle_bridge,
-        'route': handle_route,
-        'nameserver': handle_nameserver,
-    }
-
     state = util.load_command_environment()
     cfg = util.load_command_config(args, state)
 
@@ -98,244 +81,7 @@
         raise Exception("network configuration is required by mode '%s' "
                         "but not provided in the config file" % 'custom')
 
-    for command in network_config:
-        handler = command_handlers.get(command['type'])
-        if not handler:
-            raise ValueError("unknown command type '%s'" % command['type'])
-        content += handler(command, args)
-        content = content.replace('\n\n\n', '\n\n')
-
-    return content
-
-
-def handle_vlan(command, args):
-    '''
-        auto eth0.222
-        iface eth0.222 inet static
-                address 10.10.10.1
-                netmask 255.255.255.0
-                vlan-raw-device eth0
-    '''
-    content = handle_physical(command, args)[:-1]
-    content += "    vlan-raw-device {}".format(command['vlan_link'])
-
-    return content
-
-
-def handle_bond(command, args):
-    '''
-#/etc/network/interfaces
-auto eth0
-iface eth0 inet manual
-
-auto eth1
-iface eth1 inet manual
-
-auto bond0
-iface bond0 inet static
-     address 192.168.0.10
-     gateway 192.168.0.1
-     netmask 255.255.255.0
-     bond-mode 802.3ad
-     bond-miimon 100
-     bond-downdelay 200
-     bond-updelay 200
-     bond-lacp-rate 4
-    '''
-    # write out bondX iface stanza and options
-    content = handle_physical(command, args)[:-1]
-    params = command.get('params', [])
-    for param, value in params.items():
-        content += "    {} {}\n".format(param, value)
-
-    content += "\n"
-
-    # now write out slaved iface stanzas
-    for slave in command['bond_interfaces']:
-        content += "auto {}\n".format(slave)
-        content += "iface {} inet manual\n".format(slave)
-        content += "    bond-master {}\n\n".format(command['name'])
-
-    return content
-
-
-def handle_bridge(command, args):
-    '''
-        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",
-    ]
-
-    content = handle_physical(command, args)[:-1]
-    content += "    bridge_ports %s\n" % (
-        " ".join(command['bridge_interfaces']))
-    params = command.get('params', [])
-    for param, value in params.items():
-        if param in bridge_params:
-            content += "    {} {}\n".format(param, value)
-
-    return content
-
-
-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 handle_route(command, args):
-    content = "\n"
-    network, cidr = command['destination'].split("/")
-    netmask = cidr2mask(int(cidr))
-    command['network'] = network
-    command['netmask'] = netmask
-    content += "up route add"
-    mapping = {
-        'network': '-net',
-        'netmask': 'netmask',
-        'gateway': 'gw',
-        'metric': 'metric',
-    }
-    for k in ['network', 'netmask', 'gateway', 'metric']:
-        if k in command:
-            content += " %s %s" % (mapping[k], command[k])
-
-    content += '\n'
-    return content
-
-
-def handle_nameserver(command, args):
-    content = "\n"
-    if 'address' in command:
-        content += "dns-nameserver {address}\n".format(**command)
-    if 'search' in command:
-        content += "dns-search {search}\n".format(**command)
-
-    return content
-
-
-def handle_physical(command, args):
-    '''
-    command = {
-        'type': 'physical',
-        'mac_address': 'c0:d6:9f:2c:e8:80',
-        'name': 'eth0',
-        'subnets': [
-            {'type': 'dhcp4'}
-         ]
-    }
-    '''
-    ctxt = {
-        'name': command.get('name'),
-        'inet': 'inet',
-        'mode': 'manual',
-        'mtu': command.get('mtu'),
-        'address': None,
-        'gateway': None,
-        'subnets': command.get('subnets'),
-    }
-
-    content = ""
-    content += "auto {name}\n".format(**ctxt)
-    subnets = command.get('subnets', {})
-    if subnets:
-        for index, subnet in zip(range(0, len(subnets)), subnets):
-            ctxt['index'] = index
-            ctxt['mode'] = subnet['type']
-            if ctxt['mode'].endswith('6'):
-                ctxt['inet'] += '6'
-            elif ctxt['mode'] == 'static' and ":" in subnet['address']:
-                ctxt['inet'] += '6'
-            if ctxt['mode'].startswith('dhcp'):
-                ctxt['mode'] = 'dhcp'
-
-            if index == 0:
-                content += "iface {name} {inet} {mode}\n".format(**ctxt)
-            else:
-                content += \
-                    "iface {name}:{index} {inet} {mode}\n".format(**ctxt)
-
-            if 'mtu' in ctxt and ctxt['mtu'] and index == 0:
-                content += "    mtu {mtu}\n".format(**ctxt)
-            if 'address' in subnet:
-                content += "    address {address}\n".format(**subnet)
-            if 'gateway' in subnet:
-                content += "    gateway {gateway}\n".format(**subnet)
-            content += "\n"
-    else:
-        content += "iface {name} {inet} {mode}\n\n".format(**ctxt)
-
-    # for physical interfaces ,write out a persist net udev rule
-    if command['type'] == 'physical' and \
-       'name' in command and 'mac_address' in command:
-        udev_line = generate_udev_rule(command['name'],
-                                       command['mac_address'])
-        persist_net = 'etc/udev/rules.d/70-persistent-net.rules'
-        netrules = os.path.sep.join((args.target, persist_net,))
-        util.ensure_dir(os.path.dirname(netrules))
-        with open(netrules, 'a+') as f:
-            f.write(udev_line)
-
-    return content
-
-
-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
+    return config.dump_config({'network': network_config})
 
 
 def net_meta(args):
@@ -390,6 +136,11 @@
         content = interfaces_basic_dhcp(devices)
     elif args.mode == 'custom':
         content = interfaces_custom(args)
+        # if we have a config, write it out to OUTPUT_NETWORK_CONFIG
+        output_network_config = os.environ.get("OUTPUT_NETWORK_CONFIG", "")
+        if output_network_config:
+            with open(output_network_config, "w") as fp:
+                fp.write(content)
 
     if args.output == "-":
         sys.stdout.write(content)

=== modified file 'curtin/config.py'
--- curtin/config.py	2014-03-24 18:57:19 +0000
+++ curtin/config.py	2015-09-02 14:28:32 +0000
@@ -98,3 +98,7 @@
         return yaml.safe_load(content)
     else:
         return load_config_archive(content)
+
+
+def dump_config(config):
+    return yaml.dump(config, default_flow_style=False)

=== modified file 'curtin/net/__init__.py'
--- curtin/net/__init__.py	2014-07-21 17:07:39 +0000
+++ curtin/net/__init__.py	2015-09-02 14:28:32 +0000
@@ -20,6 +20,10 @@
 import os
 
 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/"
 
@@ -208,4 +212,166 @@
         os.path.dirname(os.path.abspath(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',
+        'hwaddress',
+        'mtu',
+        'scope',
+    ]
+    for key, value in subnet.items():
+        if value and key in valid_map:
+            if type(value) == list:
+                value = " ".join(value)
+            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',
+    ]
+    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')
+    for iface in interfaces.values():
+        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 (addr, dns) in network_state.get('nameservers').items():
+        content += "{}\n".format(dns)
+
+    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

=== added file 'curtin/net/network_state.py'
--- curtin/net/network_state.py	1970-01-01 00:00:00 +0000
+++ curtin/net/network_state.py	2015-09-02 14:28:32 +0000
@@ -0,0 +1,360 @@
+#   Copyright (C) 2013-2014 Canonical Ltd.
+#
+#   Author: Ryan Harper <[e-mail]>
+#
+#   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': [],
+            'nameservers': {},
+        }
+        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'], {})
+        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
+
+    auto eth1
+    iface eth1 inet manual
+
+    auto bond0
+    iface bond0 inet static
+         address 192.168.0.10
+         gateway 192.168.0.1
+         netmask 255.255.255.0
+         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})
+        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')
+            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
+
+        nameservers = self.network_state.get('nameservers')
+        if 'address' in command:
+            nameservers[command['address']] = \
+                "dns-nameserver {address}".format(**command)
+
+    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))
+
+    y = curtin_config.load_config(sys.argv[1])
+    network_config = y.get('network')
+    test_parse(network_config)
+    test_dump_and_load(network_config)

=== added file 'curtin/udev.py'
--- curtin/udev.py	1970-01-01 00:00:00 +0000
+++ curtin/udev.py	2015-09-02 14:28:32 +0000
@@ -0,0 +1,54 @@
+#   Copyright (C) 2015 Canonical Ltd.
+#
+#   Author: Ryan Harper <[e-mail]>
+#
+#   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

=== modified file 'curtin/util.py'
--- curtin/util.py	2015-08-11 13:30:17 +0000
+++ curtin/util.py	2015-09-02 14:28:32 +0000
@@ -101,7 +101,9 @@
 
     mapping = {'scratch': 'WORKING_DIR', 'fstab': 'OUTPUT_FSTAB',
                'interfaces': 'OUTPUT_INTERFACES', 'config': 'CONFIG',
-               'target': 'TARGET_MOUNT_POINT'}
+               'target': 'TARGET_MOUNT_POINT',
+               'network_state': 'OUTPUT_NETWORK_STATE',
+               'network_config': 'OUTPUT_NETWORK_CONFIG'}
 
     if strict:
         missing = [k for k in mapping if k not in env]

=== modified file 'examples/network-all.yaml'
--- examples/network-all.yaml	2015-08-07 00:16:25 +0000
+++ examples/network-all.yaml	2015-09-02 14:28:32 +0000
@@ -4,88 +4,90 @@
 
 # YAML example of a network config.
 network:
-    # Physical interfaces.
-    - type: physical
-      name: eth0
-      mac_address: "c0:d6:9f:2c:e8:80"
-    - type: physical
-      name: eth1
-      mac_address: "aa:d6:9f:2c:e8:80"
-    - type: physical
-      name: eth2
-      mac_address: "c0:bb:9f:2c:e8:80"
-    - type: physical
-      name: eth3
-      mac_address: "66:bb:9f:2c:e8:80"
-    - type: physical
-      name: eth4
-      mac_address: "98:bb:9f:2c:e8:80"
-    # VLAN interface.
-    - type: vlan
-      name: eth0.101
-      vlan_link: eth0
-      vlan_id: 101
-      mtu: 1500
-      subnets:
-        - type: static
-          address: 192.168.0.2/24
-          gateway: 192.168.0.1
-          dns_nameservers:
-            - 192.168.0.10
-        - type: static
-          address: 192.168.2.10/24
-    # Bond.
-    - type: bond
-      name: bond0
-      # if 'mac_address' is omitted, the MAC is taken from
-      # the first slave.
-      mac_address: "aa:bb:cc:dd:ee:ff"
-      bond_interfaces:
-        - eth1
-        - eth2
-      params:
-        bond-mode: active-backup
-      subnets:
-        - type: dhcp6
-    # A Bond VLAN.
-    - type: vlan 
-      name: bond0.200
-      vlan_link: bond0 
-      vlan_id: 200
-      subnets:
-          - type: dhcp4
-    # A bridge.
-    - type: bridge
-      name: br0
-      bridge_interfaces:
-          - eth3
-          - eth4
-      ipv4_conf:
-          rp_filter: 1
-          proxy_arp: 0
-          forwarding: 1
-      ipv6_conf:
-          autoconf: 1
-          disable_ipv6: 1
-          use_tempaddr: 1
-          forwarding: 1
-          # basically anything in /proc/sys/net/ipv6/conf/.../
-      params:
-          bridge_stp: 'off'
-          bridge_fd: 0
-          bridge_maxwait: 0 
-      subnets:
-          - type: static
-            address: 192.168.14.2/24
-          - type: static
-            address: 2001:1::1/64 # default to /64
-    # A global nameserver.
-    - type: nameserver
-      address: 8.8.8.8
-    # A global route.
-    - type: route
-      destination: 10.0.0.0/8
-      gateway: 11.0.0.1
-      metric: 3 
+    version: 1
+    config:
+        # Physical interfaces.
+        - type: physical
+          name: eth0
+          mac_address: "c0:d6:9f:2c:e8:80"
+        - type: physical
+          name: eth1
+          mac_address: "aa:d6:9f:2c:e8:80"
+        - type: physical
+          name: eth2
+          mac_address: "c0:bb:9f:2c:e8:80"
+        - type: physical
+          name: eth3
+          mac_address: "66:bb:9f:2c:e8:80"
+        - type: physical
+          name: eth4
+          mac_address: "98:bb:9f:2c:e8:80"
+        # VLAN interface.
+        - type: vlan
+          name: eth0.101
+          vlan_link: eth0
+          vlan_id: 101
+          mtu: 1500
+          subnets:
+            - type: static
+              address: 192.168.0.2/24
+              gateway: 192.168.0.1
+              dns_nameservers:
+                - 192.168.0.10
+            - type: static
+              address: 192.168.2.10/24
+        # Bond.
+        - type: bond
+          name: bond0
+          # if 'mac_address' is omitted, the MAC is taken from
+          # the first slave.
+          mac_address: "aa:bb:cc:dd:ee:ff"
+          bond_interfaces:
+            - eth1
+            - eth2
+          params:
+            bond-mode: active-backup
+          subnets:
+            - type: dhcp6
+        # A Bond VLAN.
+        - type: vlan 
+          name: bond0.200
+          vlan_link: bond0 
+          vlan_id: 200
+          subnets:
+              - type: dhcp4
+        # A bridge.
+        - type: bridge
+          name: br0
+          bridge_interfaces:
+              - eth3
+              - eth4
+          ipv4_conf:
+              rp_filter: 1
+              proxy_arp: 0
+              forwarding: 1
+          ipv6_conf:
+              autoconf: 1
+              disable_ipv6: 1
+              use_tempaddr: 1
+              forwarding: 1
+              # basically anything in /proc/sys/net/ipv6/conf/.../
+          params:
+              bridge_stp: 'off'
+              bridge_fd: 0
+              bridge_maxwait: 0 
+          subnets:
+              - type: static
+                address: 192.168.14.2/24
+              - type: static
+                address: 2001:1::1/64 # default to /64
+        # A global nameserver.
+        - type: nameserver
+          address: 8.8.8.8
+        # A global route.
+        - type: route
+          destination: 10.0.0.0/8
+          gateway: 11.0.0.1
+          metric: 3 
 
 

=== modified file 'examples/network-bond.yaml'
--- examples/network-bond.yaml	2015-08-07 00:16:25 +0000
+++ examples/network-bond.yaml	2015-09-02 14:28:32 +0000
@@ -4,43 +4,45 @@
 
 # YAML example of a network config.
 network:
-    # Physical interfaces.
-    - type: physical
-      name: eth0
-      mac_address: "c0:d6:9f:2c:e8:80"
-    - type: physical
-      name: eth1
-      mac_address: "aa:d6:9f:2c:e8:80"
-    - type: physical
-      name: eth2
-      mac_address: "c0:bb:9f:2c:e8:80"
-    - type: physical
-      name: eth3
-      mac_address: "66:bb:9f:2c:e8:80"
-    - type: physical
-      name: eth4
-      mac_address: "98:bb:9f:2c:e8:80"
-    # Bond.
-    - type: bond
-      name: bond0
-      # if 'mac_address' is omitted, the MAC is taken from
-      # the first slave.
-      mac_address: "aa:bb:cc:dd:ee:ff"
-      bond_interfaces:
-        - eth1
-        - eth2
-      params:
-        bond-mode: active-backup
-      subnets:
-        - type: dhcp6
-    # A Bond VLAN.
-    - type: vlan 
-      name: bond0.200
-      vlan_link: bond0 
-      vlan_id: 200
-      subnets:
-        - type: static
-          address: 192.168.0.2/24
-          gateway: 192.168.0.1
-          dns_nameservers:
-            - 192.168.0.10
+    version: 1
+    config:
+        # Physical interfaces.
+        - type: physical
+          name: eth0
+          mac_address: "c0:d6:9f:2c:e8:80"
+        - type: physical
+          name: eth1
+          mac_address: "aa:d6:9f:2c:e8:80"
+        - type: physical
+          name: eth2
+          mac_address: "c0:bb:9f:2c:e8:80"
+        - type: physical
+          name: eth3
+          mac_address: "66:bb:9f:2c:e8:80"
+        - type: physical
+          name: eth4
+          mac_address: "98:bb:9f:2c:e8:80"
+        # Bond.
+        - type: bond
+          name: bond0
+          # if 'mac_address' is omitted, the MAC is taken from
+          # the first slave.
+          mac_address: "aa:bb:cc:dd:ee:ff"
+          bond_interfaces:
+            - eth1
+            - eth2
+          params:
+            bond-mode: active-backup
+          subnets:
+            - type: dhcp6
+        # A Bond VLAN.
+        - type: vlan 
+          name: bond0.200
+          vlan_link: bond0 
+          vlan_id: 200
+          subnets:
+            - type: static
+              address: 192.168.0.2/24
+              gateway: 192.168.0.1
+              dns_nameservers:
+                - 192.168.0.10

=== modified file 'examples/network-bridge.yaml'
--- examples/network-bridge.yaml	2015-08-07 00:16:25 +0000
+++ examples/network-bridge.yaml	2015-09-02 14:28:32 +0000
@@ -4,25 +4,27 @@
 
 # YAML example of a network config.
 network:
-    # Physical interfaces.
-    - type: physical
-      name: eth0
-      mac_address: "c0:d6:9f:2c:e8:80"
-    - type: physical
-      name: eth1
-      mac_address: "aa:d6:9f:2c:e8:80"
-    # A bridge.
-    - type: bridge
-      name: br0
-      bridge_interfaces:
-          - eth0
-          - eth1
-      params:
-          bridge_stp: 'off'
-          bridge_fd: 0
-          bridge_maxwait: 0 
-      subnets:
-          - type: static
-            address: 192.168.14.2/24
-          - type: static
-            address: 2001:1::1/64 # default to /64
+    version: 1
+    config:
+        # Physical interfaces.
+        - type: physical
+          name: eth0
+          mac_address: "c0:d6:9f:2c:e8:80"
+        - type: physical
+          name: eth1
+          mac_address: "aa:d6:9f:2c:e8:80"
+        # A bridge.
+        - type: bridge
+          name: br0
+          bridge_interfaces:
+              - eth0
+              - eth1
+          params:
+              bridge_stp: 'off'
+              bridge_fd: 0
+              bridge_maxwait: 0 
+          subnets:
+              - type: static
+                address: 192.168.14.2/24
+              - type: static
+                address: 2001:1::1/64 # default to /64

=== modified file 'examples/network-simple.yaml'
--- examples/network-simple.yaml	2015-08-07 00:16:25 +0000
+++ examples/network-simple.yaml	2015-09-02 14:28:32 +0000
@@ -1,25 +1,30 @@
 network_commands:
  builtin: null
-  10_network: curtin net-meta custom
+ 10_network:
+    - curtin
+    - net-meta
+    - custom
 
 # YAML example of a simple network config
 network:
-    # Physical interfaces.
-    - type: physical
-      name: eth0
-      mac_address: "c0:d6:9f:2c:e8:80"
-      subnets:
-          - type: dhcp4
-    - type: physical
-      name: eth1
-      mtu: 1492
-      mac_address: "aa:d6:9f:2c:e8:80"
-      subnets:
-          - type: static
-            address: 192.168.14.2/24
-            gateway: 192.168.14.1
-          - type: static
-            address: 192.168.14.4/24
-    - type: physical
-      name: eth2
-      mac_address: "cf:d6:af:48:e8:80"
+    version: 1
+    config:
+        # Physical interfaces.
+        - type: physical
+          name: eth0
+          mac_address: "c0:d6:9f:2c:e8:80"
+          subnets:
+              - type: dhcp4
+        - type: physical
+          name: eth1
+          mtu: 1492
+          mac_address: "aa:d6:9f:2c:e8:80"
+          subnets:
+              - type: static
+                address: 192.168.14.2/24
+                gateway: 192.168.14.1
+              - type: static
+                address: 192.168.14.4/24
+        - type: physical
+          name: eth2
+          mac_address: "cf:d6:af:48:e8:80"

=== modified file 'examples/network-vlan.yaml'
--- examples/network-vlan.yaml	2015-08-07 00:16:25 +0000
+++ examples/network-vlan.yaml	2015-09-02 14:28:32 +0000
@@ -4,19 +4,21 @@
 
 # YAML example of a network config.
 network:
-    # Physical interfaces.
-    - type: physical
-      name: eth0
-      mac_address: "c0:d6:9f:2c:e8:80"
-    # VLAN interface.
-    - type: vlan
-      name: eth0.101
-      vlan_link: eth0
-      vlan_id: 101
-      mtu: 1500
-      subnets:
-        - type: static
-          address: 192.168.0.2/24
-          gateway: 192.168.0.1
-          dns_nameservers:
-            - 192.168.0.10
+    version: 1
+    config:
+        # Physical interfaces.
+        - type: physical
+          name: eth0
+          mac_address: "c0:d6:9f:2c:e8:80"
+        # VLAN interface.
+        - type: vlan
+          name: eth0.101
+          vlan_link: eth0
+          vlan_id: 101
+          mtu: 1500
+          subnets:
+            - type: static
+              address: 192.168.0.2/24
+              gateway: 192.168.0.1
+              dns_nameservers:
+                - 192.168.0.10

=== added file 'examples/tests/basic_network.yaml'
--- examples/tests/basic_network.yaml	1970-01-01 00:00:00 +0000
+++ examples/tests/basic_network.yaml	2015-09-02 14:28:32 +0000
@@ -0,0 +1,22 @@
+network:
+    version: 1
+    config:
+        # Physical interfaces.
+        - type: physical
+          name: eth0
+          mac_address: "52:54:00:12:34:00"
+          subnets:
+              - type: dhcp4
+        - type: physical
+          name: eth1
+          mtu: 1492
+          mac_address: "52:54:00:12:34:02"
+          subnets:
+              - type: static
+                address: 10.0.2.100/24
+                gateway: 10.0.2.1
+              - type: static
+                address: 10.0.2.200/24
+        - type: physical
+          name: eth2
+          mac_address: "52:54:00:12:34:04"

=== modified file 'tests/unittests/test_net.py'
--- tests/unittests/test_net.py	2014-07-21 17:07:39 +0000
+++ tests/unittests/test_net.py	2015-09-02 14:28:32 +0000
@@ -2,8 +2,10 @@
 import os
 import shutil
 import tempfile
+import yaml
 
 from curtin import net
+import curtin.net.network_state as network_state
 from textwrap import dedent
 
 
@@ -241,4 +243,76 @@
         expected = net.parse_deb_config(i_path)
         self.assertEqual(data, expected)
 
+
+class TestNetConfig(TestCase):
+    def setUp(self):
+        self.target = tempfile.mkdtemp()
+        self.config_f = os.path.join(self.target, 'config')
+        self.config = '''
+# YAML example of a simple network config
+network:
+    version: 1
+    config:
+        # Physical interfaces.
+        - type: physical
+          name: eth0
+          mac_address: "c0:d6:9f:2c:e8:80"
+          subnets:
+              - type: dhcp4
+        - type: physical
+          name: eth1
+          mac_address: "cf:d6:af:48:e8:80"
+'''
+        with open(self.config_f, 'w') as fp:
+            fp.write(self.config)
+
+    def get_net_config(self):
+        cfg = yaml.safe_load(self.config)
+        return cfg.get('network')
+
+    def get_net_state(self):
+        net_cfg = self.get_net_config()
+        version = net_cfg.get('version')
+        config = net_cfg.get('config')
+        ns = network_state.NetworkState(version=version, config=config)
+        ns.parse_config()
+        return ns
+
+    def tearDown(self):
+        shutil.rmtree(self.target)
+
+    def test_parse_net_config_data(self):
+        ns = self.get_net_state()
+        net_state_from_cls = ns.network_state
+
+        net_state_from_fn = net.parse_net_config_data(self.get_net_config())
+        self.assertEqual(net_state_from_cls, net_state_from_fn)
+
+    def test_parse_net_config(self):
+        ns = self.get_net_state()
+        net_state_from_cls = ns.network_state
+
+        net_state_from_fn = net.parse_net_config(self.config_f)
+        self.assertEqual(net_state_from_cls, net_state_from_fn)
+
+    def test_render_persistent_net(self):
+        ns = self.get_net_state()
+        udev_rules = ('SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ' +
+                      'ATTR{address}=="cf:d6:af:48:e8:80", NAME="eth1"\n' +
+                      'SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ' +
+                      'ATTR{address}=="c0:d6:9f:2c:e8:80", NAME="eth0"\n')
+        persist_net_rules = net.render_persistent_net(ns.network_state)
+        self.assertEqual(sorted(udev_rules.split('\n')),
+                         sorted(persist_net_rules.split('\n')))
+
+    def test_render_interfaces(self):
+        ns = self.get_net_state()
+        ifaces = ('auto eth1\n' + 'iface eth1 inet manual\n' +
+                  '    hwaddress cf:d6:af:48:e8:80\n\n' +
+                  'auto eth0\n' + 'iface eth0 inet dhcp\n' +
+                  '    hwaddress c0:d6:9f:2c:e8:80\n\n')
+        net_ifaces = net.render_interfaces(ns.network_state)
+        self.assertEqual(sorted(ifaces.split('\n')),
+                         sorted(net_ifaces.split('\n')))
+
 # vi: ts=4 expandtab syntax=python

=== modified file 'tests/vmtests/__init__.py'
--- tests/vmtests/__init__.py	2015-08-27 20:16:43 +0000
+++ tests/vmtests/__init__.py	2015-09-02 14:28:32 +0000
@@ -5,6 +5,7 @@
 import shutil
 import subprocess
 import tempfile
+import curtin.net as curtin_net
 
 IMAGE_DIR = "/srv/images"
 
@@ -22,9 +23,12 @@
         print('Query simplestreams for root image: '
               'release={release} arch={arch}'.format(release=release,
                                                      arch=arch))
-        out = subprocess.check_output(
-            ["tools/usquery", "--max=1", repo, "release=%s" % release,
-             "arch=%s" % arch, "item_name=root-image.gz"])
+        cmd = ["tools/usquery", "--max=1", repo, "release=%s" % release,
+               "krel=%s" % release, "arch=%s" % arch,
+               "item_name=root-image.gz"]
+        print(" ".join(cmd))
+        out = subprocess.check_output(cmd)
+        print(out)
         sstream_data = ast.literal_eval(bytes.decode(out))
 
         # Check if we already have the image
@@ -127,18 +131,38 @@
         if not self.interactive:
             cmd.extend(["--silent", "--power=off"])
 
+        # check for network configuration
+        self.network_state = curtin_net.parse_net_config(self.conf_file)
+        print(self.network_state)
+
+        # build -n arg list with macaddrs from net_config physical config
+        macs = []
+        interfaces = {}
+        if self.network_state:
+            interfaces = self.network_state.get('interfaces')
+        for ifname in interfaces:
+            print(ifname)
+            iface = interfaces.get(ifname)
+            hwaddr = iface.get('mac_address')
+            if hwaddr:
+                macs.append(hwaddr)
+        netdevs = []
+        if len(macs) > 0:
+            for mac in macs:
+                netdevs.extend(["--netdev=user,mac={}".format(mac)])
+        else:
+            netdevs.extend(["--netdev=user"])
+
         # build disk arguments
         extra_disks = []
         for (disk_no, disk_sz) in enumerate(self.extra_disks):
             dpath = os.path.join(self.td.tmpdir, 'extra_disk_%d.img' % disk_no)
             extra_disks.extend(['--disk', '{}:{}'.format(dpath, disk_sz)])
 
-        cmd.extend(["--netdev=user", "--disk", self.td.target_disk] +
-                   extra_disks +
-                   [boot_img, "--kernel=%s" % boot_kernel,
-                    "--initrd=%s" % boot_initrd,
-                    "--", "curtin", "install",
-                    "--config=%s" % self.conf_file, "cp:///"])
+        cmd.extend(netdevs + ["--disk", self.td.target_disk] + extra_disks +
+                   [boot_img, "--kernel=%s" % boot_kernel, "--initrd=%s" %
+                    boot_initrd, "--", "curtin", "install", "--config=%s" %
+                    self.conf_file, "cp:///"])
 
         # run vm with installer
         try:
@@ -172,8 +196,8 @@
         extra_disks = [x if ":" not in x else x.split(':')[0]
                        for x in extra_disks]
         # create xkvm cmd
-        cmd = (["tools/xkvm", "--netdev=user", "--disk", self.td.target_disk,
-                "--disk", self.td.output_disk] + extra_disks +
+        cmd = (["tools/xkvm"] + netdevs + ["--disk", self.td.target_disk,
+               "--disk", self.td.output_disk] + extra_disks +
                ["--", "-drive",
                 "file=%s,if=virtio,media=cdrom" % self.td.seed_disk,
                 "-m", "1024"])
@@ -208,6 +232,33 @@
         if os.path.exists("./serial.log"):
             os.remove("./serial.log")
 
+    @classmethod
+    def expected_interfaces(self):
+        expected = []
+        interfaces = {}
+        if self.network_state:
+            interfaces = self.network_state.get('interfaces')
+        # handle interface aliases when subnets have multiple entries
+        for iface in interfaces.values():
+            subnets = iface.get('subnets', {})
+            if subnets:
+                for index, subnet in zip(range(0, len(subnets)), subnets):
+                    if index == 0:
+                        expected.append(iface)
+                    else:
+                        expected.append("{}:{}".format(iface, index))
+            else:
+                expected.append(iface)
+        return expected
+
+    @classmethod
+    def get_network_state(self):
+        return self.network_state
+
+    @classmethod
+    def get_expected_etc_network_interfaces(self):
+        return curtin_net.render_interfaces(self.network_state)
+
     # Misc functions that are useful for many tests
     def output_files_exist(self, files):
         for f in files:

=== added file 'tests/vmtests/test_network.py'
--- tests/vmtests/test_network.py	1970-01-01 00:00:00 +0000
+++ tests/vmtests/test_network.py	2015-09-02 14:28:32 +0000
@@ -0,0 +1,224 @@
+from . import VMBaseClass
+from unittest import TestCase
+
+import ipaddress
+import os
+import re
+import textwrap
+import yaml
+
+
+def iface_extract(input):
+    mo = re.search(r'^(?P<interface>\w+|\w+:\d+)\s+' +
+                   r'Link encap:(?P<link_encap>\S+)\s+' +
+                   r'(HWaddr\s+(?P<mac_address>\S+))?' +
+                   r'(\s+inet addr:(?P<address>\S+))?' +
+                   r'(\s+Bcast:(?P<broadcast>\S+)\s+)?' +
+                   r'(Mask:(?P<netmask>\S+)\s+)?',
+                   input, re.MULTILINE)
+
+    mtu = re.search(r'(\s+MTU:(?P<mtu>\d+)\s+)\s+', input, re.MULTILINE)
+    mtu_info = mtu.groupdict('')
+    mtu_info['mtu'] = int(mtu_info['mtu'])
+
+    if mo:
+        info = mo.groupdict('')
+        info['running'] = False
+        info['up'] = False
+        info['multicast'] = False
+        if 'RUNNING' in input:
+            info['running'] = True
+        if 'UP' in input:
+            info['up'] = True
+        if 'MULTICAST' in input:
+            info['multicast'] = True
+        info.update(mtu_info)
+        return info
+    return {}
+
+
+def ifconfig_to_dict(ifconfig):
+    interfaces = {}
+    for iface in [iface_extract(iface) for iface in ifconfig.split('\n\n')
+                  if iface.strip()]:
+        interfaces[iface['interface']] = iface
+
+    return interfaces
+
+
+class TestNetworkAbs(VMBaseClass):
+    __test__ = False
+    interactive = False
+    conf_file = "examples/tests/basic_network.yaml"
+    install_timeout = 600
+    boot_timeout = 600
+    extra_disks = []
+    extra_nics = []
+    user_data = textwrap.dedent("""\
+        #cloud-config
+        password: passw0rd
+        chpasswd: { expire: False }
+        bootcmd:
+          - mkdir -p /media/output
+          - mount /dev/vdb /media/output
+        runcmd:
+          - ifconfig -a > /media/output/ifconfig_a
+          - cp -av /etc/network/interfaces /media/output
+          - cp -av /etc/udev/rules.d/70-persistent-net.rules /media/output
+          - ip -o route show > /media/output/ip_route_show
+          - route -n > /media/output/route_n
+        power_state:
+          mode: poweroff
+        """)
+
+    def test_output_files_exist(self):
+        self.output_files_exist(["ifconfig_a",
+                                 "interfaces",
+                                 "70-persistent-net.rules",
+                                 "ip_route_show",
+                                 "route_n"])
+
+    def test_etc_network_interfaces(self):
+        with open(os.path.join(self.td.mnt, "interfaces")) as fp:
+            eni = fp.read()
+            print('etc/network/interfaces:\n{}'.format(eni))
+
+        expected_eni = self.get_expected_etc_network_interfaces()
+        eni_lines = eni.split('\n')
+        for line in expected_eni.split('\n'):
+            self.assertTrue(line in eni_lines)
+
+    def test_ifconfig_output(self):
+        '''check ifconfig output with test input'''
+        network_state = self.get_network_state()
+        print('expected_network_state:\n{}'.format(
+            yaml.dump(network_state, default_flow_style=False, indent=4)))
+
+        with open(os.path.join(self.td.mnt, "ifconfig_a")) as fp:
+            ifconfig_a = fp.read()
+            print('ifconfig -a:\n{}'.format(ifconfig_a))
+
+        ifconfig_dict = ifconfig_to_dict(ifconfig_a)
+        print('parsed ifcfg dict:\n{}'.format(
+            yaml.dump(ifconfig_dict, default_flow_style=False, indent=4)))
+
+        with open(os.path.join(self.td.mnt, "ip_route_show")) as fp:
+            ip_route_show = fp.read()
+            print("ip route show:\n{}".format(ip_route_show))
+            for line in [line for line in ip_route_show.split('\n')
+                         if 'src' in line]:
+                m = re.search(r'^(?P<network>\S+)\sdev\s' +
+                              r'(?P<devname>\S+)\s+' +
+                              r'proto kernel\s+scope link' +
+                              r'\s+src\s(?P<src_ip>\S+)',
+                              line)
+                route_info = m.groupdict('')
+                print(route_info)
+
+        with open(os.path.join(self.td.mnt, "route_n")) as fp:
+            route_n = fp.read()
+            print("route -n:\n{}".format(route_n))
+
+        interfaces = network_state.get('interfaces')
+        for iface in interfaces.values():
+            subnets = iface.get('subnets', {})
+            if subnets:
+                for index, subnet in zip(range(0, len(subnets)), subnets):
+                    iface['index'] = index
+                    if index == 0:
+                        ifname = "{name}".format(**iface)
+                    else:
+                        ifname = "{name}:{index}".format(**iface)
+
+                    self.check_interface(iface,
+                                         ifconfig_dict.get(ifname),
+                                         route_n)
+            else:
+                iface['index'] = 0
+                self.check_interface(iface,
+                                     ifconfig_dict.get(iface['name']),
+                                     route_n)
+
+    def check_interface(self, iface, ifconfig, route_n):
+        print('testing iface:\n{}\n\nifconfig:\n{}'.format(
+              iface, ifconfig))
+        subnets = iface.get('subnets', {})
+        if subnets and iface['index'] != 0:
+            ifname = "{name}:{index}".format(**iface)
+        else:
+            ifname = "{name}".format(**iface)
+
+        # initial check, do we have the correct iface ?
+        print('ifname={}'.format(ifname))
+        print("ifconfig['interface']={}".format(ifconfig['interface']))
+        self.assertEqual(ifname, ifconfig['interface'])
+
+        # check physical interface attributes
+        for key in ['mac_address', 'mtu']:
+            if key in iface and iface[key]:
+                self.assertEqual(iface[key],
+                                 ifconfig[key])
+
+        def __get_subnet(subnets, subidx):
+            for index, subnet in zip(range(0, len(subnets)), subnets):
+                if index == subidx:
+                    break
+            return subnet
+
+        # check subnet related attributes, and specifically only
+        # the subnet specified by iface['index']
+        subnets = iface.get('subnets', {})
+        if subnets:
+            subnet = __get_subnet(subnets, iface['index'])
+            if 'address' in subnet and subnet['address']:
+                if ':' in subnet['address']:
+                    inet_iface = ipaddress.IPv6Interface(
+                        subnet['address'])
+                else:
+                    inet_iface = ipaddress.IPv4Interface(
+                        subnet['address'])
+
+                # check ip addr
+                self.assertEqual(str(inet_iface.ip),
+                                 ifconfig['address'])
+
+                self.assertEqual(str(inet_iface.netmask),
+                                 ifconfig['netmask'])
+
+                self.assertEqual(
+                    str(inet_iface.network.broadcast_address),
+                    ifconfig['broadcast'])
+
+            # handle gateway by looking at routing table
+            if 'gateway' in subnet and subnet['gateway']:
+                gw_ip = subnet['gateway']
+                gateways = [line for line in route_n.split('\n')
+                            if 'UG' in line and gw_ip in line]
+                print('matching gateways:\n{}'.format(gateways))
+                self.assertEqual(len(gateways), 1)
+                [gateways] = gateways
+                (dest, gw, genmask, flags, metric, ref, use, iface) = \
+                    gateways.split()
+                print('expected gw:{} found gw:{}'.format(gw_ip, gw))
+                self.assertEqual(gw_ip, gw)
+
+
+class TrustyTestBasic(TestNetworkAbs, TestCase):
+    __test__ = True
+    repo = "maas-daily"
+    release = "trusty"
+    arch = "amd64"
+
+
+class WilyTestBasic(TestNetworkAbs, TestCase):
+    __test__ = True
+    repo = "maas-daily"
+    release = "wily"
+    arch = "amd64"
+
+
+class VividTestBasic(TestNetworkAbs, TestCase):
+    __test__ = True
+    repo = "maas-daily"
+    release = "vivid"
+    arch = "amd64"