Merge lp:~marius-zalinauskas/maas-images/centos-hooks into lp:maas-images

[Marius Žalinauskas]

Heavily modified CentOS 6/7 hooks. For the most part it is curtin/commands/curthooks.py ported to CentOS with some code from old CentOS hooks.

Added functionality:

- UEFI boot. It was already kinda working on CentOS 7, but was tricky on CentOS 6.
- Simple and MD RAID layouts. No need to force the simple layout on MAAS anymore.
- IPv4 DHCP and static networking, IP aliases on physical and VLAN interfaces. Much better than original DHCP only.

[lp:~marius-zalinauskas/maas-images/centos-hooks]

353. By Marius Žalinauskas <email address hidden> on 2017-01-09

Bugfix, see https://bugs.launchpad.net/maas-images/+bug/1654853

[Tom Mullaney (tpmullan)]

These changes work great for me. They make Maas much more usable for people that don't only work with Ubuntu.

review: Approve

[Andres Rodriguez (andreserl)]

Hi Marius,

Thank you for your contribution!

In order to be able to accept your code you need to sign the Canonical Contributors Agreement. Can you please do that in [1].

That said, we have a few things that need fixing before we are able to review / land branches, to follow the procedures MAAS uses, Please:

 - Separate the UEFI changes into is own branch
 - Seprate the Simple/MD Raid into its own branch
 - IPv4 DHCP/Static Networking, also it its own branch.

Thank you!

[1]: https://www.ubuntu.com/legal/contributors/submit

review: Needs Fixing

[Scott Moser (smoser)]

Marius,
Thank you for your contribution. Sorry for the confusion or delay in responding.

I'm going to mark this 'rejected' as of right now. You are welcome to re-submit it, but do so against the git repo now.

https://code.launchpad.net/maas-images

thanks!

Unmerged revisions

353. By Marius Žalinauskas <email address hidden> on 2017-01-09

Bugfix, see https://bugs.launchpad.net/maas-images/+bug/1654853

352. By Marius Žalinauskas <email address hidden> on 2016-12-21

Extensibly modified CentOS 6/7 Curtin hooks.

For the most part it is curtin/commands/curthooks.py ported to CentOS. Some code from old CentOS hooks is still used.

Implemented:

- Legacy boot
- UEFI boot
- Simple and MD RAID layouts
- IPv4 DHCP and static networking, IP aliases on physical and VLAN interfaces

Not implemented:

- Bond, bridge, route configurations
- IPv6
- Disk encryption
- bcache
- LVM
- Multipath

=== modified file 'curtin/centos6/curtin-hooks.py'
--- curtin/centos6/curtin-hooks.py	2016-05-11 18:47:46 +0000
+++ curtin/centos6/curtin-hooks.py	2017-01-09 15:19:25 +0000
@@ -1,20 +1,19 @@
 #!/usr/bin/env python
-
-from __future__ import (
-    absolute_import,
-    print_function,
-    unicode_literals,
-    )
+# coding: utf-8
 
 import codecs
+import ipaddress
 import os
 import re
+import shutil
 import sys
 
-from curtin import (
-    block,
-    util,
-    )
+from curtin import block, config, util
+from curtin.block import mdadm
+from curtin.commands import curthooks
+from curtin.log import LOG
+from curtin.reporter import events
+
 
 """
 CentOS 6
@@ -22,15 +21,21 @@
 Currently Support:
 
 - Legacy boot
-- DHCP of BOOTIF
+- UEFI boot
+- Simple and MD RAID layouts
+- IPv4 DHCP and static networking, IP aliases on physical and VLAN interfaces
 
 Not Supported:
 
-- UEFI boot (*Bad support, most likely wont support)
-- Multiple network configration
+- Bond, bridge, route configurations
 - IPv6
+- Disk encryption
+- bcache
+- LVM
+- Multipath
 """
 
+
 FSTAB_PREPEND = """\
 #
 # /etc/fstab
@@ -54,36 +59,95 @@
 # Created by MAAS fast-path installer.
 #
 default 0
-timeout 0
-title MAAS
+timeout 1
+title CentOS
  root {grub_root}
- kernel /boot/{vmlinuz} root=UUID={root_uuid} {extra_opts}
- initrd /boot/{initrd}
+ kernel /{vmlinuz} root=UUID={root_uuid} {extra_opts}
+ initrd /{initrd}
 """
 
 
-def get_block_devices(target):
-    """Returns list of block devices for the given target."""
-    devs = block.get_devices_for_mp(target)
-    blockdevs = set()
-    for maybepart in devs:
-        (blockdev, part) = block.get_blockdev_for_partition(maybepart)
-        blockdevs.add(blockdev)
-    return list(blockdevs)
-
-
-def get_root_info(target):
-    """Returns the root partitions information."""
-    rootpath = block.get_devices_for_mp(target)[0]
-    rootdev = os.path.basename(rootpath)
-    blocks = block._lsblock()
-    return blocks[rootdev]
-
-
-def read_file(path):
-    """Returns content of a file."""
-    with codecs.open(path, encoding='utf-8') as stream:
-        return stream.read()
+def get_installed_packages(target=None):
+    (out, _) = util.subp(['rpm', '-qa', '--qf', '"%{NAME}\n"'],
+                         target=target, capture=True)
+    return set(out.splitlines())
+
+
+def install_packages(pkglist, target):
+    if isinstance(pkglist, str):
+        pkglist = [pkglist]
+    # Does not work – hosts are not resolved
+    # return util.subp(['yum', '-q', '-y', 'install'] + pkglist, target=target, capture=True)
+    with util.RunInChroot(target) as in_chroot:
+        in_chroot(['yum', '-q', '-y', 'install'] + pkglist)
+
+
+def install_missing_packages(cfg, target):
+    ''' describe which operation types will require specific packages
+
+    'custom_config_key': {
+         'pkg1': ['op_name_1', 'op_name_2', ...]
+     }
+    '''
+    custom_configs = {
+        'storage': {
+            'lvm2': ['lvm_volgroup', 'lvm_partition'],
+            'mdadm': ['raid'],
+            # TODO. At the moment there are no official packages for bcache on CentOS
+            #'bcache-tools': ['bcache']
+        },
+        'network': {
+            'bridge-utils': ['bridge']
+        },
+    }
+
+    format_configs = {
+        'xfsprogs': ['xfs'],
+        'e2fsprogs': ['ext2', 'ext3', 'ext4'],
+        'btrfs-tools': ['btrfs'],
+    }
+
+    needed_packages = []
+    installed_packages = get_installed_packages(target)
+    for cust_cfg, pkg_reqs in custom_configs.items():
+        if cust_cfg not in cfg:
+            continue
+
+        all_types = set(
+            operation['type']
+            for operation in cfg[cust_cfg]['config']
+            )
+        for pkg, types in pkg_reqs.items():
+            if set(types).intersection(all_types) and \
+               pkg not in installed_packages:
+                needed_packages.append(pkg)
+
+        format_types = set(
+            [operation['fstype']
+             for operation in cfg[cust_cfg]['config']
+             if operation['type'] == 'format'])
+        for pkg, fstypes in format_configs.items():
+            if set(fstypes).intersection(format_types) and \
+               pkg not in installed_packages:
+                needed_packages.append(pkg)
+
+    if needed_packages:
+        state = util.load_command_environment()
+        with events.ReportEventStack(
+                name=state.get('report_stack_prefix'),
+                reporting_enabled=True, level="INFO",
+                description="Installing packages on target system: " +
+                str(needed_packages)):
+            install_packages(needed_packages, target=target)
+
+
+def copy_mdadm_conf(mdadm_conf, target):
+    if not mdadm_conf:
+        LOG.warn("mdadm config must be specified, not copying")
+        return
+
+    LOG.info("copying mdadm.conf into target")
+    shutil.copy(mdadm_conf, os.path.sep.join([target, 'etc/mdadm.conf']))
 
 
 def write_fstab(target, curtin_fstab):
