merge from trunk

14 files changed, 484 insertions, 89 deletions

diff --git a/cloudinit/config/__init__.py b/cloudinit/config/__init__.py
index 69a8cc68..d57453be 100644
--- a/cloudinit/config/__init__.py
+++ b/cloudinit/config/__init__.py
@@ -52,5 +52,7 @@ def fixup_module(mod, def_freq=PER_INSTANCE):
         if freq and freq not in FREQUENCIES:
             LOG.warn("Module %s has an unknown frequency %s", mod, freq)
     if not hasattr(mod, 'distros'):
-        setattr(mod, 'distros', None)
+        setattr(mod, 'distros', [])
+    if not hasattr(mod, 'osfamilies'):
+        setattr(mod, 'osfamilies', [])
     return mod
diff --git a/cloudinit/config/cc_apt_configure.py b/cloudinit/config/cc_apt_configure.py
index f8664160..3ce3b351 100644
--- a/cloudinit/config/cc_apt_configure.py
+++ b/cloudinit/config/cc_apt_configure.py
@@ -140,10 +140,13 @@ def get_release():
 
 
 def generate_sources_list(codename, mirrors, cloud, log):
-    template_fn = cloud.get_template_filename('sources.list')
+    template_fn = cloud.get_template_filename('sources.list.%s' %
+                                              (cloud.distro.name))
     if not template_fn:
-        log.warn("No template found, not rendering /etc/apt/sources.list")
-        return
+        template_fn = cloud.get_template_filename('sources.list')
+        if not template_fn:
+            log.warn("No template found, not rendering /etc/apt/sources.list")
+            return
 
     params = {'codename': codename}
     for k in mirrors:
diff --git a/cloudinit/config/cc_ca_certs.py b/cloudinit/config/cc_ca_certs.py
index 20f24357..4f2a46a1 100644
--- a/cloudinit/config/cc_ca_certs.py
+++ b/cloudinit/config/cc_ca_certs.py
@@ -45,8 +45,15 @@ def add_ca_certs(certs):
         # First ensure they are strings...
         cert_file_contents = "\n".join([str(c) for c in certs])
         util.write_file(CA_CERT_FULL_PATH, cert_file_contents, mode=0644)
+
         # Append cert filename to CA_CERT_CONFIG file.
-        util.write_file(CA_CERT_CONFIG, "\n%s" % CA_CERT_FILENAME, omode="ab")
+        # We have to strip the content because blank lines in the file
+        # causes subsequent entries to be ignored. (LP: #1077020)
+        orig = util.load_file(CA_CERT_CONFIG)
+        cur_cont = '\n'.join([l for l in orig.splitlines()
+                              if l != CA_CERT_FILENAME])
+        out = "%s\n%s\n" % (cur_cont.rstrip(), CA_CERT_FILENAME)
+        util.write_file(CA_CERT_CONFIG, out, omode="wb")
 
 
 def remove_default_ca_certs():
diff --git a/cloudinit/config/cc_chef.py b/cloudinit/config/cc_chef.py
index 7a3d6a31..607f789e 100644
--- a/cloudinit/config/cc_chef.py
+++ b/cloudinit/config/cc_chef.py
@@ -22,6 +22,7 @@ import json
 import os
 
 from cloudinit import templater
+from cloudinit import url_helper
 from cloudinit import util
 
 RUBY_VERSION_DEFAULT = "1.8"
@@ -35,6 +36,8 @@ CHEF_DIRS = [
     '/var/run/chef',
 ]
 
+OMNIBUS_URL = "https://www.opscode.com/chef/install.sh"
+
 
 def handle(name, cfg, cloud, log, _args):
 
@@ -83,7 +86,9 @@ def handle(name, cfg, cloud, log, _args):
     util.write_file('/etc/chef/firstboot.json', json.dumps(initial_json))
 
     # If chef is not installed, we install chef based on 'install_type'
-    if not os.path.isfile('/usr/bin/chef-client'):
+    if (not os.path.isfile('/usr/bin/chef-client') or
+        util.get_cfg_option_bool(chef_cfg, 'force_install', default=False)):
+
         install_type = util.get_cfg_option_str(chef_cfg, 'install_type',
                                                'packages')
         if install_type == "gems":