@@ -97,11 +161,289 @@
         stream.write(FSTAB_APPEND)
 
 
-def extract_kernel_params(data):
-    """Extracts the kernel parametes from the provided
-    grub config data."""
-    match = re.search('^\s+kernel (.+?)$', data, re.MULTILINE)
-    return match.group(0)
+def update_initramfs(target=None):
+    path = os.path.join(
+        target, 'etc', 'dracut.conf.d', 'local.conf')
+    with open(path, 'w') as stream:
+        stream.write('mdadmconf="yes"' + '\n'
+                     'lvmconf="yes"'   + '\n')
+
+    initrd = get_boot_file(target, 'initramfs')
+    version = initrd.replace('initramfs-', '').replace('.img', '')
+    initrd_path = os.path.join(os.sep, 'boot', initrd)
+    with util.RunInChroot(target) as in_chroot:
+        in_chroot(['dracut', '-f', initrd_path, version])
+
+
+def system_upgrade(cfg, target):
+    """run yum upgrade in target.
+
+    config:
+      system_upgrade:
+        enabled: False
+
+    """
+    mycfg = {'system_upgrade': {'enabled': False}}
+    config.merge_config(mycfg, cfg)
+    mycfg = mycfg.get('system_upgrade')
+    if not isinstance(mycfg, dict):
+        LOG.debug("system_upgrade disabled by config. entry not a dict.")
+        return
+
+    if not config.value_as_boolean(mycfg.get('enabled', True)):
+        LOG.debug("system_upgrade disabled by config.")
+        return
+
+    util.subp(['yum', '-q', '-y', 'upgrade'], target=target, capture=True)
+
+
+def read_file(path):
+    """Returns content of a file."""
+    with codecs.open(path, encoding='utf-8') as stream:
+        return stream.read()
+
+
+def get_boot_mac():
+    """Return the mac address of the booting interface."""
+    cmdline = read_file('/proc/cmdline')
+    cmdline = cmdline.split()
+    try:
+        bootif = [
+            option
+            for option in cmdline
+            if option.startswith('BOOTIF')
+            ][0]
+    except IndexError:
+        return None
+    _, mac = bootif.split('=')
+    mac = mac.split('-')[1:]
+    return ':'.join(mac)
+
+
+def get_interface_names():
+    """Return a dictionary mapping mac addresses to interface names."""
+    sys_path = "/sys/class/net"
+    ifaces = {}
+    for iname in os.listdir(sys_path):
+        mac = read_file(os.path.join(sys_path, iname, "address"))
+        mac = mac.strip().lower()
+        ifaces[mac] = iname
+    return ifaces
+
+
+def find_legacy_iface_name(consistent_iface_name):
+    """Returns legacy network interface name by running biosdevname (needs)
+    to be installed beforehand)"""
+    out, err = util.subp(['biosdevname', '--policy', 'all_ethN',
+                          '--interface', consistent_iface_name],
+                         capture=True)
+    return out.strip()
+
+
+def rename_ifaces(network_config, target):
+    """CentOS 6 is not using a consistent network device naming and even we
+    would enable it, interface names would differ from names they would get
+    on new systems with systemd. Will change every occurence of consistent
+    network device name to legacy name ethN and create an appropriate
+    /etc/udev/rules.d/70-persistent-net.rules"""
+
+    # Will need biosdevname to find out legacy names
+    util.install_packages(['biosdevname'])
+
+    # Build the cache as {'consistent_name': 'legacy_name'}
+    cache = {}
+    for cfg in network_config['config']:
+        if cfg['type'] == 'physical':
+            consistent_name = cfg['name']
+            cache[consistent_name] = find_legacy_iface_name(consistent_name)
+
+    rules = ''
+    rule_template = ('SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", '
+                     'ATTR{{address}}=="{mac_address}", KERNEL=="eth*", '
+                     'NAME="{iface_name}"\n')
+
+    # Rename devices and generate an appropriate content for
+    # /etc/udev/rules.d/70-persistent-net.rules
+    for cfg in network_config['config']:
+        if cfg['type'] == 'physical':
+            consistent_phys_name = cfg['name']
+            legacy_phys_name = cache[consistent_phys_name]
+            cfg['name'] = legacy_phys_name
+            rules += rule_template.format(iface_name=legacy_phys_name,
+                                          mac_address=cfg['mac_address'])
+        if cfg['type'] == 'vlan':
+            consistent_phys_name = cfg['vlan_link']
+            legacy_phys_name = cache[consistent_phys_name]
+            cfg['name'] = '{}.{}'.format(legacy_phys_name, cfg['vlan_id'])
+            cfg['vlan_link'] = legacy_phys_name
+
+    path = os.path.join(target, 'etc', 'udev', 'rules.d',
+                        '70-persistent-net.rules')
+    util.write_file(path, rules)
+
+
+
+def get_subnet_config(subnets):
+    content = ''
+    for idx, subnet in enumerate(subnets):
+        if subnet['type'] in ('static', 'static4'):
+            if idx == 0:
+                idx = ''
+            iface = ipaddress.ip_interface(subnet['address'])
+            content += 'IPADDR{}={}\n'.format(idx, str(iface.ip))
+            content += 'NETMASK{}={}\n'.format(
+                idx, subnet.get('netmask', str(iface.netmask)))
+    return content
+
+
+def get_common_network_config(cfg):
+    # You can not have more than one GATEWAY, BOOTPROTO, DNS1, DNS2 and DOMAIN
+    # settings per interface in RHEL and clones. Will run through subnets
+    # section ensuring that only one of these makes to interface configuration.
+    content = ''
+    bootproto = 'dhcp'
+    defaultgw = None
+    resolvers = []
+    search_domains = []
+    for subnet in cfg['subnets']:
+        if subnet['type'] in ('dhcp', 'dhcp4'):
+            # OK, so we have a DHCP subnet. Let's assume all other subnets
+            # are also DHCP and just stop looking
+            bootproto = 'dhcp'
+            break
+        elif subnet['type'] in ('static', 'static4'):
+            # If this is a static subnet, then there might be a default
+            # gateway and resolvers set and if there aren't we'll keep
+            # looking for them in the next subnet configuration
+            bootproto = 'none'
+            if not defaultgw:
+                defaultgw = subnet.get('gateway')
+            if not resolvers:
+                resolvers = subnet.get('dns_nameservers')
+            if not search_domains:
+                search_domains = subnet.get('dns_search')
+        else:
+            # Let's log the lack of support and continue - there still
+            # migth be a supported subnet configuration
+            LOG.warn('Configuration of subnet type {} '
+                     'not supported'.format(subnet['type']))
+
+    content += 'BOOTPROTO={}\n'.format(bootproto)
+    if bootproto != 'dhcp':
+        if defaultgw:
+            content += 'GATEWAY={}\n'.format(defaultgw)
+        for idx, resolver in enumerate(resolvers):
+            content += 'DNS{}={}\n'.format(idx+1, resolver)
+        if search_domains:
+            content += 'DOMAIN="{}"\n'.format(' '.join(search_domains))
+
+    return content
+
+
+def write_resolv_conf(cfg, target):
+    content = '# Generated by MAAS fast-path installer\n'
+
+    for resolver in cfg.get('address', []):
+        content += 'nameserver {}\n'.format(resolver)
+
+    search_domains = cfg.get('search', [])
+    if search_domains:
+        content += 'search {}\n'.format(' '.join(search_domains))
+
+    path = os.path.join(target, 'etc', 'resolv.conf')
+    util.write_file(path, content)
+
+
+def write_physical_iface_config(cfg, target):
+    content = (
+        '# Generated by MAAS fast-path installer\n'
+        'DEVICE={device}\n'
+        'HWADDR={hwaddr}\n'
+        'MTU={mtu}\n'
+        'ONBOOT=yes\n'
+    ).format(
+        device=cfg['name'],
+        hwaddr=cfg['mac_address'],
+        mtu=cfg.get('mtu', 1500)
+    )
+
+    content += get_common_network_config(cfg) + \
+               get_subnet_config(cfg['subnets'])
+
+    path = os.path.join(target, 'etc', 'sysconfig',
+                        'network-scripts', 'ifcfg-%s' % cfg['name'])
+    util.write_file(path, content)
+
+
+def write_vlan_iface_config(cfg, target):
+    content = (
+        '# Generated by MAAS fast-path installer\n'
+        'DEVICE={device}\n'
+        'MTU={mtu}\n'
+        'ONBOOT=yes\n'
+        'VLAN=yes\n'
+    ).format(
+        device=cfg['name'],
+        mtu=cfg.get('mtu', 1500)
+    )
+
+    content += get_common_network_config(cfg) + \
+               get_subnet_config(cfg['subnets'])
+
+    path = os.path.join(target, 'etc', 'sysconfig',
+                        'network-scripts', 'ifcfg-%s' % cfg['name'])
+    util.write_file(path, content)
+
+
+def apply_networking(config, target):
+    network_config = config.get('network')
+    if not network_config:
+        LOG.warn("Unable to retrieve network configuration, will fallback "
+                 "to configuring DHCP on boot device")
+        bootmac = get_boot_mac()
+        inames = get_interface_names()
+        iname = inames[bootmac.lower()]
+        network_config = {
+            'config': [
+                {'mac_address': bootmac,
+                 'name': iname,
+                 'type': 'physical',
+                 'subnets': [{'type': 'dhcp'}]}],
+            'version': 1}
+
+    # Bring back ethN device naming on CentOS 6
+    rename_ifaces(network_config, target)
+
+    for cfg in network_config['config']:
+        if cfg['type'] == 'nameserver':
+            write_resolv_conf(cfg, target)
+        if cfg['type'] == 'physical':
+            write_physical_iface_config(cfg, target)
+        if cfg['type'] == 'vlan':
+            write_vlan_iface_config(cfg, target)
+
+
+def get_grub_root(target, dedicated_boot):
+    """Extracts the grub root (hdX,X) from the grub command.
+
+    This is used so the correct root device is used to install
+    stage1/stage2 boot loader.
+
+    Note: grub-install normally does all of this for you, but
+    since the grub is older, it has an issue with the ISCSI
+    target as /dev/sda and cannot enumarate it with the BIOS.
+    """
+    stage1 = '/boot/grub/stage1'
+    if dedicated_boot:
+        stage1 = '/grub/stage1'
+
+    with util.RunInChroot(target) as in_chroot:
+        data = ('find {}\n'
+                'quit\n').format(stage1).encode('utf-8')
+        out, err = in_chroot(['grub', '--batch'],
+                             data=data, capture=True)
+        regex = re.search(r'^\s+(\(.+?\))$', out, re.MULTILINE)
+        return regex.groups()[0]
 
 
 def strip_kernel_params(params, strip_params=[]):
@@ -118,6 +460,33 @@
     return new_params
 
 
+def get_extra_kernel_parameters():
+    """Extracts the extra kernel commands from /proc/cmdline
+    that should be placed onto the host.
+
+    Any command following the '---' entry should be placed
+    onto the host.
+    """
+    cmdline = read_file('/proc/cmdline')
+    cmdline = cmdline.split()
+    if '---' not in cmdline:
+        return []
+    idx = cmdline.index('---') + 1
+    if idx >= len(cmdline) + 1:
+        return []
+    return strip_kernel_params(
+        cmdline[idx:],
+        strip_params=['initrd=', 'BOOT_IMAGE=', 'BOOTIF='])
+
+
+def get_root_info(target):
+    """Returns the root partitions information."""
+    rootpath = block.get_devices_for_mp(target)[0]
+    rootdev = os.path.basename(rootpath)
+    blocks = block._lsblock()
+    return blocks[rootdev]
+
+
 def get_boot_file(target, filename):
     """Return the full filename of file in /boot on target."""
     boot_dir = os.path.join(target, 'boot')
@@ -125,81 +494,163 @@
         fname
         for fname in os.listdir(boot_dir)
         if fname.startswith(filename)
-        ]
+    ]
     if not files:
         return None
     return files[0]
 
 
-def write_grub_conf(target, grub_root, extra=[]):
+def write_grub_conf(target, dedicated_boot, extra=[]):
     """Writes a new /boot/grub/grub.conf with the correct
     boot arguments."""
+    grub_path = os.path.join(target, 'boot', 'grub', 'grub.conf')
+    util.write_file(grub_path, '# UEFI system, see /etc/grub.conf\n')
+
+    if util.is_uefi_bootable():
+        grub_path = os.path.join(target, 'boot', 'efi',
+                                 'EFI', 'redhat', 'grub.conf')
+
+    grub_root = get_grub_root(target, dedicated_boot)
     root_info = get_root_info(target)
-    grub_path = os.path.join(target, 'boot', 'grub', 'grub.conf')
     extra_opts = ' '.join(extra)
     vmlinuz = get_boot_file(target, 'vmlinuz')
     initrd = get_boot_file(target, 'initramfs')