@@ -99,6 +104,14 @@ def handle(name, cfg, cloud, log, _args):
         elif install_type == 'packages':
             # this will install and run the chef-client from packages
             cloud.distro.install_packages(('chef',))
+        elif install_type == 'omnibus':
+            url = util.get_cfg_option_str(chef_cfg, "omnibus_url", OMNIBUS_URL)
+            content = url_helper.readurl(url=url, retries=5)
+            with util.tempdir() as tmpd:
+                # use tmpd over tmpfile to avoid 'Text file busy' on execute
+                tmpf = "%s/chef-omnibus-install" % tmpd
+                util.write_file(tmpf, content, mode=0700)
+                util.subp([tmpf], capture=False)
         else:
             log.warn("Unknown chef install type %s", install_type)
 
diff --git a/cloudinit/config/cc_growpart.py b/cloudinit/config/cc_growpart.py
new file mode 100644
index 00000000..b6e1fd37
--- /dev/null
+++ b/cloudinit/config/cc_growpart.py
@@ -0,0 +1,272 @@
+# vi: ts=4 expandtab
+#
+#    Copyright (C) 2011 Canonical Ltd.
+#
+#    Author: Scott Moser <scott.moser@canonical.com>
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License version 3, as
+#    published by the Free Software Foundation.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import os
+import os.path
+import re
+import stat
+
+from cloudinit import log as logging
+from cloudinit.settings import PER_ALWAYS
+from cloudinit import util
+
+frequency = PER_ALWAYS
+
+DEFAULT_CONFIG = {
+    'mode': 'auto',
+    'devices': ['/'],
+}
+
+
+def enum(**enums):
+    return type('Enum', (), enums)
+
+
+RESIZE = enum(SKIPPED="SKIPPED", CHANGED="CHANGED", NOCHANGE="NOCHANGE",
+              FAILED="FAILED")
+
+LOG = logging.getLogger(__name__)
+
+
+def resizer_factory(mode):
+    resize_class = None
+    if mode == "auto":
+        for (_name, resizer) in RESIZERS:
+            cur = resizer()
+            if cur.available():
+                resize_class = cur
+                break
+
+        if not resize_class:
+            raise ValueError("No resizers available")
+
+    else:
+        mmap = {}
+        for (k, v) in RESIZERS:
+            mmap[k] = v
+
+        if mode not in mmap:
+            raise TypeError("unknown resize mode %s" % mode)
+
+        mclass = mmap[mode]()
+        if mclass.available():
+            resize_class = mclass
+
+        if not resize_class:
+            raise ValueError("mode %s not available" % mode)
+
+    return resize_class
+
+
+class ResizeFailedException(Exception):
+    pass
+
+
+class ResizeParted(object):
+    def available(self):
+        myenv = os.environ.copy()
+        myenv['LANG'] = 'C'
+
+        try:
+            (out, _err) = util.subp(["parted", "--help"], env=myenv)
+            if re.search(r"COMMAND.*resizepart\s+", out, re.DOTALL):
+                return True
+
+        except util.ProcessExecutionError:
+            pass
+        return False
+
+    def resize(self, diskdev, partnum, partdev):
+        before = get_size(partdev)
+        try:
+            util.subp(["parted", "resizepart", diskdev, partnum])
+        except util.ProcessExecutionError as e:
+            raise ResizeFailedException(e)
+
+        return (before, get_size(partdev))
+
+
+class ResizeGrowPart(object):
+    def available(self):
+        myenv = os.environ.copy()
+        myenv['LANG'] = 'C'
+
+        try:
+            (out, _err) = util.subp(["growpart", "--help"], env=myenv)
+            if re.search(r"--update\s+", out, re.DOTALL):
+                return True
+
+        except util.ProcessExecutionError:
+            pass
+        return False
+
+    def resize(self, diskdev, partnum, partdev):
+        before = get_size(partdev)
+        try:
+            util.subp(["growpart", '--dry-run', diskdev, partnum])
+        except util.ProcessExecutionError as e:
+            if e.exit_code != 1:
+                util.logexc(LOG, ("Failed growpart --dry-run for (%s, %s)" %
+                                  (diskdev, partnum)))
+                raise ResizeFailedException(e)
+            return (before, before)
+
+        try:
+            util.subp(["growpart", diskdev, partnum])
+        except util.ProcessExecutionError as e:
+            util.logexc(LOG, "Failed: growpart %s %s" % (diskdev, partnum))
+            raise ResizeFailedException(e)
+
+        return (before, get_size(partdev))
+
+
+def get_size(filename):
+    fd = os.open(filename, os.O_RDONLY)
+    try:
+        return os.lseek(fd, 0, os.SEEK_END)
+    finally:
+        os.close(fd)
+
+
+def device_part_info(devpath):
+    # convert an entry in /dev/ to parent disk and partition number
+
+    # input of /dev/vdb or /dev/disk/by-label/foo
+    # rpath is hopefully a real-ish path in /dev (vda, sdb..)
+    rpath = os.path.realpath(devpath)
+
+    bname = os.path.basename(rpath)
+    syspath = "/sys/class/block/%s" % bname
+
+    if not os.path.exists(syspath):
+        raise ValueError("%s had no syspath (%s)" % (devpath, syspath))
+
+    ptpath = os.path.join(syspath, "partition")
+    if not os.path.exists(ptpath):
+        raise TypeError("%s not a partition" % devpath)
+
+    ptnum = util.load_file(ptpath).rstrip()
+
+    # for a partition, real syspath is something like:
+    # /sys/devices/pci0000:00/0000:00:04.0/virtio1/block/vda/vda1
+    rsyspath = os.path.realpath(syspath)
+    disksyspath = os.path.dirname(rsyspath)
+
+    diskmajmin = util.load_file(os.path.join(disksyspath, "dev")).rstrip()
+    diskdevpath = os.path.realpath("/dev/block/%s" % diskmajmin)
+
+    # diskdevpath has something like 253:0
+    # and udev has put links in /dev/block/253:0 to the device name in /dev/
+    return (diskdevpath, ptnum)
+
+
+def devent2dev(devent):
+    if devent.startswith("/dev/"):
+        return devent
+    else:
+        result = util.get_mount_info(devent)
+        if not result:
+            raise ValueError("Could not determine device of '%s' % dev_ent")
+        return result[0]
+
+
+def resize_devices(resizer, devices):
+    # returns a tuple of tuples containing (entry-in-devices, action, message)
+    info = []
+    for devent in devices:
+        try:
+            blockdev = devent2dev(devent)
+        except ValueError as e:
+            info.append((devent, RESIZE.SKIPPED,
+                         "unable to convert to device: %s" % e,))
+            continue
+
+        try:
+            statret = os.stat(blockdev)
+        except OSError as e:
+            info.append((devent, RESIZE.SKIPPED,
+                         "stat of '%s' failed: %s" % (blockdev, e),))
+            continue
+
+        if not stat.S_ISBLK(statret.st_mode):
+            info.append((devent, RESIZE.SKIPPED,
+                         "device '%s' not a block device" % blockdev,))
+            continue
+
+        try:
+            (disk, ptnum) = device_part_info(blockdev)
+        except (TypeError, ValueError) as e:
+            info.append((devent, RESIZE.SKIPPED,
+                         "device_part_info(%s) failed: %s" % (blockdev, e),))
+            continue
+
+        try:
+            (old, new) = resizer.resize(disk, ptnum, blockdev)
+            if old == new:
+                info.append((devent, RESIZE.NOCHANGE,
+                             "no change necessary (%s, %s)" % (disk, ptnum),))
+            else:
+                info.append((devent, RESIZE.CHANGED,
+                             "changed (%s, %s) from %s to %s" %
+                             (disk, ptnum, old, new),))
+
+        except ResizeFailedException as e:
+            info.append((devent, RESIZE.FAILED,
+                         "failed to resize: disk=%s, ptnum=%s: %s" %
+                         (disk, ptnum, e),))
+
+    return info
+
+
+def handle(_name, cfg, _cloud, log, _args):
+    if 'growpart' not in cfg:
+        log.debug("No 'growpart' entry in cfg.  Using default: %s" %
+                  DEFAULT_CONFIG)
+        cfg['growpart'] = DEFAULT_CONFIG
+
+    mycfg = cfg.get('growpart')
+    if not isinstance(mycfg, dict):
+        log.warn("'growpart' in config was not a dict")
+        return
+
+    mode = mycfg.get('mode', "auto")
+    if util.is_false(mode):
+        log.debug("growpart disabled: mode=%s" % mode)
+        return
+
+    devices = util.get_cfg_option_list(cfg, "devices", ["/"])
+    if not len(devices):
+        log.debug("growpart: empty device list")
+        return
+
+    try:
+        resizer = resizer_factory(mode)
+    except (ValueError, TypeError) as e:
+        log.debug("growpart unable to find resizer for '%s': %s" % (mode, e))
+        if mode != "auto":
+            raise e
+        return
+
+    resized = resize_devices(resizer, devices)
+    for (entry, action, msg) in resized:
+        if action == RESIZE.CHANGED:
+            log.info("'%s' resized: %s" % (entry, msg))
+        else:
+            log.debug("'%s' %s: %s" % (entry, action, msg))
+
+RESIZERS = (('parted', ResizeParted), ('growpart', ResizeGrowPart))
diff --git a/cloudinit/config/cc_landscape.py b/cloudinit/config/cc_landscape.py
index 6734efee..47c10a97 100644
--- a/cloudinit/config/cc_landscape.py
+++ b/cloudinit/config/cc_landscape.py
@@ -63,7 +63,7 @@ def handle(_name, cfg, cloud, log, _args):
     if not ls_cloudcfg:
         return
 