-    with open(grub_path, 'w') as stream:
-        stream.write(
-            GRUB_CONF.format(
-                grub_root=grub_root,
-                vmlinuz=vmlinuz,
-                initrd=initrd,
-                root_uuid=root_info['UUID'],
-                extra_opts=extra_opts) + '\n')
-
-
-def get_extra_kernel_parameters():
-    """Extracts the extra kernel commands from /proc/cmdline
-    that should be placed onto the host.
-
-    Any command following the '--' entry should be placed
-    onto the host.
-    """
-    cmdline = read_file('/proc/cmdline')
-    cmdline = cmdline.split()
-    if '--' not in cmdline:
-        return []
-    idx = cmdline.index('--') + 1
-    if idx >= len(cmdline) + 1:
-        return []
-    return strip_kernel_params(
-        cmdline[idx:],
-        strip_params=['initrd=', 'BOOT_IMAGE=', 'BOOTIF='])
-
-
-def get_grub_root(target):
-    """Extracts the grub root (hdX,X) from the grub command.
-
-    This is used so the correct root device is used to install
-    stage1/stage2 boot loader.
-
-    Note: grub-install normally does all of this for you, but
-    since the grub is older, it has an issue with the ISCSI
-    target as /dev/sda and cannot enumarate it with the BIOS.
-    """
-    with util.RunInChroot(target) as in_chroot:
-        data = '\n'.join([
-            'find /boot/grub/stage1',
-            'quit',
-            ]).encode('utf-8')
-        out, err = in_chroot(['grub', '--batch'],
-                             data=data, capture=True)
-        regex = re.search('^\s+(\(.+?\))$', out, re.MULTILINE)
-        return regex.groups()[0]
-
-
-def grub_install(target, root):
-    """Installs grub onto the root."""
-    root_dev = root.split(',')[0] + ')'
-    with util.RunInChroot(target) as in_chroot:
-        data = '\n'.join([
-            'root %s' % root,
-            'setup %s' % root_dev,
-            'quit',
-            ]).encode('utf-8')
-        in_chroot(['grub', '--batch'],
-                  data=data)
+
+    if not dedicated_boot:
+        vmlinuz = 'boot/' + vmlinuz
+        initrd = 'boot/' + initrd
+
+    util.write_file(grub_path,
+                    GRUB_CONF.format(
+                        grub_root=grub_root,
+                        vmlinuz=vmlinuz,
+                        initrd=initrd,
+                        root_uuid=root_info['UUID'],
+                        extra_opts=extra_opts) + '\n')
+
+    # FIXME. replace() is unreliable here if target ends with /
+    # Update /etc/grub.conf link as it is used by kernel install scripts
+    util.subp(['ln', '-sf', grub_path.replace(target, '..'),
+               '/etc/grub.conf'], target=target)
+
+
+def get_uefi_partition():
+    """Return the UEFI partition."""
+    for _, value in block._lsblock().items():
+        if value['LABEL'] == 'uefi-boot':
+            return value
+    return None
+
+
+def install_bootloader(target, device=None):
+    """Installs bootloader to the device."""
+    cmd = []
+    if util.is_uefi_bootable():
+        uefi_dev = get_uefi_partition()['device_path']
+        disk, part = block.get_blockdev_for_partition(uefi_dev)
+        cmd = ['efibootmgr', '-v', '-c', '-w', '-L', 'centos',
+               '-d', disk, '-p', part, '-l', r'\EFI\redhat\grub.efi']
+    else:
+        # Legacy grub-install uses df output, which itself uses /etc/mtab
+        with util.RunInChroot(target) as in_chroot:
+            in_chroot(['cp', '-f', '/proc/mounts', '/etc/mtab'])
+        cmd = ['grub-install', '--recheck', device]
+
+    with util.RunInChroot(target) as in_chroot:
+        in_chroot(cmd)
+
+
+def setup_grub(cfg, target):
+    # target is the path to the mounted filesystem
+
+    # FIXME: these methods need moving to curtin.block
+    # and using them from there rather than commands.block_meta
+    from curtin.commands.block_meta import (extract_storage_ordered_dict,
+                                            get_path_to_storage_volume)
+
+    grubcfg = cfg.get('grub', {})
+
+    # copy legacy top level name
+    if 'grub_install_devices' in cfg and 'install_devices' not in grubcfg:
+        grubcfg['install_devices'] = cfg['grub_install_devices']
+
+    LOG.debug("setup grub on target %s", target)
+    # if there is storage config, look for devices tagged with 'grub_device'
+    storage_cfg_odict = None
+    try:
+        storage_cfg_odict = extract_storage_ordered_dict(cfg)
+    except ValueError as e:
+        pass
+
+    if storage_cfg_odict:
+        storage_grub_devices = []
+        for item_id, item in storage_cfg_odict.items():
+            if not item.get('grub_device'):
+                continue
+            LOG.debug("checking: %s", item)
+            storage_grub_devices.append(
+                get_path_to_storage_volume(item_id, storage_cfg_odict))
+        if len(storage_grub_devices) > 0:
+            grubcfg['install_devices'] = storage_grub_devices
+
+    LOG.debug("install_devices: %s", grubcfg.get('install_devices'))
+    if 'install_devices' in grubcfg:
+        instdevs = grubcfg.get('install_devices')
+        if isinstance(instdevs, str):
+            instdevs = [instdevs]
+        if instdevs is None:
+            LOG.debug("grub installation disabled by config")
+    else:
+        # If there were no install_devices found then we try to do the right
+        # thing.  That right thing is basically installing on all block
+        # devices that are mounted.  On powerpc, though it means finding PrEP
+        # partitions.
+        devs = block.get_devices_for_mp(target)
+        blockdevs = set()
+        for maybepart in devs:
+            try:
+                (blockdev, part) = block.get_blockdev_for_partition(maybepart)
+                blockdevs.add(blockdev)
+            except ValueError as e:
+                # if there is no syspath for this device such as a lvm
+                # or raid device, then a ValueError is raised here.
+                LOG.debug("failed to find block device for %s", maybepart)
+        instdevs = list(blockdevs)
+
+    # UEFI requires additional packages
+    #if util.is_uefi_bootable():
+    #    pkgs = ['efibootmgr']
+    #    install_packages(pkgs, target=target)
+
+    # CentOS will not assemble MD devices on boot without rd.md.uuid=MD_UUID
+    # kernel parameters
+    mdmap = {}
+    rdmduuids = []
+    try:
+        mdmap = mdadm.md_read_run_mdadm_map()
+        for md in mdmap:
+            rdmduuids.append("rd.md.uuid=%s" % mdadm.md_get_uuid(mdmap[md][2]))
+    except ValueError as e:
+        pass
+
+    dedicated_boot = False
+    if block.get_devices_for_mp(os.path.join(target, 'boot')):
+        dedicated_boot = True
+    write_grub_conf(target, dedicated_boot, extra=get_extra_kernel_parameters() + rdmduuids)
+
+    if instdevs:
+        instdevs = [block.get_dev_name_entry(i)[1] for i in instdevs]
+    else:
+        instdevs = ["none"]
+
+    LOG.debug("installing grub to %s", instdevs)
+
+    if util.is_uefi_bootable():
+        if grubcfg.get('update_nvram', False):
+            install_bootloader(target)
+    else:
+        for dev in instdevs:
+            install_bootloader(target, dev)
 
 
 def set_autorelabel(target):
@@ -214,128 +665,75 @@
     open(path, 'a').close()
 
 
-def get_boot_mac():
-    """Return the mac address of the booting interface."""
-    cmdline = read_file('/proc/cmdline')
-    cmdline = cmdline.split()
-    try:
-        bootif = [
-            option
-            for option in cmdline
-            if option.startswith('BOOTIF')
-            ][0]
-    except IndexError:
-        return None
-    _, mac = bootif.split('=')
-    mac = mac.split('-')[1:]
-    return ':'.join(mac)
-
-
-def get_interface_names():
-    """Return a dictionary mapping mac addresses to interface names."""
-    sys_path = "/sys/class/net"
-    ifaces = {}
-    for iname in os.listdir(sys_path):
-        mac = read_file(os.path.join(sys_path, iname, "address"))
-        mac = mac.strip().lower()
-        ifaces[mac] = iname
-    return ifaces
-
-
-def get_ipv4_config(iface, data):
-    """Returns the contents of the interface file for ipv4."""
-    config = [
-        'TYPE="Ethernet"',
-        'NM_CONTROLLED="no"',
-        'USERCTL="yes"',
-        ]
-    if 'hwaddress' in data:
-        config.append('HWADDR="%s"' % data['hwaddress'])
-    else:
-        # Last ditch effort, use the device name, it probably won't match
-        # though!
-        config.append('DEVICE="%s"' % iface)
-    if data['auto']:
-        config.append('ONBOOT="yes"')
-    else:
-        config.append('ONBOOT="no"')
-
-    method = data['method']
-    if method == 'dhcp':
-        config.append('BOOTPROTO="dhcp"')
-        config.append('PEERDNS="yes"')
-        config.append('PERSISTENT_DHCLIENT="1"')
-        if 'hostname' in data:
-            config.append('DHCP_HOSTNAME="%s"' % data['hostname'])
-    elif method == 'static':
-        config.append('BOOTPROTO="none"')
-        config.append('IPADDR="%s"' % data['address'])
-        config.append('NETMASK="%s"' % data['netmask'])
-        if 'broadcast' in data:
-            config.append('BROADCAST="%s"' % data['broadcast'])
-        if 'gateway' in data:
-            config.append('GATEWAY="%s"' % data['gateway'])
-    elif method == 'manual':
-        config.append('BOOTPROTO="none"')
-    return '\n'.join(config)
-
-
-def write_interface_config(target, iface, data):
-    """Writes config for interface."""
-    family = data['family']
-    if family != "inet":
-        # Only supporting ipv4 currently
-        print(
-            "WARN: unsupported family %s, "
-            "failed to configure interface: %s" (family, iface))
-        return
-    config = get_ipv4_config(iface, data)
-    path = os.path.join(
-        target, 'etc', 'sysconfig', 'network-scripts', 'ifcfg-%s' % iface)
-    with open(path, 'w') as stream:
-        stream.write(config + '\n')
-
-
-def write_network_config(target, mac):
-    """Write network configuration for the given MAC address."""
-    inames = get_interface_names()
-    iname = inames[mac.lower()]
-    write_interface_config(
-        target, iname, {
-            'family': 'inet',
-            'hwaddress': mac.upper(),
-            'auto': True,
-            'method': 'dhcp'
-        })
-
-
 def main():
     state = util.load_command_environment()
+
     target = state['target']
     if target is None:
-        print("Target was not provided in the environment.")
-        sys.exit(1)
-    fstab = state['fstab']
-    if fstab is None:
-        print("/etc/fstab output was not provided in the environment.")
-        sys.exit(1)
-    bootmac = get_boot_mac()
-    if bootmac is None:
-        print("Unable to determine boot interface.")
-        sys.exit(1)
-    devices = get_block_devices(target)
-    if not devices:
-        print("Unable to find block device for: %s" % target)
-        sys.exit(1)
-
-    write_fstab(target, fstab)
-
-    grub_root = get_grub_root(target)
-    write_grub_conf(target, grub_root, extra=get_extra_kernel_parameters())
-    grub_install(target, grub_root)
+        sys.stderr.write("Target was not provided in the environment.")
+        sys.exit(1)
+
+    cfg = config.load_command_config(None, state)
+    stack_prefix = state.get('report_stack_prefix', '')
+
+    with events.ReportEventStack(
+            name=stack_prefix, reporting_enabled=True, level="INFO",
+            description="writing config files"):
+        curthooks.write_files(cfg, target)
+
+    # Default CentOS image does not contain some packages that may be necessary
+    install_missing_packages(cfg, target)
+
+    # If a mdadm.conf file was created by block_meta then it needs to be copied
+    # onto the target system
+    mdadm_location = os.path.join(os.path.split(state['fstab'])[0],
+                                  "mdadm.conf")
+    if os.path.exists(mdadm_location):
+        copy_mdadm_conf(mdadm_location, target)
+
+    with events.ReportEventStack(
+            name=stack_prefix, reporting_enabled=True, level="INFO",
+            description="setting up swap"):
+        curthooks.add_swap(cfg, target, state.get('fstab'))
+
+    with events.ReportEventStack(
+            name=stack_prefix, reporting_enabled=True, level="INFO",
+            description="writing etc/fstab"):
+        write_fstab(target, state.get('fstab'))
+
+    # TODO. There's a multipath implementation on Ubuntu in curtin/curthooks.py
+    # that should be reimplemented here. Skipping for now.
+
+    with events.ReportEventStack(
+            name=stack_prefix, reporting_enabled=True, level="INFO",
+            description="updating packages on target system"):
+        system_upgrade(cfg, target)
+
+    # TODO. If a crypttab file was created by block_meta than it needs to be 
+    # copied onto the target system, and update_initramfs() (well, alternative 
+    # for CentOS actually) needs to be run, so that the cryptsetup hooks are 
+    # properly configured on the installed system and it will be able to open 
+    # encrypted volumes at boot. Skipping for now.
+
+    with events.ReportEventStack(
+            name=stack_prefix, reporting_enabled=True, level="INFO",
+            description="apply networking"):
+        apply_networking(cfg, target)
+
+    # If udev dname rules were created, copy them to target
+    udev_rules_d = os.path.join(state['scratch'], "rules.d")
+    if os.path.isdir(udev_rules_d):
+        curthooks.copy_dname_rules(udev_rules_d, target)
+
+    with events.ReportEventStack(
+            name=stack_prefix, reporting_enabled=True, level="INFO",
+            description="updating packages on target system"):
+        setup_grub(cfg, target)
 
     set_autorelabel(target)
-    write_network_config(target, bootmac)
+    update_initramfs(target)
+
+    sys.exit(0)
 
 
 if __name__ == "__main__":
 
=== modified file 'curtin/centos7/curtin-hooks.py'
--- curtin/centos7/curtin-hooks.py	2016-05-11 18:47:46 +0000
+++ curtin/centos7/curtin-hooks.py	2017-01-09 15:19:25 +0000
@@ -1,20 +1,17 @@
 #!/usr/bin/env python
-
-from __future__ import (
-    absolute_import,
-    print_function,
-    unicode_literals,
-    )
+# coding: utf-8
 
 import codecs
+import ipaddress
 import os
+import shutil
 import sys
-import shutil
 
-from curtin import (
-    block,
-    util,
-    )
+from curtin import block, config, util
+from curtin.block import mdadm
+from curtin.commands import curthooks
+from curtin.log import LOG
+from curtin.reporter import events
 
 
 """
@@ -24,60 +21,142 @@
 
 - Legacy boot
 - UEFI boot
-- DHCP of BOOTIF
+- Simple and MD RAID layouts
+- IPv4 DHCP and static networking, IP aliases on physical and VLAN interfaces
 
 Not Supported:
 
-- Multiple network configration
+- Bond, bridge, route configurations
 - IPv6
-"""
-
-FSTAB_PREPEND = """\
-#
-# /etc/fstab
-# Created by MAAS fast-path installer.
-#
-# Accessible filesystems, by reference, are maintained under '/dev/disk'
-# See man pages fstab(5), findfs(8), mount(8) and/or blkid(8) for more info
-#
-"""
-
-FSTAB_UEFI = """\
-LABEL=uefi-boot /boot/efi vfat defaults 0 0
-"""
+- Disk encryption
+- bcache
+- LVM
+- Multipath
+"""
+
 
 GRUB_PREPEND = """\
 # Set by MAAS fast-path installer.