-    cloud.distro.install_packages(["landscape-client"])
+    cloud.distro.install_packages(('landscape-client',))
 
     merge_data = [
         LSC_BUILTIN_CFG,
diff --git a/cloudinit/config/cc_mounts.py b/cloudinit/config/cc_mounts.py
index 6ebe563d..390ba711 100644
--- a/cloudinit/config/cc_mounts.py
+++ b/cloudinit/config/cc_mounts.py
@@ -25,8 +25,8 @@ import re
 from cloudinit import type_utils
 from cloudinit import util
 
-# Shortname matches 'sda', 'sda1', 'xvda', 'hda', 'sdb', xvdb, vda, vdd1
-SHORTNAME_FILTER = r"^[x]{0,1}[shv]d[a-z][0-9]*$"
+# Shortname matches 'sda', 'sda1', 'xvda', 'hda', 'sdb', xvdb, vda, vdd1, sr0
+SHORTNAME_FILTER = r"^([x]{0,1}[shv]d[a-z][0-9]*|sr[0-9]+)$"
 SHORTNAME = re.compile(SHORTNAME_FILTER)
 WS = re.compile("[%s]+" % (whitespace))
 FSTAB_PATH = "/etc/fstab"
diff --git a/cloudinit/config/cc_power_state_change.py b/cloudinit/config/cc_power_state_change.py
index aefa3aff..de0c0bbd 100644
--- a/cloudinit/config/cc_power_state_change.py
+++ b/cloudinit/config/cc_power_state_change.py
@@ -75,7 +75,7 @@ def load_power_state(cfg):
                         ','.join(opt_map.keys()))
 
     delay = pstate.get("delay", "now")