-GRUB_TIMEOUT=0
+GRUB_TIMEOUT=1
 GRUB_TERMINAL_OUTPUT=console
 GRUB_DISABLE_OS_PROBER=true
 """
 
 
-def get_block_devices(target):
-    """Returns list of block devices for the given target."""
-    devs = block.get_devices_for_mp(target)
-    blockdevs = set()
-    for maybepart in devs:
-        (blockdev, part) = block.get_blockdev_for_partition(maybepart)
-        blockdevs.add(blockdev)
-    return list(blockdevs)
-
-
-def get_root_info(target):
-    """Returns the root partitions information."""
-    rootpath = block.get_devices_for_mp(target)[0]
-    rootdev = os.path.basename(rootpath)
-    blocks = block._lsblock()
-    return blocks[rootdev]
-
-
-def get_uefi_partition():
-    """Return the UEFI partition."""
-    for _, value in block._lsblock().items():
-        if value['LABEL'] == 'uefi-boot':
-            return value
-    return None
+def get_installed_packages(target=None):
+    (out, _) = util.subp(['rpm', '-qa', '--qf', '"%{NAME}\n"'],
+                         target=target, capture=True)
+    return set(out.splitlines())
+
+
+def install_packages(pkglist, target):
+    if isinstance(pkglist, str):
+        pkglist = [pkglist]
+    # Does not work – hosts are not resolved
+    # return util.subp(['yum', '-q', '-y', 'install'] + pkglist, target=target, capture=True)
+    with util.RunInChroot(target) as in_chroot:
+        in_chroot(['yum', '-q', '-y', 'install'] + pkglist)
+
+
+def install_missing_packages(cfg, target):
+    ''' describe which operation types will require specific packages
+
+    'custom_config_key': {
+         'pkg1': ['op_name_1', 'op_name_2', ...]
+     }
+    '''
+    custom_configs = {
+        'storage': {
+            'lvm2': ['lvm_volgroup', 'lvm_partition'],
+            'mdadm': ['raid'],
+            # XXX. At the moment there are no official packages for bcache on CentOS
+            #'bcache-tools': ['bcache']
+        },
+        'network': {
+            'bridge-utils': ['bridge']
+        },
+    }
+
+    format_configs = {
+        'xfsprogs': ['xfs'],
+        'e2fsprogs': ['ext2', 'ext3', 'ext4'],
+        'btrfs-tools': ['btrfs'],
+    }
+
+    needed_packages = []
+    installed_packages = get_installed_packages(target)
+    for cust_cfg, pkg_reqs in custom_configs.items():
+        if cust_cfg not in cfg:
+            continue
+
+        all_types = set(
+            operation['type']
+            for operation in cfg[cust_cfg]['config']
+            )
+        for pkg, types in pkg_reqs.items():
+            if set(types).intersection(all_types) and \
+               pkg not in installed_packages:
+                needed_packages.append(pkg)
+
+        format_types = set(
+            [operation['fstype']
+             for operation in cfg[cust_cfg]['config']
+             if operation['type'] == 'format'])
+        for pkg, fstypes in format_configs.items():
+            if set(fstypes).intersection(format_types) and \
+               pkg not in installed_packages:
+                needed_packages.append(pkg)
+
+    if needed_packages:
+        state = util.load_command_environment()
+        with events.ReportEventStack(
+                name=state.get('report_stack_prefix'),
+                reporting_enabled=True, level="INFO",
+                description="Installing packages on target system: " +
+                str(needed_packages)):
+            install_packages(needed_packages, target=target)
+
+
+def copy_mdadm_conf(mdadm_conf, target):
+    if not mdadm_conf:
+        LOG.warn("mdadm config must be specified, not copying")
+        return
+
+    LOG.info("copying mdadm.conf into target")
+    shutil.copy(mdadm_conf, os.path.sep.join([target, 'etc/mdadm.conf']))
+
+
+def update_initramfs(target=None):
+    path = os.path.join(
+        target, 'etc', 'dracut.conf.d', 'local.conf')
+    with open(path, 'w') as stream:
+        stream.write('mdadmconf="yes"' + '\n'
+                     'lvmconf="yes"'   + '\n')
+
+    with util.RunInChroot(target) as in_chroot:
+        in_chroot(['dracut', '-f', '--regenerate-all'])
+
+
+def system_upgrade(cfg, target):
+    """run yum upgrade in target.
+
+    config:
+      system_upgrade:
+        enabled: False
+
+    """
+    mycfg = {'system_upgrade': {'enabled': False}}
+    config.merge_config(mycfg, cfg)
+    mycfg = mycfg.get('system_upgrade')
+    if not isinstance(mycfg, dict):
+        LOG.debug("system_upgrade disabled by config. entry not a dict.")
+        return
+
+    if not config.value_as_boolean(mycfg.get('enabled', True)):
+        LOG.debug("system_upgrade disabled by config.")
+        return
+
+    util.subp(['yum', '-q', '-y', 'upgrade'], target=target, capture=True)
 
 
 def read_file(path):
@@ -86,16 +165,178 @@
         return stream.read()
 
 
-def write_fstab(target, curtin_fstab):
-    """Writes the new fstab, using the fstab provided
-    from curtin."""
-    fstab_path = os.path.join(target, 'etc', 'fstab')
-    fstab_data = read_file(curtin_fstab)
-    with open(fstab_path, 'w') as stream:
-        stream.write(FSTAB_PREPEND)
-        stream.write(fstab_data)
-        if util.is_uefi_bootable():
-            stream.write(FSTAB_UEFI)
+def get_boot_mac():
+    """Return the mac address of the booting interface."""
+    cmdline = read_file('/proc/cmdline')
+    cmdline = cmdline.split()
+    try:
+        bootif = [
+            option
+            for option in cmdline
+            if option.startswith('BOOTIF')
+            ][0]
+    except IndexError:
+        return None
+    _, mac = bootif.split('=')
+    mac = mac.split('-')[1:]
+    return ':'.join(mac)
+
+
+def get_interface_names():
+    """Return a dictionary mapping mac addresses to interface names."""
+    sys_path = "/sys/class/net"
+    ifaces = {}
+    for iname in os.listdir(sys_path):
+        mac = read_file(os.path.join(sys_path, iname, "address"))
+        mac = mac.strip().lower()
+        ifaces[mac] = iname
+    return ifaces
+
+
+def get_subnet_config(subnets):
+    content = ''
+    for idx, subnet in enumerate(subnets):
+        if subnet['type'] in ('static', 'static4'):
+            if idx == 0:
+                idx = ''
+            iface = ipaddress.ip_interface(subnet['address'])
+            content += 'IPADDR{}={}\n'.format(idx, str(iface.ip))
+            content += 'NETMASK{}={}\n'.format(
+                idx, subnet.get('netmask', str(iface.netmask)))
+    return content
+
+
+def get_common_network_config(cfg):
+    # You can not have more than one GATEWAY, BOOTPROTO, DNS1, DNS2 and DOMAIN
+    # settings per interface in RHEL and clones. Will run through subnets
+    # section ensuring that only one of these makes to interface configuration.
+    content = ''
+    bootproto = 'dhcp'
+    defaultgw = None
+    resolvers = []
+    search_domains = []
+    for subnet in cfg['subnets']:
+        if subnet['type'] in ('dhcp', 'dhcp4'):
+            # OK, so we have a DHCP subnet. Let's assume all other subnets
+            # are also DHCP and just stop looking
+            bootproto = 'dhcp'
+            break
+        elif subnet['type'] in ('static', 'static4'):
+            # If this is a static subnet, then there might be a default
+            # gateway and resolvers set and if there aren't we'll keep
+            # looking for them in the next subnet configuration
+            bootproto = 'none'
+            if not defaultgw:
+                defaultgw = subnet.get('gateway')
+            if not resolvers:
+                resolvers = subnet.get('dns_nameservers')
+            if not search_domains:
+                search_domains = subnet.get('dns_search')
+        else:
+            # Let's log the lack of support and continue - there still
+            # migth be a supported subnet configuration
+            LOG.warn('Configuration of subnet type {} '
+                     'not supported'.format(subnet['type']))
+
+    content += 'BOOTPROTO={}\n'.format(bootproto)
+    if bootproto != 'dhcp':
+        if defaultgw:
+            content += 'GATEWAY={}\n'.format(defaultgw)
+        for idx, resolver in enumerate(resolvers):
+            content += 'DNS{}={}\n'.format(idx+1, resolver)
+        if search_domains:
+            content += 'DOMAIN="{}"\n'.format(' '.join(search_domains))
+
+    return content
+
+
+def write_resolv_conf(cfg, target):
+    content = '# Generated by MAAS fast-path installer\n'
+
+    for resolver in cfg.get('address', []):
+        content += 'nameserver {}\n'.format(resolver)
+
+    search_domains = cfg.get('search', [])
+    if search_domains:
+        content += 'search {}\n'.format(' '.join(search_domains))
+
+    path = os.path.join(target, 'etc', 'resolv.conf')
+    util.write_file(path, content)
+
+
+def write_physical_iface_config(cfg, target):
+    content = (
+        '# Generated by MAAS fast-path installer\n'
+        'DEVICE={device}\n'
+        'HWADDR={hwaddr}\n'
+        'MTU={mtu}\n'
+        'ONBOOT=yes\n'
+    ).format(
+        device=cfg['name'],
+        hwaddr=cfg['mac_address'],
+        mtu=cfg.get('mtu', 1500)
+    )
+
+    content += get_common_network_config(cfg) + \
+               get_subnet_config(cfg['subnets'])
+
+    path = os.path.join(target, 'etc', 'sysconfig',
+                        'network-scripts', 'ifcfg-%s' % cfg['name'])
+    util.write_file(path, content)
+
+
+def write_vlan_iface_config(cfg, target):
+    content = (
+        '# Generated by MAAS fast-path installer\n'
+        'DEVICE={device}\n'
+        'MTU={mtu}\n'
+        'ONBOOT=yes\n'
+        'VLAN=yes\n'
+    ).format(
+        device=cfg['name'],
+        mtu=cfg.get('mtu', 1500)
+    )
+
+    content += get_common_network_config(cfg) + \
+               get_subnet_config(cfg['subnets'])
+
+    path = os.path.join(target, 'etc', 'sysconfig',
+                        'network-scripts', 'ifcfg-%s' % cfg['name'])
+    util.write_file(path, content)
+
+
+def apply_networking(config, target):
+    network_config = config.get('network')
+    if not network_config:
+        LOG.warn("Unable to retrieve network configuration, will fallback "
+                 "to configuring DHCP on boot device")
+        bootmac = get_boot_mac()
+        inames = get_interface_names()
+        iname = inames[bootmac.lower()]
+        network_config = {
+            'config': [
+                {'mac_address': bootmac,
+                 'name': iname,
+                 'type': 'physical',
+                 'subnets': [{'type': 'dhcp'}]}],
+            'version': 1}
+
+    for cfg in network_config['config']:
+        if cfg['type'] == 'nameserver':
+            write_resolv_conf(cfg, target)
+        if cfg['type'] == 'physical':
+            write_physical_iface_config(cfg, target)
+        if cfg['type'] == 'vlan':
+            write_vlan_iface_config(cfg, target)
+
+
+def update_grub_default(target, extra=[]):
+    """Updates /etc/default/grub with the correct options."""
+    grub_default_path = os.path.join(target, 'etc', 'default', 'grub')
+    kernel_cmdline = ' '.join(extra)
+    with open(grub_default_path, 'a') as stream:
+        stream.write(GRUB_PREPEND)
+        stream.write('GRUB_CMDLINE_LINUX=\"%s\"\n' % kernel_cmdline)
 
 
 def strip_kernel_params(params, strip_params=[]):
@@ -121,9 +362,9 @@
     """
     cmdline = read_file('/proc/cmdline')
     cmdline = cmdline.split()
-    if '--' not in cmdline:
+    if '---' not in cmdline:
         return []
-    idx = cmdline.index('--') + 1
+    idx = cmdline.index('---') + 1
     if idx >= len(cmdline) + 1:
         return []
     return strip_kernel_params(
@@ -131,57 +372,141 @@
         strip_params=['initrd=', 'BOOT_IMAGE=', 'BOOTIF='])
 
 
-def update_grub_default(target, extra=[]):
-    """Updates /etc/default/grub with the correct options."""
-    grub_default_path = os.path.join(target, 'etc', 'default', 'grub')
-    kernel_cmdline = ' '.join(extra)
-    with open(grub_default_path, 'a') as stream:
-        stream.write(GRUB_PREPEND)
-        stream.write('GRUB_CMDLINE_LINUX=\"%s\"\n' % kernel_cmdline)
-
-
-def grub2_install(target, root):
-    """Installs grub2 to the root."""
-    with util.RunInChroot(target) as in_chroot:
-        in_chroot(['grub2-install', '--recheck', root])
-
-
 def grub2_mkconfig(target):
     """Writes the new grub2 config."""
-    with util.RunInChroot(target) as in_chroot:
-        in_chroot(['grub2-mkconfig', '-o', '/boot/grub2/grub.cfg'])
-
-
-def install_efi(target, uefi_path):
-    """Install the EFI data from /boot into efi partition."""
-    # Create temp mount point for uefi partition.
-    tmp_efi = os.path.join(target, 'boot', 'efi_part')
-    os.mkdir(tmp_efi)
-    util.subp(['mount', uefi_path, tmp_efi])
-
-    # Copy the data over.
-    try:
-        efi_path = os.path.join(target, 'boot', 'efi')
-        if os.path.exists(os.path.join(tmp_efi, 'EFI')):
-            shutil.rmtree(os.path.join(tmp_efi, 'EFI'))
-        shutil.copytree(
-            os.path.join(efi_path, 'EFI'),
-            os.path.join(tmp_efi, 'EFI'))
-    finally:
-        # Clean up tmp mount
-        util.subp(['umount', tmp_efi])
-        os.rmdir(tmp_efi)
-
-    # Mount and do grub install
-    util.subp(['mount', uefi_path, efi_path])
-    try:
-        with util.RunInChroot(target) as in_chroot:
-            in_chroot([
-                'grub2-install', '--target=x86_64-efi',
-                '--efi-directory', '/boot/efi',
-                '--recheck'])
-    finally:
-        util.subp(['umount', efi_path])
+    # NOTE. CentOS kernel packages expect /etc/grub2.cfg symlink in
+    # BIOS mode and /etc/grub2-efi.cfg symlink in UEFI mode pointing
+    # to an actual grub.cfg
+
+    grub_cfg = '/boot/grub2/grub.cfg'
+    grub_link = '/etc/grub2.cfg'
+    grub_unlink = os.path.join(target, 'etc', 'grub2-efi.cfg')
+
+    if util.is_uefi_bootable():
+        grub_cfg = '/boot/efi/EFI/centos/grub.cfg'
+        grub_link = '/etc/grub2-efi.cfg'
+        grub_unlink = os.path.join(target, 'etc', 'grub2.cfg')
+        util.write_file(os.path.join(target, 'boot', 'grub2', 'grub.cfg'),
+                        '# UEFI system, see /etc/grub2-efi.cfg\n')
+
+    with util.RunInChroot(target) as in_chroot:
+        in_chroot(['grub2-mkconfig', '-o', grub_cfg])
+        in_chroot(['ln', '-sf', grub_cfg, grub_link])
+    util.del_file(grub_unlink)
+
+
+def get_uefi_partition():
+    """Return the UEFI partition."""
+    for _, value in block._lsblock().items():
+        if value['LABEL'] == 'uefi-boot':
+            return value
+    return None
+
+
+def install_bootloader(target, device=None):
+    """Installs bootloader to the device."""
+    cmd = []
+    if util.is_uefi_bootable():
+        uefi_dev = get_uefi_partition()['device_path']
+        disk, part = block.get_blockdev_for_partition(uefi_dev)
+        cmd = ['efibootmgr', '-v', '-c', '-w', '-L', 'centos',
+               '-d', disk, '-p', part, '-l', r'\EFI\centos\shim.efi']
+    else:
+        cmd = ['grub2-install', '--recheck', device]
+
+    with util.RunInChroot(target) as in_chroot:
+        in_chroot(cmd)
+
+
+def setup_grub(cfg, target):
+    # target is the path to the mounted filesystem
+
+    # FIXME: these methods need moving to curtin.block
+    # and using them from there rather than commands.block_meta
+    from curtin.commands.block_meta import (extract_storage_ordered_dict,
+                                            get_path_to_storage_volume)
+
+    grubcfg = cfg.get('grub', {})
+
+    # copy legacy top level name
+    if 'grub_install_devices' in cfg and 'install_devices' not in grubcfg:
+        grubcfg['install_devices'] = cfg['grub_install_devices']
+
+    LOG.debug("setup grub on target %s", target)
+    # if there is storage config, look for devices tagged with 'grub_device'
+    storage_cfg_odict = None
+    try:
+        storage_cfg_odict = extract_storage_ordered_dict(cfg)
+    except ValueError as e:
+        pass
+
+    if storage_cfg_odict:
+        storage_grub_devices = []
+        for item_id, item in storage_cfg_odict.items():
+            if not item.get('grub_device'):
+                continue
+            LOG.debug("checking: %s", item)
+            storage_grub_devices.append(
+                get_path_to_storage_volume(item_id, storage_cfg_odict))
+        if len(storage_grub_devices) > 0:
+            grubcfg['install_devices'] = storage_grub_devices
+
+    LOG.debug("install_devices: %s", grubcfg.get('install_devices'))
+    if 'install_devices' in grubcfg:
+        instdevs = grubcfg.get('install_devices')
+        if isinstance(instdevs, str):
+            instdevs = [instdevs]
+        if instdevs is None:
+            LOG.debug("grub installation disabled by config")
+    else:
+        # If there were no install_devices found then we try to do the right
+        # thing.  That right thing is basically installing on all block
+        # devices that are mounted.  On powerpc, though it means finding PrEP
+        # partitions.
+        devs = block.get_devices_for_mp(target)
+        blockdevs = set()
+        for maybepart in devs:
+            try:
+                (blockdev, part) = block.get_blockdev_for_partition(maybepart)
+                blockdevs.add(blockdev)
+            except ValueError as e:
+                # if there is no syspath for this device such as a lvm
+                # or raid device, then a ValueError is raised here.
+                LOG.debug("failed to find block device for %s", maybepart)
+        instdevs = list(blockdevs)
+
+    # UEFI requires additional packages
+    if util.is_uefi_bootable():
+        pkgs = ['grub2-efi', 'shim', 'efibootmgr']
+        install_packages(pkgs, target=target)
+
+    # CentOS will not assemble MD devices on boot without rd.md.uuid=MD_UUID
+    # kernel parameters
+    mdmap = {}
+    rdmduuids = []
+    try:
+        mdmap = mdadm.md_read_run_mdadm_map()
+        for md in mdmap:
+            rdmduuids.append("rd.md.uuid=%s" % mdadm.md_get_uuid(mdmap[md][2]))
+    except ValueError as e:
+        pass
+
+    update_grub_default(target, extra=get_extra_kernel_parameters() + rdmduuids)
+    grub2_mkconfig(target)
+
+    if instdevs:
+        instdevs = [block.get_dev_name_entry(i)[1] for i in instdevs]
+    else:
+        instdevs = ["none"]
+
+    LOG.debug("installing grub to %s", instdevs)
+
+    if util.is_uefi_bootable():
+        if grubcfg.get('update_nvram', False):
+            install_bootloader(target)
+    else:
+        for dev in instdevs:
+            install_bootloader(target, dev)
 
 
 def set_autorelabel(target):