-    if delay != "now" and not re.match("\+[0-9]+", delay):
+    if delay != "now" and not re.match(r"\+[0-9]+", delay):
         raise TypeError("power_state[delay] must be 'now' or '+m' (minutes).")
 
     args = ["shutdown", opt_map[mode], delay]
diff --git a/cloudinit/config/cc_puppet.py b/cloudinit/config/cc_puppet.py
index 8fe3af57..471a1a8a 100644
--- a/cloudinit/config/cc_puppet.py
+++ b/cloudinit/config/cc_puppet.py
@@ -57,8 +57,16 @@ def handle(name, cfg, cloud, log, _args):
 
     puppet_cfg = cfg['puppet']
 
-    # Start by installing the puppet package ...
-    cloud.distro.install_packages(["puppet"])
+    # Start by installing the puppet package if necessary...
+    install = util.get_cfg_option_bool(puppet_cfg, 'install', True)
+    version = util.get_cfg_option_str(puppet_cfg, 'version', None)
+    if not install and version:
+        log.warn(("Puppet install set false but version supplied,"
+                  " doing nothing."))
+    elif install:
+        log.debug(("Attempting to install puppet %s,"),
+                   version if version else 'latest')
+        cloud.distro.install_packages(('puppet', version))
 
     # ... and then update the puppet configuration
     if 'conf' in puppet_cfg:
diff --git a/cloudinit/config/cc_resizefs.py b/cloudinit/config/cc_resizefs.py
index 70294eda..51dead2f 100644
--- a/cloudinit/config/cc_resizefs.py
+++ b/cloudinit/config/cc_resizefs.py
@@ -27,41 +27,28 @@ from cloudinit import util
 
 frequency = PER_ALWAYS
 
-RESIZE_FS_PREFIXES_CMDS = [
-    ('ext', 'resize2fs'),
-    ('xfs', 'xfs_growfs'),
-]
 
-NOBLOCK = "noblock"
+def _resize_btrfs(mount_point, devpth):  # pylint: disable=W0613
+    return ('btrfs', 'filesystem', 'resize', 'max', mount_point)
 
 
-def nodeify_path(devpth, where, log):
-    try:
-        st_dev = os.stat(where).st_dev
-        dev = os.makedev(os.major(st_dev), os.minor(st_dev))
-        os.mknod(devpth, 0400 | stat.S_IFBLK, dev)
-        return st_dev
-    except:
-        if util.is_container():
-            log.debug("Inside container, ignoring mknod failure in resizefs")
-            return
-        log.warn("Failed to make device node to resize %s at %s",
-                 where, devpth)
-        raise
+def _resize_ext(mount_point, devpth):  # pylint: disable=W0613
+    return ('resize2fs', devpth)
 
 
-def get_fs_type(st_dev, path, log):
-    try:
-        dev_entries = util.find_devs_with(tag='TYPE', oformat='value',
-                                         no_cache=True, path=path)
-        if not dev_entries:
-            return None
-        return dev_entries[0].strip()
-    except util.ProcessExecutionError:
-        util.logexc(log, ("Failed to get filesystem type"
-                          " of maj=%s, min=%s for path %s"),
-                    os.major(st_dev), os.minor(st_dev), path)
-        raise
+def _resize_xfs(mount_point, devpth):  # pylint: disable=W0613
+    return ('xfs_growfs', devpth)
+
+# Do not use a dictionary as these commands should be able to be used
+# for multiple filesystem types if possible, e.g. one command for
+# ext2, ext3 and ext4.
+RESIZE_FS_PREFIXES_CMDS = [
+    ('btrfs', _resize_btrfs),
+    ('ext', _resize_ext),
+    ('xfs', _resize_xfs),
+]
+
+NOBLOCK = "noblock"
 
 
 def handle(name, cfg, _cloud, log, args):
@@ -80,52 +67,47 @@ def handle(name, cfg, _cloud, log, args):
 
     # TODO(harlowja): allow what is to be resized to be configurable??
     resize_what = "/"