@@ -196,136 +521,75 @@
     open(path, 'a').close()
 
 
-def get_boot_mac():
-    """Return the mac address of the booting interface."""
-    cmdline = read_file('/proc/cmdline')
-    cmdline = cmdline.split()
-    try:
-        bootif = [
-            option
-            for option in cmdline
-            if option.startswith('BOOTIF')
-            ][0]
-    except IndexError:
-        return None
-    _, mac = bootif.split('=')
-    mac = mac.split('-')[1:]
-    return ':'.join(mac)
-
-
-def get_interface_names():
-    """Return a dictionary mapping mac addresses to interface names."""
-    sys_path = "/sys/class/net"
-    ifaces = {}
-    for iname in os.listdir(sys_path):
-        mac = read_file(os.path.join(sys_path, iname, "address"))
-        mac = mac.strip().lower()
-        ifaces[mac] = iname
-    return ifaces
-
-
-def get_ipv4_config(iface, data):
-    """Returns the contents of the interface file for ipv4."""
-    config = [
-        'TYPE="Ethernet"',
-        'NM_CONTROLLED="no"',
-        'USERCTL="yes"',
-        ]
-    if 'hwaddress' in data:
-        config.append('HWADDR="%s"' % data['hwaddress'])
-    # Fallback to using device name
-    else:
-        config.append('DEVICE="%"' % iface)
-    if data['auto']:
-        config.append('ONBOOT="yes"')
-    else:
-        config.append('ONBOOT="no"')
-
-    method = data['method']
-    if method == 'dhcp':
-        config.append('BOOTPROTO="dhcp"')
-        config.append('PEERDNS="yes"')
-        config.append('PERSISTENT_DHCLIENT="1"')
-        if 'hostname' in data:
-            config.append('DHCP_HOSTNAME="%s"' % data['hostname'])
-    elif method == 'static':
-        config.append('BOOTPROTO="none"')
-        config.append('IPADDR="%s"' % data['address'])
-        config.append('NETMASK="%s"' % data['netmask'])
-        if 'broadcast' in data:
-            config.append('BROADCAST="%s"' % data['broadcast'])
-        if 'gateway' in data:
-            config.append('GATEWAY="%s"' % data['gateway'])
-    elif method == 'manual':
-        config.append('BOOTPROTO="none"')
-    return '\n'.join(config)
-
-
-def write_interface_config(target, iface, data):
-    """Writes config for interface."""
-    family = data['family']
-    if family != "inet":
-        # Only supporting ipv4 currently
-        print(
-            "WARN: unsupported family %s, "
-            "failed to configure interface: %s" (family, iface))
-        return
-    config = get_ipv4_config(iface, data)
-    path = os.path.join(
-        target, 'etc', 'sysconfig', 'network-scripts', 'ifcfg-%s' % iface)
-    with open(path, 'w') as stream:
-        stream.write(config + '\n')
-
-
-def write_network_config(target, mac):
-    """Write network configuration for the given MAC address."""
-    inames = get_interface_names()
-    iname = inames[mac.lower()]
-    write_interface_config(
-        target, iname, {
-            'family': 'inet',
-            'hwaddress': mac.upper(),
-            'auto': True,
-            'method': 'dhcp'
-        })
-
-
 def main():
     state = util.load_command_environment()
+
     target = state['target']
     if target is None:
-        print("Target was not provided in the environment.")
-        sys.exit(1)
-    fstab = state['fstab']
-    if fstab is None:
-        print("/etc/fstab output was not provided in the environment.")
-        sys.exit(1)
-    bootmac = get_boot_mac()
-    if bootmac is None:
-        print("Unable to determine boot interface.")
-        sys.exit(1)
-    devices = get_block_devices(target)
-    if not devices:
-        print("Unable to find block device for: %s" % target)
-        sys.exit(1)
-
-    write_fstab(target, fstab)
-
-    update_grub_default(
-        target, extra=get_extra_kernel_parameters())
-    grub2_mkconfig(target)
-    if util.is_uefi_bootable():
-        uefi_part = get_uefi_partition()
-        if uefi_part is None:
-            print('Unable to determine UEFI parition.')
-            sys.exit(1)
-        install_efi(target, uefi_part['device_path'])
-    else:
-        for dev in devices:
-            grub2_install(target, dev)
+        sys.stderr.write("Target was not provided in the environment.")
+        sys.exit(1)
+
+    cfg = config.load_command_config(None, state)
+    stack_prefix = state.get('report_stack_prefix', '')
+
+    with events.ReportEventStack(
+            name=stack_prefix, reporting_enabled=True, level="INFO",
+            description="writing config files"):
+        curthooks.write_files(cfg, target)
+
+    # Default CentOS image does not contain some packages that may be necessary
+    install_missing_packages(cfg, target)
+
+    # If a mdadm.conf file was created by block_meta then it needs to be copied
+    # onto the target system
+    mdadm_location = os.path.join(os.path.split(state['fstab'])[0],
+                                  "mdadm.conf")
+    if os.path.exists(mdadm_location):
+        copy_mdadm_conf(mdadm_location, target)
+
+    with events.ReportEventStack(
+            name=stack_prefix, reporting_enabled=True, level="INFO",
+            description="setting up swap"):
+        curthooks.add_swap(cfg, target, state.get('fstab'))
+
+    with events.ReportEventStack(
+            name=stack_prefix, reporting_enabled=True, level="INFO",
+            description="writing etc/fstab"):
+        curthooks.copy_fstab(state.get('fstab'), target)
+
+    # TODO. There's a multipath implementation on Ubuntu in curtin/curthooks.py
+    # that should be reimplemented here. Skipping for now.
+
+    with events.ReportEventStack(
+            name=stack_prefix, reporting_enabled=True, level="INFO",
+            description="updating packages on target system"):
+        system_upgrade(cfg, target)
+
+    # TODO. If a crypttab file was created by block_meta than it needs to be 
+    # copied onto the target system, and update_initramfs() (well, alternative 
+    # for CentOS actually) needs to be run, so that the cryptsetup hooks are 
+    # properly configured on the installed system and it will be able to open 
+    # encrypted volumes at boot. Skipping for now.
+
+    with events.ReportEventStack(
+            name=stack_prefix, reporting_enabled=True, level="INFO",
+            description="apply networking"):
+        apply_networking(cfg, target)
+
+    # If udev dname rules were created, copy them to target
+    udev_rules_d = os.path.join(state['scratch'], "rules.d")
+    if os.path.isdir(udev_rules_d):
+        curthooks.copy_dname_rules(udev_rules_d, target)
+
+    with events.ReportEventStack(
+            name=stack_prefix, reporting_enabled=True, level="INFO",
+            description="updating packages on target system"):
+        setup_grub(cfg, target)
 
     set_autorelabel(target)
-    write_network_config(target, bootmac)
+    update_initramfs(target)
+
+    sys.exit(0)
 
 
 if __name__ == "__main__":