-    with util.ExtendedTemporaryFile(prefix="cloudinit.resizefs.",
-                                    dir=resize_root_d, delete=True) as tfh:
-        devpth = tfh.name
-
-        # Delete the file so that mknod will work
-        # but don't change the file handle to know that its
-        # removed so that when a later call that recreates
-        # occurs this temporary file will still benefit from
-        # auto deletion
-        tfh.unlink_now()
-
-        st_dev = nodeify_path(devpth, resize_what, log)
-        fs_type = get_fs_type(st_dev, devpth, log)
-        if not fs_type:
-            log.warn("Could not determine filesystem type of %s", resize_what)
-            return
-
-        resizer = None
-        fstype_lc = fs_type.lower()
-        for (pfix, root_cmd) in RESIZE_FS_PREFIXES_CMDS:
-            if fstype_lc.startswith(pfix):
-                resizer = root_cmd
-                break
-
-        if not resizer:
-            log.warn("Not resizing unknown filesystem type %s for %s",
-                     fs_type, resize_what)
-            return
-
-        log.debug("Resizing %s (%s) using %s", resize_what, fs_type, resizer)
-        resize_cmd = [resizer, devpth]
-
-        if resize_root == NOBLOCK:
-            # Fork to a child that will run
-            # the resize command
-            util.fork_cb(do_resize, resize_cmd, log)
-            # Don't delete the file now in the parent
-            tfh.delete = False
-        else:
-            do_resize(resize_cmd, log)
+    result = util.get_mount_info(resize_what, log)
+    if not result:
+        log.warn("Could not determine filesystem type of %s", resize_what)
+        return
+
+    (devpth, fs_type, mount_point) = result
+
+    # Ensure the path is a block device.
+    if not stat.S_ISBLK(os.stat(devpth).st_mode):
+        log.debug("The %s device which was found for mount point %s for %s "
+                  "is not a block device" % (devpth, mount_point, resize_what))
+        return
+
+    resizer = None
+    fstype_lc = fs_type.lower()
+    for (pfix, root_cmd) in RESIZE_FS_PREFIXES_CMDS:
+        if fstype_lc.startswith(pfix):
+            resizer = root_cmd
+            break
+
+    if not resizer:
+        log.warn("Not resizing unknown filesystem type %s for %s",
+                 fs_type, resize_what)
+        return
+
+    resize_cmd = resizer(resize_what, devpth)
+    log.debug("Resizing %s (%s) using %s", resize_what, fs_type,
+              ' '.join(resize_cmd))
+
+    if resize_root == NOBLOCK:
+        # Fork to a child that will run
+        # the resize command
+        util.fork_cb(do_resize, resize_cmd, log)
+    else:
+        do_resize(resize_cmd, log)
 
     action = 'Resized'
     if resize_root == NOBLOCK:
         action = 'Resizing (via forking)'
-    log.debug("%s root filesystem (type=%s, maj=%i, min=%i, val=%s)",
-              action, fs_type, os.major(st_dev), os.minor(st_dev), resize_root)
+    log.debug("%s root filesystem (type=%s, val=%s)", action, fs_type,
+              resize_root)
 
 
 def do_resize(resize_cmd, log):
diff --git a/cloudinit/config/cc_resolv_conf.py b/cloudinit/config/cc_resolv_conf.py
new file mode 100644
index 00000000..8a460f7e
--- /dev/null
+++ b/cloudinit/config/cc_resolv_conf.py
@@ -0,0 +1,107 @@
+# vi: ts=4 expandtab
+#
+#    Copyright (C) 2013 Craig Tracey
+#
+#    Author: Craig Tracey <craigtracey@gmail.com>
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License version 3, as
+#    published by the Free Software Foundation.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#    Note:
+#    This module is intended to manage resolv.conf in environments where
+#    early configuration of resolv.conf is necessary for further
+#    bootstrapping and/or where configuration management such as puppet or
+#    chef own dns configuration. As Debian/Ubuntu will, by default, utilize
+#    resovlconf, and similarly RedHat will use sysconfig, this module is
+#    likely to be of little use unless those are configured correctly.
+#
+#    For RedHat with sysconfig, be sure to set PEERDNS=no for all DHCP
+#    enabled NICs.  And, in Ubuntu/Debian it is recommended that DNS
+#    be configured via the standard /etc/network/interfaces configuration
+#    file.
+#
+#
+#    Usage Example:
+#
+#    #cloud-config
+#    manage_resolv_conf: true
+#
+#    resolv_conf:
+#      nameservers: ['8.8.4.4', '8.8.8.8']
+#      searchdomains:
+#        - foo.example.com
+#        - bar.example.com
+#      domain: example.com
+#      options:
+#        rotate: true
+#        timeout: 1
+#
+
+
+from cloudinit.settings import PER_INSTANCE
+from cloudinit import templater
+from cloudinit import util
+
+frequency = PER_INSTANCE
+
+distros = ['fedora', 'rhel']
+
+
+def generate_resolv_conf(cloud, log, params):
+    template_fn = cloud.get_template_filename('resolv.conf')
+    if not template_fn:
+        log.warn("No template found, not rendering /etc/resolv.conf")
+        return
+
+    flags = []
+    false_flags = []
+    if 'options' in params:
+        for key, val in params['options'].iteritems():
+            if type(val) == bool:
+                if val:
+                    flags.append(key)
+                else:
+                    false_flags.append(key)
+
+    for flag in flags + false_flags:
+        del params['options'][flag]
+
+    params['flags'] = flags
+    log.debug("Writing resolv.conf from template %s" % template_fn)
+    templater.render_to_file(template_fn, '/etc/resolv.conf', params)
+
+
+def handle(name, cfg, _cloud, log, _args):
+    """
+    Handler for resolv.conf
+
+    @param name: The module name "resolv-conf" from cloud.cfg
+    @param cfg: A nested dict containing the entire cloud config contents.
+    @param cloud: The L{CloudInit} object in use.
+    @param log: Pre-initialized Python logger object to use for logging.
+    @param args: Any module arguments from cloud.cfg
+    """
+    if "manage_resolv_conf" not in cfg:
+        log.debug(("Skipping module named %s,"
+                   " no 'manage_resolv_conf' key in configuration"), name)
+        return
+
+    if not util.get_cfg_option_bool(cfg, "manage_resolv_conf", False):
+        log.debug(("Skipping module named %s,"
+                   " 'manage_resolv_conf' present but set to False"), name)
+        return
+
+    if not "resolv_conf" in cfg:
+        log.warn("manage_resolv_conf True but no parameters provided!")
+
+    generate_resolv_conf(_cloud, log, cfg["resolv_conf"])
+    return
diff --git a/cloudinit/config/cc_salt_minion.py b/cloudinit/config/cc_salt_minion.py
index f3eede18..53013dcb 100644
--- a/cloudinit/config/cc_salt_minion.py
+++ b/cloudinit/config/cc_salt_minion.py
@@ -31,7 +31,7 @@ def handle(name, cfg, cloud, log, _args):
     salt_cfg = cfg['salt_minion']
 
     # Start by installing the salt package ...
-    cloud.distro.install_packages(["salt-minion"])
+    cloud.distro.install_packages(('salt-minion',))
 
     # Ensure we can configure files at the right dir
     config_dir = salt_cfg.get("config_dir", '/etc/salt')
diff --git a/cloudinit/config/cc_ssh.py b/cloudinit/config/cc_ssh.py
index b623d476..7ef20d9f 100644
--- a/cloudinit/config/cc_ssh.py
+++ b/cloudinit/config/cc_ssh.py
@@ -126,7 +126,7 @@ def apply_credentials(keys, user, disable_root, disable_root_opts):
 
     keys = set(keys)
     if user:
-        ssh_util.setup_user_keys(keys, user, '')
+        ssh_util.setup_user_keys(keys, user)
 
     if disable_root:
         if not user:
@@ -135,4 +135,4 @@ def apply_credentials(keys, user, disable_root, disable_root_opts):
     else:
         key_prefix = ''
 
-    ssh_util.setup_user_keys(keys, 'root', key_prefix)
+    ssh_util.setup_user_keys(keys, 'root', options=key_prefix)
diff --git a/cloudinit/config/cc_update_etc_hosts.py b/cloudinit/config/cc_update_etc_hosts.py
index 96103615..d3dd1f32 100644
--- a/cloudinit/config/cc_update_etc_hosts.py
+++ b/cloudinit/config/cc_update_etc_hosts.py
@@ -37,10 +37,11 @@ def handle(name, cfg, cloud, log, _args):
 
         # Render from a template file
         tpl_fn_name = cloud.get_template_filename("hosts.%s" %
-                                                  (cloud.distro.name))
+                                                  (cloud.distro.osfamily))
         if not tpl_fn_name:
             raise RuntimeError(("No hosts template could be"
-                                " found for distro %s") % (cloud.distro.name))
+                                " found for distro %s") %
+                                (cloud.distro.osfamily))
 
         templater.render_to_file(tpl_fn_name, '/etc/hosts',
                                 {'hostname': hostname, 'fqdn': fqdn})