From 81ca0bc300ac5d8b8c0498727132e82dab72a396 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Mon, 30 Jan 2012 09:24:30 -0500
Subject: netinfo.py: minor pylint complaint on unused 'devname'

---
 cloudinit/netinfo.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cloudinit/netinfo.py b/cloudinit/netinfo.py
index 80223256..7e07812e 100644
--- a/cloudinit/netinfo.py
+++ b/cloudinit/netinfo.py
@@ -61,7 +61,7 @@ def netdev_info(empty=""):
                     devs[curdev][target] = toks[i][len(field) + 1:]
 
     if empty != "":
-        for (devname, dev) in devs.iteritems():
+        for (_devname, dev) in devs.iteritems():
             for field in dev:
                 if dev[field] == "":
                     dev[field] = empty
-- 
cgit v1.2.3


From fb2fb2ff30db6f1f06f15974a6f6be5c5ed518a6 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Mon, 30 Jan 2012 09:24:41 -0500
Subject: support empty lines in '#include' files (LP: #923043)

LP: #923043
---
 ChangeLog                    | 1 +
 cloudinit/UserDataHandler.py | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/ChangeLog b/ChangeLog
index cc43aaad..bdba748e 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -21,6 +21,7 @@
  - fix pylint warnings [Juerg Haefliger] (LP: #914739)
  - add support for adding and deleting CA Certificates [Mike Milner] (LP: #915232)
  - in ci-info lines, use '.' to indicate empty field for easier machine reading
+ - support empty lines in "#include" files (LP: #923043)
 0.6.2:
  - fix bug where update was not done unless update was explicitly set.
    It would not be run if 'upgrade' or packages were set to be installed
diff --git a/cloudinit/UserDataHandler.py b/cloudinit/UserDataHandler.py
index 93d1d36a..98729056 100644
--- a/cloudinit/UserDataHandler.py
+++ b/cloudinit/UserDataHandler.py
@@ -71,6 +71,8 @@ def do_include(content, appendmsg):
             line = line[len("#include"):].lstrip()
         if line.startswith("#"):
             continue
+        if line.strip() == "":
+            continue
 
         # urls cannot not have leading or trailing white space
         msum = hashlib.md5()  # pylint: disable=E1101
-- 
cgit v1.2.3


From 16fd813d8543dd629346e81c4043411c32b7d9d1 Mon Sep 17 00:00:00 2001
From: Jeff Bauer <jbauer@rubic.com>
Date: Sat, 11 Feb 2012 09:27:14 -0600
Subject: add support for salt minions

---
 cloudinit/CloudConfig/cc_salt_minion.py   | 55 +++++++++++++++++++++++++++++++
 doc/examples/cloud-config-salt-minion.txt | 53 +++++++++++++++++++++++++++++
 2 files changed, 108 insertions(+)
 create mode 100644 cloudinit/CloudConfig/cc_salt_minion.py
 create mode 100644 doc/examples/cloud-config-salt-minion.txt

diff --git a/cloudinit/CloudConfig/cc_salt_minion.py b/cloudinit/CloudConfig/cc_salt_minion.py
new file mode 100644
index 00000000..9a710e72
--- /dev/null
+++ b/cloudinit/CloudConfig/cc_salt_minion.py
@@ -0,0 +1,55 @@
+# vi: ts=4 expandtab
+#
+#    Author: Jeff Bauer <jbauer@rubic.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 subprocess
+import cloudinit.CloudConfig as cc
+import yaml
+
+def handle(_name, cfg, cloud, log, _args):
+    # If there isn't a salt key in the configuration don't do anything
+    if 'salt_minion' not in cfg:
+        return
+    salt_cfg = cfg['salt_minion']
+    # Start by installing the salt package ...
+    cc.install_packages(("salt",))
+    config_dir = '/etc/salt'
+    if not os.path.isdir(config_dir):
+        os.makedirs(config_dir)
+    # ... and then update the salt configuration
+    if 'conf' in salt_cfg:
+        # Add all sections from the conf object to /etc/salt/minion
+        minion_config = os.path.join(config_dir, 'minion')
+        yaml.dump(salt_cfg['conf'],
+                  file(minion_config, 'w'),
+                  default_flow_style=False)
+    # ... copy the key pair if specified
+    if 'public_key' in salt_cfg and 'private_key' in salt_cfg:
+        pki_dir = '/etc/salt/pki'
+        cumask = os.umask(077)
+        if not os.path.isdir(pki_dir):
+            os.makedirs(pki_dir)
+        pub_name = os.path.join(pki_dir, 'minion.pub')
+        pem_name = os.path.join(pki_dir, 'minion.pem')
+        with open(pub_name, 'w') as f:
+            f.write(salt_cfg['public_key'])
+        with open(pem_name, 'w') as f:
+            f.write(salt_cfg['private_key'])
+        os.umask(cumask)
+
+    # Start salt-minion
+    subprocess.check_call(['service', 'salt-minion', 'start'])
diff --git a/doc/examples/cloud-config-salt-minion.txt b/doc/examples/cloud-config-salt-minion.txt
new file mode 100644
index 00000000..939fdc8b
--- /dev/null
+++ b/doc/examples/cloud-config-salt-minion.txt
@@ -0,0 +1,53 @@
+#cloud-config
+#
+# This is an example file to automatically setup and run a salt
+# minion when the instance boots for the first time.
+# Make sure that this file is valid yaml before starting instances.
+# It should be passed as user-data when starting the instance.
+
+salt_minion:
+  # conf contains all the directives to be assigned in /etc/salt/minion.
+
+  conf:
+    # Set the location of the salt master server, if the master server cannot be
+    # resolved, then the minion will fail to start.
+
+    master: salt.example.com
+
+  # Salt keys are manually generated by: salt-key --gen-keys=GEN_KEYS,
+  # where GEN_KEYS is the name of the keypair, e.g. 'minion'.  The keypair
+  # will be copied to /etc/salt/pki on the minion instance.
+
+  public_key: |
+    -----BEGIN PUBLIC KEY-----
+    MIIBIDANBgkqhkiG9w0BAQEFAAOCAQ0AMIIBCAKCAQEAwI4yqk1Y12zVmu9Ejlua
+    h2FD6kjrt+N9XfGqZUUVNeRb7CA0Sj5Q6NtgoaiXuIrSea2sLda6ivqAGmtxMMrP
+    zpf3FwsYWxBUNF7D4YeLmYjvcTbfr3bCOIRnPNXZ+4isuvvEiM02u2cO0okZSgeb
+    dofNa1NbTLYAQr9jZZb7GPKrTO4CKy0xzBih/A+sl6dL9PNDmqXQEjyJS6PXG1Vj
+    PvD5jpSrxuIl5Ms/+2Ro3ALgvC8dgoY/3m3csnd06afumGKv5YOGtf+bnWLhc0bf
+    6Sk8Q6i5t0Bl+HAULSPr+B9x/I0rN76ZnPvTj1+hJ0zTof4d0hOLx/K5OQyt7AKo
+    4wIBAQ==
+    -----END PUBLIC KEY-----
+
+  private_key: |
+    -----BEGIN RSA PRIVATE KEY-----
+    Proc-Type: 4,ENCRYPTED
+    DEK-Info: AES-128-CBC,ECE30DBBA56E2DF06B7BC415F8870994
+
+    YQOE5HIsghqjRsxPQqiWMH/VHmyFH6xIpBcmzxzispEHwBojlvLXviwvR66YhgNw
+    7smwE10Ik4/cwwiHTZqCk++jPATPygBiqQkUijCWzcT9kfaxmqdP4PL+hu9g7kGC
+    KrD2Bm8/oO08s957aThuHC1sABRcJ1V3FRzJT6Za4fwweyvHVYRnmgaDA6zH0qV8
+    NqBSB2hnNXKEdh6UFz9QGcrQxnRjfdIaW64zoEX7jT7gYYL7FkGXBa3XdMOA4fnl
+    adRwLFMs0jfilisZv8oUbPdZ6J6x3o8p8LVecCF8tdZt1zkcLSIXKnoDFpHSISGs
+    BD9aqD+E4ejynM/tPaVFq4IHzT8viN6h6WcH8fbpClFZ66Iyy9XL3/CjAY7Jzhh9
+    fnbc4Iq28cdbmO/vkR7JyVOgEMWe1BcSqtro70XoUNRY8uDJUPqohrhm/9AigFRA
+    Pwyf3LqojxRnwXjHsZtGltUtEAPZzgh3fKJnx9MyRR7DPXBRig7TAHU7n2BFRhHA
+    TYThy29bK6NkIc/cKc2kEQVo98Cr04PO8jVxZM332FlhiVlP0kpAp+tFj7aMzPTG
+    sJumb9kPbMsgpEuTCONm3yyoufGEBFMrIJ+Po48M2RlYOh50VkO09pI+Eu7FPtVB
+    H4gKzoJIpZZ/7vYXQ3djM8s9hc5gD5CVExTZV4drbsXt6ITiwHuxZ6CNHRBPL5AY
+    wmF8QZz4oivv1afdSe6E6OGC3uVmX3Psn5CVq2pE8VlRDKFy1WqfU2enRAijSS2B
+    rtJs263fOJ8ZntDzMVMPgiAlzzfA285KUletpAeUmz+peR1gNzkE0eKSG6THOCi0
+    rfmR8SeEzyNvin0wQ3qgYiiHjHbbFhJIMAQxoX+0hDSooM7Wo5wkLREULpGuesTg
+    A6Fe3CiOivMDraNGA7H6Yg==
+    -----END RSA PRIVATE KEY-----
+
-- 
cgit v1.2.3


From fcefeb469261bf19ffa249ceddf1ca003e520e5d Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Wed, 15 Feb 2012 13:49:41 -0500
Subject: fix update-etc-hosts, 'manage_etc_hosts' is not a boolean, but a
 string

---
 cloudinit/CloudConfig/cc_update_etc_hosts.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cloudinit/CloudConfig/cc_update_etc_hosts.py b/cloudinit/CloudConfig/cc_update_etc_hosts.py
index 572e6750..6ad2fca8 100644
--- a/cloudinit/CloudConfig/cc_update_etc_hosts.py
+++ b/cloudinit/CloudConfig/cc_update_etc_hosts.py
@@ -28,7 +28,7 @@ frequency = per_always
 def handle(_name, cfg, cloud, log, _args):
     (hostname, fqdn) = util.get_hostname_fqdn(cfg, cloud)
 
-    manage_hosts = util.get_cfg_option_bool(cfg, "manage_etc_hosts", False)
+    manage_hosts = util.get_cfg_option_str(cfg, "manage_etc_hosts", False)
     if manage_hosts in ("True", "true", True, "template"):
         # render from template file
         try:
-- 
cgit v1.2.3


From 4213f7c28c2b6788938b1504e5dec7fcda2b8806 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Wed, 15 Feb 2012 16:03:37 -0500
Subject: DataSourceOVF: only search for OVF data on ISO9660 filesystems

I believe this will resolve LP: #898373 by making DataSourceOVF restrict
its mounting of filesystems to iso9660.  By doing this, it will never
mount a ext3 (or btrfs or any fs that mountall would fsck) and thus will
avoid any races with that.

LP: #898373
---
 ChangeLog                  | 1 +
 cloudinit/DataSourceOVF.py | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/ChangeLog b/ChangeLog
index 45af41ed..5b0cfb90 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -23,6 +23,7 @@
  - in ci-info lines, use '.' to indicate empty field for easier machine reading
  - support empty lines in "#include" files (LP: #923043)
  - support configuration of salt minions (Jeff Bauer) (LP: #927795)
+ - DataSourceOVF: only search for OVF data on ISO9660 filesystems (LP: #898373)
 0.6.2:
  - fix bug where update was not done unless update was explicitly set.
    It would not be run if 'upgrade' or packages were set to be installed
diff --git a/cloudinit/DataSourceOVF.py b/cloudinit/DataSourceOVF.py
index 1f2b622e..a0b1b518 100644
--- a/cloudinit/DataSourceOVF.py
+++ b/cloudinit/DataSourceOVF.py
@@ -162,7 +162,7 @@ def get_ovf_env(dirname):
 
 # transport functions take no input and return
 # a 3 tuple of content, path, filename
-def transport_iso9660(require_iso=False):
+def transport_iso9660(require_iso=True):
 
     # default_regex matches values in
     # /lib/udev/rules.d/60-cdrom_id.rules
-- 
cgit v1.2.3


From 725ea78fe96b3282f67d67ddd6079f24f055c746 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Thu, 16 Feb 2012 13:31:19 -0500
Subject: initial version of DataSourceConfigDrive

---
 cloudinit/DataSourceConfigDrive.py | 208 +++++++++++++++++++++++++++++++++++++
 cloudinit/__init__.py              |   2 +-
 cloudinit/util.py                  |  80 ++++++++++++++
 config/cloud.cfg                   |   2 +-
 4 files changed, 290 insertions(+), 2 deletions(-)
 create mode 100644 cloudinit/DataSourceConfigDrive.py

diff --git a/cloudinit/DataSourceConfigDrive.py b/cloudinit/DataSourceConfigDrive.py
new file mode 100644
index 00000000..1c6021b3
--- /dev/null
+++ b/cloudinit/DataSourceConfigDrive.py
@@ -0,0 +1,208 @@
+#    Copyright (C) 2012 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 cloudinit.DataSource as DataSource
+
+from cloudinit import seeddir as base_seeddir
+import cloudinit.util as util
+import os.path
+import os
+import json
+
+DEFAULT_IID = "iid-dsconfigdrive"
+
+
+class DataSourceConfigDrive(DataSource.DataSource):
+    seed = None
+    seeddir = base_seeddir + '/config_drive'
+    cfg = {}
+    userdata_raw = None
+    metadata = None
+    dsmode = "local"
+
+    def __str__(self):
+        mstr = "DataSourceConfigDrive"
+        mstr = mstr + " [seed=%s]" % self.seed
+        return(mstr)
+
+    def get_data(self):
+        found = None
+        md = {}
+        ud = ""
+
+        defaults = {"instance-id": DEFAULT_IID}
+
+        try:
+            (md, ud) = read_config_drive_dir(self.seeddir)
+            found = self.seeddir
+        except nonConfigDriveDir:
+            pass
+
+        if not found:
+            dev = cfg_drive_device()
+            if dev:
+                try:
+                    (md, ud) = util.mount_callback_umount(dev,
+                        read_config_drive_dir)
+                    found = dev
+                except (nonConfigDriveDir, util.mountFailedError):
+                    pass
+
+        if not found:
+            return False
+
+        if 'dsconfig' in md:
+            self.cfg = md['dscfg']
+
+        md = util.mergedict(md, defaults)
+
+        self.seed = found
+        self.metadata = md
+        self.userdata_raw = ud
+
+        if 'dsmode' in md and md['dsmode'] == self.dsmode:
+            return True
+
+        return False
+
+    def get_public_ssh_keys(self):
+        if not 'public-keys' in self.metadata:
+            return([])
+        return([self.metadata['public-keys'], ])
+
+    # the data sources' config_obj is a cloud-config formated
+    # object that came to it from ways other than cloud-config
+    # because cloud-config content would be handled elsewhere
+    def get_config_obj(self):
+        return(self.cfg)
+
+
+class DataSourceConfigDriveNet(DataSourceConfigDrive):
+    dsmode = "net"
+
+
+class nonConfigDriveDir(Exception):
+    pass
+
+
+def update_network_config(content):
+    """
+    Update [write] /etc/network/interfaces
+    """
+    util.write_file("/etc/network/interfaces", content)
+    util.subp(['ifup', '--all'])
+
+
+def cfg_drive_device():
+    """ get the config drive device.  return a string like '/dev/vdb'
+        or None (if there is no non-root device attached). This does not
+        check the contents, only reports that if there *were* a config_drive
+        attached, it would be this device.
+        per config_drive documentation, this is
+         "associated as the last available disk on the instance"
+    """
+
+    if 'CLOUD_INIT_CONFIG_DRIVE_DEVICE' in os.environ:
+        return(os.environ['CLOUD_INIT_CONFIG_DRIVE_DEVICE'])
+
+    # we are looking for a raw block device (sda, not sda1) with a vfat
+    # filesystem on it.
+
+    letters = "abcdefghijklmnopqrstuvwxyz"
+    devs = util.find_devs_with("TYPE=vfat")
+
+    # filter out anything not ending in a letter (ignore partitions)
+    devs = [f for f in devs if f[-1] not in letters]
+
+    # sort them in reverse so "last" device is first
+    devs.sort(reverse=True)
+
+    if len(devs):
+        return(devs[0])
+
+    return(None)
+
+
+def read_config_drive_dir(source_dir):
+    """
+    read_config_drive_dir(source_dir):
+       read source_dir, and return a tuple with metadata dict and user-data
+       string populated.  If not a valid dir, raise a nonConfigDriveDir
+    """
+    md = {}
+    ud = ""
+
+    flist = ("etc/network/interfaces", "root/.ssh/authorized_keys", "meta.js")
+    found = [f for f in flist if os.path.isfile("%s/%s" % (source_dir, f))]
+
+    if len(found) == 0:
+        raise nonConfigDriveDir("%s: %s" % (source_dir, "no files found"))
+
+    if "etc/network/interfaces" in found:
+        with open("%s/%s" % (source_dir, "/etc/network/interfaces")) as fp:
+            md['interfaces'] = fp.read()
+
+    if "root/.ssh/authorized_keys" in found:
+        with open("%s/%s" % (source_dir, "root/.ssh/authorized_keys")) as fp:
+            md['public_keys'] = fp.read()
+
+    meta_js = {}
+
+    if "meta.js" in found:
+        content = ''
+        with open("%s/%s" % (source_dir, "meta.js")) as fp:
+            content = fp.read()
+        md['meta_js'] = content
+        try:
+            meta_js = json.loads(content)
+        except ValueError:
+            raise nonConfigDriveDir("%s: %s" %
+                (source_dir, "invalid json in meta.js"))
+
+    for copy in ('public_keys', 'dsmode', 'instance-id', 'dscfg'):
+        if copy in meta_js:
+            md[copy] = meta_js[copy]
+
+    if 'user-data' in meta_js:
+        ud = meta_js['user-data']
+
+    return(md, ud)
+
+datasources = (
+  (DataSourceConfigDrive, (DataSource.DEP_FILESYSTEM, )),
+  (DataSourceConfigDriveNet,
+    (DataSource.DEP_FILESYSTEM, DataSource.DEP_NETWORK)),
+)
+
+
+# return a list of data sources that match this set of dependencies
+def get_datasource_list(depends):
+    return(DataSource.list_from_depends(depends, datasources))
+
+if __name__ == "__main__":
+    def main():
+        import sys
+        import pprint
+        print cfg_drive_device()
+        (md, ud) = read_config_drive_dir(sys.argv[1])
+        print "=== md ==="
+        pprint.pprint(md)
+        print "=== ud ==="
+        print(ud)
+
+    main()
+
+# vi: ts=4 expandtab
diff --git a/cloudinit/__init__.py b/cloudinit/__init__.py
index 7a34e053..0fc61795 100644
--- a/cloudinit/__init__.py
+++ b/cloudinit/__init__.py
@@ -29,7 +29,7 @@ cfg_env_name = "CLOUD_CFG"
 
 cfg_builtin = """
 log_cfgs: []
-datasource_list: ["NoCloud", "OVF", "Ec2"]
+datasource_list: ["NoCloud", "ConfigDrive", "OVF", "Ec2"]
 def_log_file: /var/log/cloud-init.log
 syslog_fix_perms: syslog:adm
 """
diff --git a/cloudinit/util.py b/cloudinit/util.py
index e6489648..b53aa5fe 100644
--- a/cloudinit/util.py
+++ b/cloudinit/util.py
@@ -32,6 +32,7 @@ import re
 import socket
 import sys
 import time
+import tempfile
 import traceback
 import urlparse
 
@@ -630,3 +631,82 @@ def close_stdin():
         return
     with open(os.devnull) as fp:
         os.dup2(fp.fileno(), sys.stdin.fileno())
+
+def find_devs_with(criteria):
+    """
+    find devices matching given criteria (via blkid)
+    criteria can be *one* of:
+      TYPE=<filesystem>
+      LABEL=<label>
+      UUID=<uuid>
+    """
+    try:
+        (out,err) = subp(['blkid','-t%s' % criteria,'-odevice'])
+    except subprocess.CalledProcessError as exc:
+        return([])
+    return(out.splitlines())
+
+
+class mountFailedError(Exception):
+    pass
+        
+def mount_callback_umount(device, callback, data=None):
+    """
+    mount the device, call method 'callback' passing the directory
+    in which it was mounted, then unmount.  Return whatever 'callback'
+    returned.  If data != None, also pass data to callback.
+    """
+
+    def _cleanup(mountpoint, tmpd):
+        if umount:
+            try:
+                subp(["umount", '-l', umount])
+            except subprocess.CalledProcessError as exc:
+                raise
+        if tmpd:
+            os.rmdir(tmpd)
+                
+    # go through mounts to see if it was already mounted
+    fp = open("/proc/mounts")
+    mounts = fp.readlines()
+    fp.close()
+
+    tmpd = None
+
+    mounted = {}
+    for mpline in mounts:
+        (dev, mp, fstype, _opts, _freq, _passno) = mpline.split()
+        mp = mp.replace("\\040", " ")
+        mounted[dev] = (dev, fstype, mp, False)
+
+    umount = False
+    if device in mounted:
+        mountpoint = mounted[device][2]
+    else:
+        tmpd = tempfile.mkdtemp()
+        
+        mountcmd = ["mount", "-o", "ro", device, tmpd]
+
+        try:
+            (out, err) = subp(mountcmd)
+            umount = tmpd
+        except subprocess.CalledProcessError as exc:
+            _cleanup(umount, tmpd)
+            print exc.output[1]
+            raise mountFailedError(exc.output[1])
+
+        mountpoint = tmpd
+
+    try:
+        if data == None:
+            ret = callback(mountpoint)
+        else:
+            ret = callback(mountpoint, data)
+
+    except Exception as exc:
+        _cleanup(umount, tmpd)
+        raise exc
+
+    _cleanup(umount, tmpd)
+
+    return(ret)
diff --git a/config/cloud.cfg b/config/cloud.cfg
index 4eab2a36..c9b057e0 100644
--- a/config/cloud.cfg
+++ b/config/cloud.cfg
@@ -1,7 +1,7 @@
 user: ubuntu
 disable_root: 1
 preserve_hostname: False
-# datasource_list: [ "NoCloud", "OVF", "Ec2" ]
+# datasource_list: [ "NoCloud", "ConfigDrive", "OVF", "Ec2" ]
 
 cloud_init_modules:
  - bootcmd
-- 
cgit v1.2.3


From 00c36df90bcade0a1a3f59ceb7b88142b6eab962 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Thu, 16 Feb 2012 13:34:42 -0500
Subject: incorrect name for salt minion cloud_config

---
 config/cloud.cfg | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/config/cloud.cfg b/config/cloud.cfg
index 4eab2a36..fa17a2b3 100644
--- a/config/cloud.cfg
+++ b/config/cloud.cfg
@@ -24,7 +24,7 @@ cloud_config_modules:
  - timezone
  - puppet
  - chef
- - salt
+ - salt-minion
  - mcollective
  - disable-ec2-metadata
  - runcmd
-- 
cgit v1.2.3


From 7e770b1bc1a73afe0a5b37bb2242fce930089890 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Thu, 16 Feb 2012 15:10:45 -0500
Subject: DataSourceConfigDrive: generally seems functional

---
 cloudinit/DataSourceConfigDrive.py | 55 ++++++++++++++++++++++++--------------
 1 file changed, 35 insertions(+), 20 deletions(-)

diff --git a/cloudinit/DataSourceConfigDrive.py b/cloudinit/DataSourceConfigDrive.py
index 1c6021b3..04b9e0ce 100644
--- a/cloudinit/DataSourceConfigDrive.py
+++ b/cloudinit/DataSourceConfigDrive.py
@@ -17,10 +17,12 @@
 import cloudinit.DataSource as DataSource
 
 from cloudinit import seeddir as base_seeddir
+from cloudinit import log
 import cloudinit.util as util
 import os.path
 import os
 import json
+import subprocess
 
 DEFAULT_IID = "iid-dsconfigdrive"
 
@@ -34,7 +36,7 @@ class DataSourceConfigDrive(DataSource.DataSource):
     dsmode = "local"
 
     def __str__(self):
-        mstr = "DataSourceConfigDrive"
+        mstr = "DataSourceConfigDrive[%s]" % self.dsmode
         mstr = mstr + " [seed=%s]" % self.seed
         return(mstr)
 
@@ -43,13 +45,14 @@ class DataSourceConfigDrive(DataSource.DataSource):
         md = {}
         ud = ""
 
-        defaults = {"instance-id": DEFAULT_IID}
+        defaults = {"instance-id": DEFAULT_IID, "dsmode": "pass"}
 
-        try:
-            (md, ud) = read_config_drive_dir(self.seeddir)
-            found = self.seeddir
-        except nonConfigDriveDir:
-            pass
+        if os.path.isdir(self.seeddir):
+            try:
+                (md, ud) = read_config_drive_dir(self.seeddir)
+                found = self.seeddir
+            except nonConfigDriveDir:
+                pass
 
         if not found:
             dev = cfg_drive_device()
@@ -69,19 +72,36 @@ class DataSourceConfigDrive(DataSource.DataSource):
 
         md = util.mergedict(md, defaults)
 
+        if 'interfaces' in md and md['dsmode'] in (self.dsmode, "pass"):
+            if md['dsmode'] == "pass":
+                log.info("updating network interfaces from configdrive")
+            else:
+                log.debug("updating network interfaces from configdrive")
+
+            util.write_file("/etc/network/interfaces", md['interfaces'])
+            try:
+                (out, err) = util.subp(['ifup', '--all'])
+                if len(out) or len(err):
+                    log.warn("ifup --all had stderr: %s" % err)
+
+            except subprocess.CalledProcessError as exc:
+                log.warn("ifup --all failed: %s" % (exc.output[1]))
+
         self.seed = found
         self.metadata = md
         self.userdata_raw = ud
 
-        if 'dsmode' in md and md['dsmode'] == self.dsmode:
+        if md['dsmode'] == self.dsmode:
             return True
 
+        log.debug("%s: not claiming datasource, dsmode=%s" %
+            (self, md['dsmode']))
         return False
 
     def get_public_ssh_keys(self):
         if not 'public-keys' in self.metadata:
             return([])
-        return([self.metadata['public-keys'], ])
+        return(self.metadata['public-keys'])
 
     # the data sources' config_obj is a cloud-config formated
     # object that came to it from ways other than cloud-config
@@ -98,14 +118,6 @@ class nonConfigDriveDir(Exception):
     pass
 
 
-def update_network_config(content):
-    """
-    Update [write] /etc/network/interfaces
-    """
-    util.write_file("/etc/network/interfaces", content)
-    util.subp(['ifup', '--all'])
-
-
 def cfg_drive_device():
     """ get the config drive device.  return a string like '/dev/vdb'
         or None (if there is no non-root device attached). This does not
@@ -125,7 +137,7 @@ def cfg_drive_device():
     devs = util.find_devs_with("TYPE=vfat")
 
     # filter out anything not ending in a letter (ignore partitions)
-    devs = [f for f in devs if f[-1] not in letters]
+    devs = [f for f in devs if f[-1] in letters]
 
     # sort them in reverse so "last" device is first
     devs.sort(reverse=True)
@@ -157,7 +169,10 @@ def read_config_drive_dir(source_dir):
 
     if "root/.ssh/authorized_keys" in found:
         with open("%s/%s" % (source_dir, "root/.ssh/authorized_keys")) as fp:
-            md['public_keys'] = fp.read()
+            content = fp.read()
+            lines = content.splitlines()
+            keys = [l for l in lines if len(l) and not l.startswith("#")]
+            md['public-keys'] = keys
 
     meta_js = {}
 
@@ -172,7 +187,7 @@ def read_config_drive_dir(source_dir):
             raise nonConfigDriveDir("%s: %s" %
                 (source_dir, "invalid json in meta.js"))
 
-    for copy in ('public_keys', 'dsmode', 'instance-id', 'dscfg'):
+    for copy in ('public-keys', 'dsmode', 'instance-id', 'dscfg'):
         if copy in meta_js:
             md[copy] = meta_js[copy]
 
-- 
cgit v1.2.3


From 9f171511042d29542d8578957c6692c2c9457583 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Thu, 16 Feb 2012 16:52:58 -0500
Subject: DataSourceNoCloud: allow reading user-data and meta-data from simple
 files

This allows you to attach a disk in ISO9660 or vfat filesystem format
labeled 'cidata' with 'user-data' and 'meta-data' on it.

It provides a much easier way to interact with cloud-init in nocloud
than mounting the image or the OVF method.
---
 cloudinit/DataSourceNoCloud.py | 21 +++++++++++++++++++++
 cloudinit/util.py              |  4 ++--
 2 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/cloudinit/DataSourceNoCloud.py b/cloudinit/DataSourceNoCloud.py
index fa64f2e5..6c744b82 100644
--- a/cloudinit/DataSourceNoCloud.py
+++ b/cloudinit/DataSourceNoCloud.py
@@ -23,6 +23,7 @@ import cloudinit.DataSource as DataSource
 from cloudinit import seeddir as base_seeddir
 from cloudinit import log
 import cloudinit.util as util
+import errno
 
 
 class DataSourceNoCloud(DataSource.DataSource):
@@ -64,6 +65,26 @@ class DataSourceNoCloud(DataSource.DataSource):
             found.append(self.seeddir)
             log.debug("using seeded cache data in %s" % self.seeddir)
 
+        fslist = util.find_devs_with("TYPE=vfat")
+        fslist.extend(util.find_devs_with("TYPE=iso9660"))
+
+        label_list = util.find_devs_with("LABEL=cidata")
+        devlist = list(set(fslist) & set(label_list))
+        devlist.sort(reverse=True)
+
+        for dev in devlist:
+            try:
+                (newmd, newud) = util.mount_callback_umount(dev,
+                    util.read_seeded)
+                md = util.mergedict(newmd, md)
+                ud = newud
+                log.debug("using data from %s" % dev)
+                found.append(dev)
+                break
+            except OSError, e:
+                if e.errno != errno.ENOENT:
+                    raise
+
         # there was no indication on kernel cmdline or data
         # in the seeddir suggesting this handler should be used.
         if len(found) == 0:
diff --git a/cloudinit/util.py b/cloudinit/util.py
index b53aa5fe..0a691dcf 100644
--- a/cloudinit/util.py
+++ b/cloudinit/util.py
@@ -681,7 +681,7 @@ def mount_callback_umount(device, callback, data=None):
 
     umount = False
     if device in mounted:
-        mountpoint = mounted[device][2]
+        mountpoint = "%s/" % mounted[device][2]
     else:
         tmpd = tempfile.mkdtemp()
         
@@ -695,7 +695,7 @@ def mount_callback_umount(device, callback, data=None):
             print exc.output[1]
             raise mountFailedError(exc.output[1])
 
-        mountpoint = tmpd
+        mountpoint = "%s/" % tmpd
 
     try:
         if data == None:
-- 
cgit v1.2.3


From 45becc7f68e5bab4dfdc5f36e07a2a14400ae376 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Thu, 16 Feb 2012 16:56:01 -0500
Subject: update changelog

---
 ChangeLog | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ChangeLog b/ChangeLog
index 56da07c4..52d170c8 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -25,6 +25,7 @@
  - support configuration of salt minions (Jeff Bauer) (LP: #927795)
  - DataSourceOVF: only search for OVF data on ISO9660 filesystems (LP: #898373)
  - DataSourceConfigDrive: support getting data from openstack config drive (LP: #857378)
+ - DataSourceNoCloud: support seed from external disk of ISO or vfat (LP: #857378)
 0.6.2:
  - fix bug where update was not done unless update was explicitly set.
    It would not be run if 'upgrade' or packages were set to be installed
-- 
cgit v1.2.3


From fb43a1cc3d40b540411f9565e848d32598cf4b3f Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Fri, 17 Feb 2012 10:04:49 -0500
Subject: fix pylint warnings

---
 cloudinit/CloudConfig/cc_salt_minion.py |  3 ++-
 cloudinit/util.py                       | 21 +++++++++++----------
 2 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/cloudinit/CloudConfig/cc_salt_minion.py b/cloudinit/CloudConfig/cc_salt_minion.py
index 9a710e72..1a3b5039 100644
--- a/cloudinit/CloudConfig/cc_salt_minion.py
+++ b/cloudinit/CloudConfig/cc_salt_minion.py
@@ -20,7 +20,8 @@ import subprocess
 import cloudinit.CloudConfig as cc
 import yaml
 
-def handle(_name, cfg, cloud, log, _args):
+
+def handle(_name, cfg, _cloud, _log, _args):
     # If there isn't a salt key in the configuration don't do anything
     if 'salt_minion' not in cfg:
         return
diff --git a/cloudinit/util.py b/cloudinit/util.py
index 0a691dcf..780578e2 100644
--- a/cloudinit/util.py
+++ b/cloudinit/util.py
@@ -632,6 +632,7 @@ def close_stdin():
     with open(os.devnull) as fp:
         os.dup2(fp.fileno(), sys.stdin.fileno())
 
+
 def find_devs_with(criteria):
     """
     find devices matching given criteria (via blkid)
@@ -641,15 +642,16 @@ def find_devs_with(criteria):
       UUID=<uuid>
     """
     try:
-        (out,err) = subp(['blkid','-t%s' % criteria,'-odevice'])
-    except subprocess.CalledProcessError as exc:
+        (out, _err) = subp(['blkid', '-t%s' % criteria, '-odevice'])
+    except subprocess.CalledProcessError:
         return([])
-    return(out.splitlines())
+    return(str(out).splitlines())
 
 
 class mountFailedError(Exception):
     pass
-        
+
+
 def mount_callback_umount(device, callback, data=None):
     """
     mount the device, call method 'callback' passing the directory
@@ -657,15 +659,15 @@ def mount_callback_umount(device, callback, data=None):
     returned.  If data != None, also pass data to callback.
     """
 
-    def _cleanup(mountpoint, tmpd):
+    def _cleanup(umount, tmpd):
         if umount:
             try:
                 subp(["umount", '-l', umount])
-            except subprocess.CalledProcessError as exc:
+            except subprocess.CalledProcessError:
                 raise
         if tmpd:
             os.rmdir(tmpd)
-                
+
     # go through mounts to see if it was already mounted
     fp = open("/proc/mounts")
     mounts = fp.readlines()
@@ -684,15 +686,14 @@ def mount_callback_umount(device, callback, data=None):
         mountpoint = "%s/" % mounted[device][2]
     else:
         tmpd = tempfile.mkdtemp()
-        
+
         mountcmd = ["mount", "-o", "ro", device, tmpd]
 
         try:
-            (out, err) = subp(mountcmd)
+            (_out, _err) = subp(mountcmd)
             umount = tmpd
         except subprocess.CalledProcessError as exc:
             _cleanup(umount, tmpd)
-            print exc.output[1]
             raise mountFailedError(exc.output[1])
 
         mountpoint = "%s/" % tmpd
-- 
cgit v1.2.3


From 45bff1e1c6b1a5a1d9d52e109d38680853c58b11 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Fri, 17 Feb 2012 10:49:35 -0500
Subject: DataSourceConfigDrive: change 'interfaces' to 'network-interfaces'

Instead of a metadata entry named 'interfaces', use 'network-interfaces'
which is a somewhat less likely namespace collision.
---
 cloudinit/DataSourceConfigDrive.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cloudinit/DataSourceConfigDrive.py b/cloudinit/DataSourceConfigDrive.py
index 04b9e0ce..af776e08 100644
--- a/cloudinit/DataSourceConfigDrive.py
+++ b/cloudinit/DataSourceConfigDrive.py
@@ -78,7 +78,7 @@ class DataSourceConfigDrive(DataSource.DataSource):
             else:
                 log.debug("updating network interfaces from configdrive")
 
-            util.write_file("/etc/network/interfaces", md['interfaces'])
+            util.write_file("/etc/network/interfaces", md['network-interfaces'])
             try:
                 (out, err) = util.subp(['ifup', '--all'])
                 if len(out) or len(err):
@@ -165,7 +165,7 @@ def read_config_drive_dir(source_dir):
 
     if "etc/network/interfaces" in found:
         with open("%s/%s" % (source_dir, "/etc/network/interfaces")) as fp:
-            md['interfaces'] = fp.read()
+            md['network-interfaces'] = fp.read()
 
     if "root/.ssh/authorized_keys" in found:
         with open("%s/%s" % (source_dir, "root/.ssh/authorized_keys")) as fp:
-- 
cgit v1.2.3


From 979bee2c9ee477ea495c5df4f420d5ca2123a840 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Fri, 17 Feb 2012 11:00:39 -0500
Subject: DataSourceConfigDrive: update interfaces (and ifup) only on local

Previously, the 'ifup --all' and update of /etc/network/interfaces
was done only if the specified 'dsmode' (which defaults to 'pass') was
either 'pass' or *this* dsmode.

That meant that it would be updated once on DataSourceConfigDrive
and on DataSourceConfigDriveNet.

This changes that to only happen on local.
---
 cloudinit/DataSourceConfigDrive.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/cloudinit/DataSourceConfigDrive.py b/cloudinit/DataSourceConfigDrive.py
index af776e08..f44344a2 100644
--- a/cloudinit/DataSourceConfigDrive.py
+++ b/cloudinit/DataSourceConfigDrive.py
@@ -72,13 +72,16 @@ class DataSourceConfigDrive(DataSource.DataSource):
 
         md = util.mergedict(md, defaults)
 
-        if 'interfaces' in md and md['dsmode'] in (self.dsmode, "pass"):
+        # update interfaces and ifup only on the local datasource
+        # this way the DataSourceConfigDriveNet doesn't do it also.
+        if 'network-interfaces' in md and self.dsmode == "local":
             if md['dsmode'] == "pass":
                 log.info("updating network interfaces from configdrive")
             else:
                 log.debug("updating network interfaces from configdrive")
 
-            util.write_file("/etc/network/interfaces", md['network-interfaces'])
+            util.write_file("/etc/network/interfaces",
+                md['network-interfaces'])
             try:
                 (out, err) = util.subp(['ifup', '--all'])
                 if len(out) or len(err):
-- 
cgit v1.2.3


From 02aea2383e0ea020fd6c2e74ffcaad8983820a9d Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Fri, 17 Feb 2012 12:14:48 -0500
Subject: support reading network interface config from DataSourceNoCloud

document usage of DataSourceNoCloud from vfat or iso disk.
---
 ChangeLog                      |  1 +
 cloudinit/DataSourceNoCloud.py | 41 +++++++++++++++++++++++++++++--
 doc/nocloud/README             | 55 ++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 95 insertions(+), 2 deletions(-)
 create mode 100644 doc/nocloud/README

diff --git a/ChangeLog b/ChangeLog
index 52d170c8..cd92618d 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -26,6 +26,7 @@
  - DataSourceOVF: only search for OVF data on ISO9660 filesystems (LP: #898373)
  - DataSourceConfigDrive: support getting data from openstack config drive (LP: #857378)
  - DataSourceNoCloud: support seed from external disk of ISO or vfat (LP: #857378)
+ - DataSourceNoCloud: support inserting /etc/network/interfaces
 0.6.2:
  - fix bug where update was not done unless update was explicitly set.
    It would not be run if 'upgrade' or packages were set to be installed
diff --git a/cloudinit/DataSourceNoCloud.py b/cloudinit/DataSourceNoCloud.py
index 6c744b82..1e28edbd 100644
--- a/cloudinit/DataSourceNoCloud.py
+++ b/cloudinit/DataSourceNoCloud.py
@@ -24,6 +24,7 @@ from cloudinit import seeddir as base_seeddir
 from cloudinit import log
 import cloudinit.util as util
 import errno
+import subprocess
 
 
 class DataSourceNoCloud(DataSource.DataSource):
@@ -31,6 +32,7 @@ class DataSourceNoCloud(DataSource.DataSource):
     userdata = None
     userdata_raw = None
     supported_seed_starts = ("/", "file://")
+    dsmode = "local"
     seed = None
     cmdline_id = "ds=nocloud"
     seeddir = base_seeddir + '/nocloud'
@@ -42,7 +44,7 @@ class DataSourceNoCloud(DataSource.DataSource):
 
     def get_data(self):
         defaults = {
-            "instance-id": "nocloud"
+            "instance-id": "nocloud", "dsmode": "net"
         }
 
         found = []
@@ -84,14 +86,20 @@ class DataSourceNoCloud(DataSource.DataSource):
             except OSError, e:
                 if e.errno != errno.ENOENT:
                     raise
+            except util.mountFailedError:
+                log.warn("Failed to mount %s when looking for seed" % dev)
 
         # there was no indication on kernel cmdline or data
         # in the seeddir suggesting this handler should be used.
         if len(found) == 0:
             return False
 
+        seeded_interfaces = None
+
         # the special argument "seedfrom" indicates we should
         # attempt to seed the userdata / metadata from its value
+        # its primarily value is in allowing the user to type less
+        # on the command line, ie: ds=nocloud;s=http://bit.ly/abcdefg
         if "seedfrom" in md:
             seedfrom = md["seedfrom"]
             seedfound = False
@@ -104,6 +112,9 @@ class DataSourceNoCloud(DataSource.DataSource):
                     (seedfrom, self.__class__))
                 return False
 
+            if 'network-interfaces' in md:
+                seeded_interfaces = self.dsmode
+
             # this could throw errors, but the user told us to do it
             # so if errors are raised, let them raise
             (md_seed, ud) = util.read_seeded(seedfrom, timeout=None)
@@ -114,10 +125,35 @@ class DataSourceNoCloud(DataSource.DataSource):
             found.append(seedfrom)
 
         md = util.mergedict(md, defaults)
+
+        # update the network-interfaces if metadata had 'network-interfaces'
+        # entry and this is the local datasource, or 'seedfrom' was used
+        # and the source of the seed was self.dsmode
+        # ('local' for NoCloud, 'net' for NoCloudNet')
+        if ('network-interfaces' in md and
+            (self.dsmode in ("local", seeded_interfaces))):
+            log.info("updating network interfaces from nocloud")
+
+            util.write_file("/etc/network/interfaces",
+                md['network-interfaces'])
+            try:
+                (out, err) = util.subp(['ifup', '--all'])
+                if len(out) or len(err):
+                    log.warn("ifup --all had stderr: %s" % err)
+
+            except subprocess.CalledProcessError as exc:
+                log.warn("ifup --all failed: %s" % (exc.output[1]))
+
         self.seed = ",".join(found)
         self.metadata = md
         self.userdata_raw = ud
-        return True
+
+        if md['dsmode'] == self.dsmode:
+            return True
+
+        log.debug("%s: not claiming datasource, dsmode=%s" %
+            (self, md['dsmode']))
+        return False
 
 
 # returns true or false indicating if cmdline indicated
@@ -166,6 +202,7 @@ class DataSourceNoCloudNet(DataSourceNoCloud):
     cmdline_id = "ds=nocloud-net"
     supported_seed_starts = ("http://", "https://", "ftp://")
     seeddir = base_seeddir + '/nocloud-net'
+    dsmode = "net"
 
 
 datasources = (
diff --git a/doc/nocloud/README b/doc/nocloud/README
new file mode 100644
index 00000000..c94b206a
--- /dev/null
+++ b/doc/nocloud/README
@@ -0,0 +1,55 @@
+The data source 'NoCloud' and 'NoCloudNet' allow the user to provide user-data
+and meta-data to the instance without running a network service (or even without
+having a network at all)
+
+You can provide meta-data and user-data to a local vm boot via files on a vfat
+or iso9660 filesystem.  These user-data and meta-data files are expected to be
+in the format described in doc/example/seed/README .  Basically, user-data is
+simply user-data and meta-data is a yaml formated file representing what you'd
+find in the EC2 metadata service.
+
+Given a disk 12.04 cloud image in 'disk.img', you can create a sufficient disk
+by following the example below.
+
+## create user-data and meta-data files that will be used
+## to modify image on first boot
+$ { echo instance-id: iid-local01; echo local-hostname: cloudimg; } > meta-data
+
+$ printf "#cloud-config\npassword: passw0rd\nchpasswd: { expire: False }\nssh_pwauth: True\n" > user-data
+
+## create a disk to attach with some user-data and meta-data
+$ genisoimage  -output seed.iso -volid cidata -joliet -rock user-data meta-data
+
+## alternatively, create a vfat filesystem with same files
+## $ truncate --size 2M seed.img
+## $ mkfs.vfat -n cidata seed.img
+## $ mcopy -oi seed.img user-data meta-data ::
+
+## create a new qcow image to boot, backed by your original image
+$ qemu-img create -f qcow2 -b disk.img boot-disk.img
+
+## boot the image and login as 'ubuntu' with password 'passw0rd'
+## note, passw0rd was set as password through the user-data above,
+## there is no password set on these images.
+$ kvm -m 256 \
+   -net nic -net user,hostfwd=tcp::2222-:22 \
+   -drive file=boot-disk.img,if=virtio \
+   -drive file=seed.iso,if=virtio
+
+Note, that the instance-id provided ('iid-local01' above) is what is used to
+determine if this is "first boot".  So if you are making updates to user-data
+you will also have to change that, or start the disk fresh.
+
+
+Also, you can inject an /etc/network/interfaces file by providing the content
+for that file in the 'network-interfaces' field of metadata.  Example metadata:
+  instance-id: iid-abcdefg
+  network-interfaces: |
+    iface eth0 inet static
+    address 192.168.1.10
+    network 192.168.1.0
+    netmask 255.255.255.0
+    broadcast 192.168.1.255
+    gateway 192.168.1.254
+  hostname: myhost
+
-- 
cgit v1.2.3


From 9c37781563e79e1c816632725a3890ea0955a5f6 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Fri, 17 Feb 2012 13:19:26 -0500
Subject: cloud-init.py: exit success if no data sources found

previously, cloud-init would exit failure if no data sources were
found.  In the case of cloud-init-local, that was often the case.

In the case of cloud-init (net) it is a bit more likely that the user
would consider it failure if nothing was found.  Potentially this could
even be user-configurable.
---
 cloud-init.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cloud-init.py b/cloud-init.py
index 9d559020..9e0a0405 100755
--- a/cloud-init.py
+++ b/cloud-init.py
@@ -136,7 +136,7 @@ def main():
         cloud.get_data_source()
     except cloudinit.DataSourceNotFoundException as e:
         sys.stderr.write("no instance data found in %s\n" % cmd)
-        sys.exit(1)
+        sys.exit(0)
 
     # set this as the current instance
     cloud.set_cur_instance()
-- 
cgit v1.2.3


From 1e0e6c6ced37a9c111b0f1aa26d308a7a0bf0d79 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Fri, 17 Feb 2012 14:33:57 -0500
Subject: add doc for configdrive

---
 doc/configdrive/README | 73 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 doc/configdrive/README

diff --git a/doc/configdrive/README b/doc/configdrive/README
new file mode 100644
index 00000000..1ad7b0d0
--- /dev/null
+++ b/doc/configdrive/README
@@ -0,0 +1,73 @@
+The 'ConfigDrive' DataSource supports the OpenStack configdrive disk.
+See doc/source/api_ext/ext_config_drive.rst in the nova source code for
+more information on config drive.
+
+The following criteria are required to be identified by
+DataSourceConfigDrive as a config drive:
+ * must be formated with vfat filesystem
+ * must be a un-partitioned block device (/dev/vdb, not /dev/vdb1)
+ * must contain one of the following files:
+    * etc/network/interfaces
+    * root/.ssh/authorized_keys
+    * meta.js
+
+By default, cloud-init does not consider this source to be a full-fledged
+datasource.  Instead, the default behavior is to assume it is really only
+present to provide networking information.  Cloud-init will copy off the
+network information, apply it to the system, and then continue on.  The
+"full" datasource would then be found in the EC2 metadata service.
+
+== Content of config-drive ==
+  * etc/network/interfaces
+    This file is laid down by nova in order to pass static networking
+    information to the guest.  Cloud-init will copy it off of the config-drive
+    and into /etc/network/interfaces as soon as it can, and then attempt to
+    bring up all network interfaces.
+
+  * root/.ssh/authorized_keys
+    This file is laid down by nova, and contains the keys that were
+    provided to it on instance creation (nova-boot --key ....)
+
+    Cloud-init will copy those keys and put them into the configured user
+    ('ubuntu') .ssh/authorized_keys.
+
+  * meta.js
+    meta.js is populated on the config-drive in response to the user passing
+    "meta flags" (nova boot --meta key=value ...).  It is expected to be json
+    formated.
+
+== Configuration ==
+Cloud-init's behavior can be modified by keys found in the meta.js file in
+the following ways:
+ * dsmode:  
+   values: local, net, pass
+   default: pass
+
+   This is what indicates if configdrive is a final data source or not.
+   By default it is 'pass', meaning this datasource should not be read.
+   Set it to 'local' or 'net' to stop cloud-init from continuing on to
+   search for other data sources after network config.
+
+   The difference between 'local' and 'net' is that local will not require
+   networking to be up before user-data actions (or boothooks) are run.
+   
+ * instance-id:
+   default: iid-dsconfigdrive
+   This is utilized as the metadata's instance-id.  It should generally
+   be unique, as it is what is used to determine "is this a new instance".
+
+ * public-keys:
+   default: None
+   if present, these keys will be used as the public keys for the
+   instance.  This value overrides the content in authorized_keys.
+   Note: it is likely preferable to provide keys via user-data
+
+ * user-data:
+   default: None
+   This provides cloud-init user-data.  See other documentation for what
+   all can be present here.
+
+--
+[1] https://github.com/openstack/nova/blob/master/doc/source/api_ext/ext_config_drive.rst for more if
+
+
-- 
cgit v1.2.3


From 316f9ee4bfb27375ae92027664a59b94922f11ec Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Fri, 17 Feb 2012 16:58:02 -0500
Subject: more documentation on configdrive

---
 doc/configdrive/README | 45 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/doc/configdrive/README b/doc/configdrive/README
index 1ad7b0d0..ed9033c9 100644
--- a/doc/configdrive/README
+++ b/doc/configdrive/README
@@ -67,6 +67,51 @@ the following ways:
    This provides cloud-init user-data.  See other documentation for what
    all can be present here.
 
+== Example ==
+Here is an example using the nova client (python-novaclien)
+
+Assuming the following variables set up:
+ * img_id : set to the nova image id (uuid from image-list)
+ * flav_id : set to numeric flavor_id (nova flavor-list)
+ * keyname : set to name of key for this instance (nova keypair-list)
+
+$ cat my-user-data 
+#!/bin/sh
+echo ==== USER_DATA FROM EC2 MD ==== | tee /ud.log
+
+$ ud_value=$(sed 's,EC2 MD,META KEY,')
+
+## Now, 'ud_value' has same content of my-user-data file, but
+## with the string "USER_DATA FROM META KEY"
+
+## launch an instance with dsmode=pass
+## This will really not use the configdrive for anything as the mode
+## for the datasource is 'pass', meaning it will still expect some
+## other data source (DataSourceEc2).
+
+$ nova boot --image=$img_id --config-drive=1 --flavor=$flav_id \
+   --key_name=$keyname \
+   --user_data=my-user-data \
+   "--meta=instance-id=iid-001 \
+   "--meta=user-data=${ud_keyval}" \
+   "--meta=dsmode=pass" cfgdrive-dsmode-pass
+
+$ euca-get-console-output i-0000001 | grep USER_DATA
+echo ==== USER_DATA FROM EC2 MD ==== | tee /ud.log
+
+## Now, launch an instance with dsmode=local
+## This time, the only metadata and userdata available to cloud-init
+## are on the config-drive
+$ nova boot --image=$img_id --config-drive=1 --flavor=$flav_id \
+   --key_name=$keyname \
+   --user_data=my-user-data \
+   "--meta=instance-id=iid-001 \
+   "--meta=user-data=${ud_keyval}" \
+   "--meta=dsmode=local" cfgdrive-dsmode-local
+
+$ euca-get-console-output i-0000002 | grep USER_DATA
+echo ==== USER_DATA FROM META KEY ==== | tee /ud.log
+
 --
 [1] https://github.com/openstack/nova/blob/master/doc/source/api_ext/ext_config_drive.rst for more if
 
-- 
cgit v1.2.3


From 3b3386dd794c9063db99fc0c9422119e8536b18d Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Fri, 17 Feb 2012 16:59:04 -0500
Subject: ConfigDrive: better support public-keys in meta flags

This makes the user able to pass in multi-line input to the public-key flag,
and it will be handled correctly (just as if it came from the authorized_keys
file)
---
 cloudinit/DataSourceConfigDrive.py | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/cloudinit/DataSourceConfigDrive.py b/cloudinit/DataSourceConfigDrive.py
index f44344a2..2db4a76a 100644
--- a/cloudinit/DataSourceConfigDrive.py
+++ b/cloudinit/DataSourceConfigDrive.py
@@ -162,6 +162,7 @@ def read_config_drive_dir(source_dir):
 
     flist = ("etc/network/interfaces", "root/.ssh/authorized_keys", "meta.js")
     found = [f for f in flist if os.path.isfile("%s/%s" % (source_dir, f))]
+    keydata = ""
 
     if len(found) == 0:
         raise nonConfigDriveDir("%s: %s" % (source_dir, "no files found"))
@@ -172,10 +173,7 @@ def read_config_drive_dir(source_dir):
 
     if "root/.ssh/authorized_keys" in found:
         with open("%s/%s" % (source_dir, "root/.ssh/authorized_keys")) as fp:
-            content = fp.read()
-            lines = content.splitlines()
-            keys = [l for l in lines if len(l) and not l.startswith("#")]
-            md['public-keys'] = keys
+            keydata = fp.read()
 
     meta_js = {}
 
@@ -190,7 +188,14 @@ def read_config_drive_dir(source_dir):
             raise nonConfigDriveDir("%s: %s" %
                 (source_dir, "invalid json in meta.js"))
 
-    for copy in ('public-keys', 'dsmode', 'instance-id', 'dscfg'):
+    keydata = meta_js.get('public-keys', keydata)
+
+    if keydata:
+        lines = keydata.splitlines()
+        md['public-keys'] = [l for l in lines
+            if len(l) and not l.startswith("#")]
+
+    for copy in ('dsmode', 'instance-id', 'dscfg'):
         if copy in meta_js:
             md[copy] = meta_js[copy]
 
-- 
cgit v1.2.3


From 09e9d225c61ecae1c27e4dcfb1cda0d374535ba6 Mon Sep 17 00:00:00 2001
From: Mike Milner <mike.milner@canonical.com>
Date: Tue, 21 Feb 2012 14:26:48 -0400
Subject: Added tests for adding handlers.

---
 tests/unittests/test__init__.py                    |  91 +++++++++++
 .../test_handler/test_handler_ca_certs.py          | 178 +++++++++++++++++++++
 tests/unittests/test_handler_ca_certs.py           | 178 ---------------------
 3 files changed, 269 insertions(+), 178 deletions(-)
 create mode 100644 tests/unittests/test__init__.py
 create mode 100644 tests/unittests/test_handler/test_handler_ca_certs.py
 delete mode 100644 tests/unittests/test_handler_ca_certs.py

diff --git a/tests/unittests/test__init__.py b/tests/unittests/test__init__.py
new file mode 100644
index 00000000..f18e39b8
--- /dev/null
+++ b/tests/unittests/test__init__.py
@@ -0,0 +1,91 @@
+from unittest import TestCase
+from mocker import MockerTestCase, ANY, ARGS, KWARGS
+from tempfile import mkdtemp
+from shutil import rmtree
+import os
+import stat
+import sys
+
+from cloudinit import partwalker_handle_handler, handler_handle_part, handler_register
+from cloudinit.util import write_file, logexc
+
+
+class TestPartwalkerHandleHandler(MockerTestCase):
+    def setUp(self):
+        self.data = {
+            "handlercount": 0,
+            "frequency": "?",
+            "handlerdir": "?",
+            "handlers": [],
+            "data": None}
+
+        self.expected_module_name = "part-handler-%03d" % self.data["handlercount"]
+        expected_file_name = "%s.py" % self.expected_module_name
+        expected_file_fullname = os.path.join(self.data["handlerdir"], expected_file_name)
+        self.module_fake = "fake module handle"
+        self.ctype = None
+        self.filename = None
+        self.payload = "dummy payload"
+
+        # Mock the write_file function
+        write_file_mock = self.mocker.replace(write_file, passthrough=False)
+        write_file_mock(expected_file_fullname, self.payload, 0600)
+
+    def test_no_errors(self):
+        """Payload gets written to file and added to C{pdata}."""
+        # Mock the __import__ builtin
+        import_mock = self.mocker.replace("__builtin__.__import__")
+        import_mock(self.expected_module_name)
+        self.mocker.result(self.module_fake)
+        # Mock the handle_register function
+        handle_reg_mock = self.mocker.replace(handler_register, passthrough=False)
+        handle_reg_mock(self.module_fake, self.data["handlers"], self.data["data"], self.data["frequency"])
+        # Activate mocks
+        self.mocker.replay()
+
+        partwalker_handle_handler(self.data, self.ctype, self.filename, self.payload)
+
+        self.assertEqual(1, self.data["handlercount"])
+
+    def test_import_error(self):
+        """Payload gets written to file and added to C{pdata}."""
+        # Mock the __import__ builtin
+        import_mock = self.mocker.replace("__builtin__.__import__")
+        import_mock(self.expected_module_name)
+        self.mocker.throw(ImportError())
+        # Mock log function
+        logexc_mock = self.mocker.replace(logexc, passthrough=False)
+        logexc_mock(ANY)
+        # Mock the print_exc function
+        print_exc_mock = self.mocker.replace("traceback.print_exc", passthrough=False)
+        print_exc_mock(ARGS, KWARGS)
+        # Activate mocks
+        self.mocker.replay()
+
+        partwalker_handle_handler(self.data, self.ctype, self.filename, self.payload)
+
+    def test_attribute_error(self):
+        """Payload gets written to file and added to C{pdata}."""
+        # Mock the __import__ builtin
+        import_mock = self.mocker.replace("__builtin__.__import__")
+        import_mock(self.expected_module_name)
+        self.mocker.result(self.module_fake)
+        # Mock the handle_register function
+        handle_reg_mock = self.mocker.replace(handler_register, passthrough=False)
+        handle_reg_mock(self.module_fake, self.data["handlers"], self.data["data"], self.data["frequency"])
+        self.mocker.throw(AttributeError())
+        # Mock log function
+        logexc_mock = self.mocker.replace(logexc, passthrough=False)
+        logexc_mock(ANY)
+        # Mock the print_exc function
+        print_exc_mock = self.mocker.replace("traceback.print_exc", passthrough=False)
+        print_exc_mock(ARGS, KWARGS)
+        # Activate mocks
+        self.mocker.replay()
+
+        partwalker_handle_handler(self.data, self.ctype, self.filename, self.payload)
+
+
+class TestHandlerHandlePart(TestCase):
+    def test_dummy(self):
+        self.assertTrue(False)
diff --git a/tests/unittests/test_handler/test_handler_ca_certs.py b/tests/unittests/test_handler/test_handler_ca_certs.py
new file mode 100644
index 00000000..d6513b5b
--- /dev/null
+++ b/tests/unittests/test_handler/test_handler_ca_certs.py
@@ -0,0 +1,178 @@
+from mocker import MockerTestCase
+
+from cloudinit.util import write_file, delete_dir_contents
+from cloudinit.CloudConfig.cc_ca_certs import (
+    handle, update_ca_certs, add_ca_certs, remove_default_ca_certs)
+from logging import getLogger
+
+
+class TestNoConfig(MockerTestCase):
+    def setUp(self):
+        super(TestNoConfig, self).setUp()
+        self.name = "ca-certs"
+        self.cloud_init = None
+        self.log = getLogger("TestNoConfig")
+        self.args = []
+
+    def test_no_config(self):
+        """
+        Test that nothing is done if no ca-certs configuration is provided.
+        """
+        config = {"unknown-key": "value"}
+
+        self.mocker.replace(write_file, passthrough=False)
+        self.mocker.replace(update_ca_certs, passthrough=False)
+        self.mocker.replay()
+
+        handle(self.name, config, self.cloud_init, self.log, self.args)
+
+
+class TestConfig(MockerTestCase):
+    def setUp(self):
+        super(TestConfig, self).setUp()
+        self.name = "ca-certs"
+        self.cloud_init = None
+        self.log = getLogger("TestNoConfig")
+        self.args = []
+
+        # Mock out the functions that actually modify the system
+        self.mock_add = self.mocker.replace(add_ca_certs, passthrough=False)
+        self.mock_update = self.mocker.replace(update_ca_certs,
+                                               passthrough=False)
+        self.mock_remove = self.mocker.replace(remove_default_ca_certs,
+                                               passthrough=False)
+        # Order must be correct
+        self.mocker.order()
+
+    def test_no_trusted_list(self):
+        """
+        Test that no certificates are written if the 'trusted' key is not
+        present.
+        """
+        config = {"ca-certs": {}}
+
+        # No functions should be called
+        self.mock_update()
+        self.mocker.replay()
+
+        handle(self.name, config, self.cloud_init, self.log, self.args)
+
+    def test_empty_trusted_list(self):
+        """Test that no certificate are written if 'trusted' list is empty"""
+        config = {"ca-certs": {"trusted": []}}
+
+        # No functions should be called
+        self.mock_update()
+        self.mocker.replay()
+
+        handle(self.name, config, self.cloud_init, self.log, self.args)
+
+    def test_single_trusted(self):
+        """Test that a single cert gets passed to add_ca_certs"""
+        config = {"ca-certs": {"trusted": ["CERT1"]}}
+
+        self.mock_add(["CERT1"])
+        self.mock_update()
+        self.mocker.replay()
+
+        handle(self.name, config, self.cloud_init, self.log, self.args)
+
+    def test_multiple_trusted(self):
+        """Test that multiple certs get passed to add_ca_certs"""
+        config = {"ca-certs": {"trusted": ["CERT1", "CERT2"]}}
+
+        self.mock_add(["CERT1", "CERT2"])
+        self.mock_update()
+        self.mocker.replay()
+
+        handle(self.name, config, self.cloud_init, self.log, self.args)
+
+    def test_remove_default_ca_certs(self):
+        """Test remove_defaults works as expected"""
+        config = {"ca-certs": {"remove-defaults": True}}
+
+        self.mock_remove()
+        self.mock_update()
+        self.mocker.replay()
+
+        handle(self.name, config, self.cloud_init, self.log, self.args)
+
+    def test_no_remove_defaults_if_false(self):
+        """Test remove_defaults is not called when config value is False"""
+        config = {"ca-certs": {"remove-defaults": False}}
+
+        self.mock_update()
+        self.mocker.replay()
+
+        handle(self.name, config, self.cloud_init, self.log, self.args)
+
+    def test_correct_order_for_remove_then_add(self):
+        """Test remove_defaults is not called when config value is False"""
+        config = {"ca-certs": {"remove-defaults": True, "trusted": ["CERT1"]}}
+
+        self.mock_remove()
+        self.mock_add(["CERT1"])
+        self.mock_update()
+        self.mocker.replay()
+
+        handle(self.name, config, self.cloud_init, self.log, self.args)
+
+
+class TestAddCaCerts(MockerTestCase):
+    def test_no_certs_in_list(self):
+        """Test that no certificate are written if not provided."""
+        self.mocker.replace(write_file, passthrough=False)
+        self.mocker.replay()
+
+        add_ca_certs([])
+
+    def test_single_cert(self):
+        """Test adding a single certificate to the trusted CAs"""
+        cert = "CERT1\nLINE2\nLINE3"
+
+        mock_write = self.mocker.replace(write_file, passthrough=False)
+        mock_write("/usr/share/ca-certificates/cloud-init-ca-certs.crt",
+                   cert, mode=0644)
+        mock_write("/etc/ca-certificates.conf",
+                   "\ncloud-init-ca-certs.crt", omode="a")
+        self.mocker.replay()
+
+        add_ca_certs([cert])
+
+    def test_multiple_certs(self):
+        """Test adding multiple certificates to the trusted CAs"""
+        certs = ["CERT1\nLINE2\nLINE3", "CERT2\nLINE2\nLINE3"]
+        expected_cert_file = "\n".join(certs)
+
+        mock_write = self.mocker.replace(write_file, passthrough=False)
+        mock_write("/usr/share/ca-certificates/cloud-init-ca-certs.crt",
+                   expected_cert_file, mode=0644)
+        mock_write("/etc/ca-certificates.conf",
+                   "\ncloud-init-ca-certs.crt", omode="a")
+        self.mocker.replay()
+
+        add_ca_certs(certs)
+
+
+class TestUpdateCaCerts(MockerTestCase):
+    def test_commands(self):
+        mock_check_call = self.mocker.replace("subprocess.check_call",
+                                              passthrough=False)
+        mock_check_call(["update-ca-certificates"])
+        self.mocker.replay()
+
+        update_ca_certs()
+
+
+class TestRemoveDefaultCaCerts(MockerTestCase):
+    def test_commands(self):
+        mock_delete_dir_contents = self.mocker.replace(delete_dir_contents,
+                                                       passthrough=False)
+        mock_write = self.mocker.replace(write_file, passthrough=False)
+
+        mock_delete_dir_contents("/usr/share/ca-certificates/")
+        mock_delete_dir_contents("/etc/ssl/certs/")
+        mock_write("/etc/ca-certificates.conf", "", mode=0644)
+        self.mocker.replay()
+
+        remove_default_ca_certs()
diff --git a/tests/unittests/test_handler_ca_certs.py b/tests/unittests/test_handler_ca_certs.py
deleted file mode 100644
index d6513b5b..00000000
--- a/tests/unittests/test_handler_ca_certs.py
+++ /dev/null
@@ -1,178 +0,0 @@
-from mocker import MockerTestCase
-
-from cloudinit.util import write_file, delete_dir_contents
-from cloudinit.CloudConfig.cc_ca_certs import (
-    handle, update_ca_certs, add_ca_certs, remove_default_ca_certs)
-from logging import getLogger
-
-
-class TestNoConfig(MockerTestCase):
-    def setUp(self):
-        super(TestNoConfig, self).setUp()
-        self.name = "ca-certs"
-        self.cloud_init = None
-        self.log = getLogger("TestNoConfig")
-        self.args = []
-
-    def test_no_config(self):
-        """
-        Test that nothing is done if no ca-certs configuration is provided.
-        """
-        config = {"unknown-key": "value"}
-
-        self.mocker.replace(write_file, passthrough=False)
-        self.mocker.replace(update_ca_certs, passthrough=False)
-        self.mocker.replay()
-
-        handle(self.name, config, self.cloud_init, self.log, self.args)
-
-
-class TestConfig(MockerTestCase):
-    def setUp(self):
-        super(TestConfig, self).setUp()
-        self.name = "ca-certs"
-        self.cloud_init = None
-        self.log = getLogger("TestNoConfig")
-        self.args = []
-
-        # Mock out the functions that actually modify the system
-        self.mock_add = self.mocker.replace(add_ca_certs, passthrough=False)
-        self.mock_update = self.mocker.replace(update_ca_certs,
-                                               passthrough=False)
-        self.mock_remove = self.mocker.replace(remove_default_ca_certs,
-                                               passthrough=False)
-        # Order must be correct
-        self.mocker.order()
-
-    def test_no_trusted_list(self):
-        """
-        Test that no certificates are written if the 'trusted' key is not
-        present.
-        """
-        config = {"ca-certs": {}}
-
-        # No functions should be called
-        self.mock_update()
-        self.mocker.replay()
-
-        handle(self.name, config, self.cloud_init, self.log, self.args)
-
-    def test_empty_trusted_list(self):
-        """Test that no certificate are written if 'trusted' list is empty"""
-        config = {"ca-certs": {"trusted": []}}
-
-        # No functions should be called
-        self.mock_update()
-        self.mocker.replay()
-
-        handle(self.name, config, self.cloud_init, self.log, self.args)
-
-    def test_single_trusted(self):
-        """Test that a single cert gets passed to add_ca_certs"""
-        config = {"ca-certs": {"trusted": ["CERT1"]}}
-
-        self.mock_add(["CERT1"])
-        self.mock_update()
-        self.mocker.replay()
-
-        handle(self.name, config, self.cloud_init, self.log, self.args)
-
-    def test_multiple_trusted(self):
-        """Test that multiple certs get passed to add_ca_certs"""
-        config = {"ca-certs": {"trusted": ["CERT1", "CERT2"]}}
-
-        self.mock_add(["CERT1", "CERT2"])
-        self.mock_update()
-        self.mocker.replay()
-
-        handle(self.name, config, self.cloud_init, self.log, self.args)
-
-    def test_remove_default_ca_certs(self):
-        """Test remove_defaults works as expected"""
-        config = {"ca-certs": {"remove-defaults": True}}
-
-        self.mock_remove()
-        self.mock_update()
-        self.mocker.replay()
-
-        handle(self.name, config, self.cloud_init, self.log, self.args)
-
-    def test_no_remove_defaults_if_false(self):
-        """Test remove_defaults is not called when config value is False"""
-        config = {"ca-certs": {"remove-defaults": False}}
-
-        self.mock_update()
-        self.mocker.replay()
-
-        handle(self.name, config, self.cloud_init, self.log, self.args)
-
-    def test_correct_order_for_remove_then_add(self):
-        """Test remove_defaults is not called when config value is False"""
-        config = {"ca-certs": {"remove-defaults": True, "trusted": ["CERT1"]}}
-
-        self.mock_remove()
-        self.mock_add(["CERT1"])
-        self.mock_update()
-        self.mocker.replay()
-
-        handle(self.name, config, self.cloud_init, self.log, self.args)
-
-
-class TestAddCaCerts(MockerTestCase):
-    def test_no_certs_in_list(self):
-        """Test that no certificate are written if not provided."""
-        self.mocker.replace(write_file, passthrough=False)
-        self.mocker.replay()
-
-        add_ca_certs([])
-
-    def test_single_cert(self):
-        """Test adding a single certificate to the trusted CAs"""
-        cert = "CERT1\nLINE2\nLINE3"
-
-        mock_write = self.mocker.replace(write_file, passthrough=False)
-        mock_write("/usr/share/ca-certificates/cloud-init-ca-certs.crt",
-                   cert, mode=0644)
-        mock_write("/etc/ca-certificates.conf",
-                   "\ncloud-init-ca-certs.crt", omode="a")
-        self.mocker.replay()
-
-        add_ca_certs([cert])
-
-    def test_multiple_certs(self):
-        """Test adding multiple certificates to the trusted CAs"""
-        certs = ["CERT1\nLINE2\nLINE3", "CERT2\nLINE2\nLINE3"]
-        expected_cert_file = "\n".join(certs)
-
-        mock_write = self.mocker.replace(write_file, passthrough=False)
-        mock_write("/usr/share/ca-certificates/cloud-init-ca-certs.crt",
-                   expected_cert_file, mode=0644)
-        mock_write("/etc/ca-certificates.conf",
-                   "\ncloud-init-ca-certs.crt", omode="a")
-        self.mocker.replay()
-
-        add_ca_certs(certs)
-
-
-class TestUpdateCaCerts(MockerTestCase):
-    def test_commands(self):
-        mock_check_call = self.mocker.replace("subprocess.check_call",
-                                              passthrough=False)
-        mock_check_call(["update-ca-certificates"])
-        self.mocker.replay()
-
-        update_ca_certs()
-
-
-class TestRemoveDefaultCaCerts(MockerTestCase):
-    def test_commands(self):
-        mock_delete_dir_contents = self.mocker.replace(delete_dir_contents,
-                                                       passthrough=False)
-        mock_write = self.mocker.replace(write_file, passthrough=False)
-
-        mock_delete_dir_contents("/usr/share/ca-certificates/")
-        mock_delete_dir_contents("/etc/ssl/certs/")
-        mock_write("/etc/ca-certificates.conf", "", mode=0644)
-        self.mocker.replay()
-
-        remove_default_ca_certs()
-- 
cgit v1.2.3


From 149e58e715dba9c6c332ac12ddc4cca6609cbb41 Mon Sep 17 00:00:00 2001
From: Mike Milner <mike.milner@canonical.com>
Date: Tue, 21 Feb 2012 15:17:02 -0400
Subject: Add tests for various frequencies.

---
 tests/unittests/test__init__.py | 61 +++++++++++++++++++++++++++++++++++++++--
 1 file changed, 58 insertions(+), 3 deletions(-)

diff --git a/tests/unittests/test__init__.py b/tests/unittests/test__init__.py
index f18e39b8..79df8e72 100644
--- a/tests/unittests/test__init__.py
+++ b/tests/unittests/test__init__.py
@@ -86,6 +86,61 @@ class TestPartwalkerHandleHandler(MockerTestCase):
         partwalker_handle_handler(self.data, self.ctype, self.filename, self.payload)
 
 
-class TestHandlerHandlePart(TestCase):
-    def test_dummy(self):
-        self.assertTrue(False)
+class TestHandlerHandlePart(MockerTestCase):
+    def setUp(self):
+        self.data = "fake data"
+        self.ctype = "fake ctype"
+        self.filename = "fake filename"
+        self.payload = "fake payload"
+        self.frequency = "once-per-instance"
+
+    def test_normal_version_1(self):
+        """C{handle_part} is called without frequency for C{handler_version} == 1"""
+        # Build a mock part-handler module
+        mod_mock = self.mocker.mock()
+        getattr(mod_mock, "frequency")
+        self.mocker.result("once-per-instance")
+        getattr(mod_mock, "handler_version")
+        self.mocker.result(1)
+        mod_mock.handle_part(self.data, self.ctype, self.filename, self.payload)
+        self.mocker.replay()
+        
+        handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency)
+
+    def test_normal_version_2(self):
+        """C{handle_part} is called with frequency for C{handler_version} == 2"""
+        # Build a mock part-handler module
+        mod_mock = self.mocker.mock()
+        getattr(mod_mock, "frequency")
+        self.mocker.result("once-per-instance")
+        getattr(mod_mock, "handler_version")
+        self.mocker.result(2)
+        mod_mock.handle_part(self.data, self.ctype, self.filename, self.payload, self.frequency)
+        self.mocker.replay()
+        
+        handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency)
+
+    def test_modfreq_per_always(self):
+        """C{handle_part} is called regardless of frequency if nofreq is always."""
+        self.frequency = "once"
+        # Build a mock part-handler module
+        mod_mock = self.mocker.mock()
+        getattr(mod_mock, "frequency")
+        self.mocker.result("always")
+        getattr(mod_mock, "handler_version")
+        self.mocker.result(2)
+        mod_mock.handle_part(self.data, self.ctype, self.filename, self.payload, self.frequency)
+        self.mocker.replay()
+        
+        handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency)
+
+    def test_no_handle_when_modfreq_once(self):
+        """C{handle_part} is not called if frequency is once"""
+        self.frequency = "once"
+        # Build a mock part-handler module
+        mod_mock = self.mocker.mock()
+        getattr(mod_mock, "frequency")
+        self.mocker.result("once-per-instance")
+        self.mocker.replay()
+        
+        handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency)
-- 
cgit v1.2.3


From 8b17caade46cf84050961e24a0006386dbe96669 Mon Sep 17 00:00:00 2001
From: Mike Milner <mike.milner@canonical.com>
Date: Tue, 21 Feb 2012 15:26:08 -0400
Subject: Add test and fix for catching exceptions.

---
 cloudinit/__init__.py           | 13 ++++++++-----
 tests/unittests/test__init__.py | 20 ++++++++++++++++++++
 2 files changed, 28 insertions(+), 5 deletions(-)

diff --git a/cloudinit/__init__.py b/cloudinit/__init__.py
index 7a34e053..4338b46f 100644
--- a/cloudinit/__init__.py
+++ b/cloudinit/__init__.py
@@ -572,10 +572,14 @@ def handler_handle_part(mod, data, ctype, filename, payload, frequency):
     if not (modfreq == per_always or
             (frequency == per_instance and modfreq == per_instance)):
         return
-    if mod.handler_version == 1:
-        mod.handle_part(data, ctype, filename, payload)
-    else:
-        mod.handle_part(data, ctype, filename, payload, frequency)
+    try:
+        if mod.handler_version == 1:
+            mod.handle_part(data, ctype, filename, payload)
+        else:
+            mod.handle_part(data, ctype, filename, payload, frequency)
+    except:
+        util.logexc(log)
+        traceback.print_exc(file=sys.stderr)
 
 
 def partwalker_handle_handler(pdata, _ctype, _filename, payload):
@@ -594,7 +598,6 @@ def partwalker_handle_handler(pdata, _ctype, _filename, payload):
     except:
         util.logexc(log)
         traceback.print_exc(file=sys.stderr)
-        return
 
 
 def partwalker_callback(pdata, ctype, filename, payload):
diff --git a/tests/unittests/test__init__.py b/tests/unittests/test__init__.py
index 79df8e72..f1818e9c 100644
--- a/tests/unittests/test__init__.py
+++ b/tests/unittests/test__init__.py
@@ -144,3 +144,23 @@ class TestHandlerHandlePart(MockerTestCase):
         self.mocker.replay()
         
         handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency)
+
+    def test_exception_is_caught(self):
+        """Exceptions within C{handle_part} are caught and logged."""
+        # Build a mock part-handler module
+        mod_mock = self.mocker.mock()
+        getattr(mod_mock, "frequency")
+        self.mocker.result("once-per-instance")
+        getattr(mod_mock, "handler_version")
+        self.mocker.result(1)
+        mod_mock.handle_part(self.data, self.ctype, self.filename, self.payload)
+        self.mocker.throw(Exception())
+        # Mock log function
+        logexc_mock = self.mocker.replace(logexc, passthrough=False)
+        logexc_mock(ANY)
+        # Mock the print_exc function
+        print_exc_mock = self.mocker.replace("traceback.print_exc", passthrough=False)
+        print_exc_mock(ARGS, KWARGS)
+        self.mocker.replay()
+        
+        handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency)
-- 
cgit v1.2.3


From e8a3e39c1a6356460418d45f5b24f29b3fe6f20b Mon Sep 17 00:00:00 2001
From: Mike Milner <mike.milner@canonical.com>
Date: Tue, 21 Feb 2012 15:35:04 -0400
Subject: Lint fixes.

---
 cloudinit/__init__.py           |  1 -
 tests/unittests/test__init__.py | 95 ++++++++++++++++++++++++++---------------
 2 files changed, 60 insertions(+), 36 deletions(-)

diff --git a/cloudinit/__init__.py b/cloudinit/__init__.py
index 4338b46f..82390eeb 100644
--- a/cloudinit/__init__.py
+++ b/cloudinit/__init__.py
@@ -60,7 +60,6 @@ import cPickle
 import sys
 import os.path
 import errno
-import pwd
 import subprocess
 import yaml
 import logging
diff --git a/tests/unittests/test__init__.py b/tests/unittests/test__init__.py
index f1818e9c..d273748a 100644
--- a/tests/unittests/test__init__.py
+++ b/tests/unittests/test__init__.py
@@ -1,12 +1,8 @@
-from unittest import TestCase
 from mocker import MockerTestCase, ANY, ARGS, KWARGS
-from tempfile import mkdtemp
-from shutil import rmtree
 import os
-import stat
-import sys
 
-from cloudinit import partwalker_handle_handler, handler_handle_part, handler_register
+from cloudinit import (partwalker_handle_handler, handler_handle_part,
+                       handler_register)
 from cloudinit.util import write_file, logexc
 
 
@@ -19,9 +15,11 @@ class TestPartwalkerHandleHandler(MockerTestCase):
             "handlers": [],
             "data": None}
 
-        self.expected_module_name = "part-handler-%03d" % self.data["handlercount"]
+        self.expected_module_name = "part-handler-%03d" % (
+            self.data["handlercount"],)
         expected_file_name = "%s.py" % self.expected_module_name
-        expected_file_fullname = os.path.join(self.data["handlerdir"], expected_file_name)
+        expected_file_fullname = os.path.join(self.data["handlerdir"],
+                                              expected_file_name)
         self.module_fake = "fake module handle"
         self.ctype = None
         self.filename = None
@@ -38,12 +36,15 @@ class TestPartwalkerHandleHandler(MockerTestCase):
         import_mock(self.expected_module_name)
         self.mocker.result(self.module_fake)
         # Mock the handle_register function
-        handle_reg_mock = self.mocker.replace(handler_register, passthrough=False)
-        handle_reg_mock(self.module_fake, self.data["handlers"], self.data["data"], self.data["frequency"])
+        handle_reg_mock = self.mocker.replace(handler_register,
+                                              passthrough=False)
+        handle_reg_mock(self.module_fake, self.data["handlers"],
+                        self.data["data"], self.data["frequency"])
         # Activate mocks
         self.mocker.replay()
 
-        partwalker_handle_handler(self.data, self.ctype, self.filename, self.payload)
+        partwalker_handle_handler(self.data, self.ctype, self.filename,
+                                  self.payload)
 
         self.assertEqual(1, self.data["handlercount"])
 
@@ -57,12 +58,14 @@ class TestPartwalkerHandleHandler(MockerTestCase):
         logexc_mock = self.mocker.replace(logexc, passthrough=False)
         logexc_mock(ANY)
         # Mock the print_exc function
-        print_exc_mock = self.mocker.replace("traceback.print_exc", passthrough=False)
+        print_exc_mock = self.mocker.replace("traceback.print_exc",
+                                             passthrough=False)
         print_exc_mock(ARGS, KWARGS)
         # Activate mocks
         self.mocker.replay()
 
-        partwalker_handle_handler(self.data, self.ctype, self.filename, self.payload)
+        partwalker_handle_handler(self.data, self.ctype, self.filename,
+                                  self.payload)
 
     def test_attribute_error(self):
         """Payload gets written to file and added to C{pdata}."""
@@ -71,19 +74,23 @@ class TestPartwalkerHandleHandler(MockerTestCase):
         import_mock(self.expected_module_name)
         self.mocker.result(self.module_fake)
         # Mock the handle_register function
-        handle_reg_mock = self.mocker.replace(handler_register, passthrough=False)
-        handle_reg_mock(self.module_fake, self.data["handlers"], self.data["data"], self.data["frequency"])
+        handle_reg_mock = self.mocker.replace(handler_register,
+                                              passthrough=False)
+        handle_reg_mock(self.module_fake, self.data["handlers"],
+                        self.data["data"], self.data["frequency"])
         self.mocker.throw(AttributeError())
         # Mock log function
         logexc_mock = self.mocker.replace(logexc, passthrough=False)
         logexc_mock(ANY)
         # Mock the print_exc function
-        print_exc_mock = self.mocker.replace("traceback.print_exc", passthrough=False)
+        print_exc_mock = self.mocker.replace("traceback.print_exc",
+                                             passthrough=False)
         print_exc_mock(ARGS, KWARGS)
         # Activate mocks
         self.mocker.replay()
 
-        partwalker_handle_handler(self.data, self.ctype, self.filename, self.payload)
+        partwalker_handle_handler(self.data, self.ctype, self.filename,
+                                  self.payload)
 
 
 class TestHandlerHandlePart(MockerTestCase):
@@ -95,33 +102,45 @@ class TestHandlerHandlePart(MockerTestCase):
         self.frequency = "once-per-instance"
 
     def test_normal_version_1(self):
-        """C{handle_part} is called without frequency for C{handler_version} == 1"""
+        """
+        C{handle_part} is called without C{frequency} for
+        C{handler_version} == 1.
+        """
         # Build a mock part-handler module
         mod_mock = self.mocker.mock()
         getattr(mod_mock, "frequency")
         self.mocker.result("once-per-instance")
         getattr(mod_mock, "handler_version")
         self.mocker.result(1)
-        mod_mock.handle_part(self.data, self.ctype, self.filename, self.payload)
+        mod_mock.handle_part(self.data, self.ctype, self.filename,
+                             self.payload)
         self.mocker.replay()
-        
-        handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency)
+
+        handler_handle_part(mod_mock, self.data, self.ctype, self.filename,
+                            self.payload, self.frequency)
 
     def test_normal_version_2(self):
-        """C{handle_part} is called with frequency for C{handler_version} == 2"""
+        """
+        C{handle_part} is called with C{frequency} for
+        C{handler_version} == 2.
+        """
         # Build a mock part-handler module
         mod_mock = self.mocker.mock()
         getattr(mod_mock, "frequency")
         self.mocker.result("once-per-instance")
         getattr(mod_mock, "handler_version")
         self.mocker.result(2)
-        mod_mock.handle_part(self.data, self.ctype, self.filename, self.payload, self.frequency)
+        mod_mock.handle_part(self.data, self.ctype, self.filename,
+                             self.payload, self.frequency)
         self.mocker.replay()
-        
-        handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency)
+
+        handler_handle_part(mod_mock, self.data, self.ctype, self.filename,
+                            self.payload, self.frequency)
 
     def test_modfreq_per_always(self):
-        """C{handle_part} is called regardless of frequency if nofreq is always."""
+        """
+        C{handle_part} is called regardless of frequency if nofreq is always.
+        """
         self.frequency = "once"
         # Build a mock part-handler module
         mod_mock = self.mocker.mock()
@@ -129,10 +148,12 @@ class TestHandlerHandlePart(MockerTestCase):
         self.mocker.result("always")
         getattr(mod_mock, "handler_version")
         self.mocker.result(2)
-        mod_mock.handle_part(self.data, self.ctype, self.filename, self.payload, self.frequency)
+        mod_mock.handle_part(self.data, self.ctype, self.filename,
+                             self.payload, self.frequency)
         self.mocker.replay()
-        
-        handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency)
+
+        handler_handle_part(mod_mock, self.data, self.ctype, self.filename,
+                            self.payload, self.frequency)
 
     def test_no_handle_when_modfreq_once(self):
         """C{handle_part} is not called if frequency is once"""
@@ -142,8 +163,9 @@ class TestHandlerHandlePart(MockerTestCase):
         getattr(mod_mock, "frequency")
         self.mocker.result("once-per-instance")
         self.mocker.replay()
-        
-        handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency)
+
+        handler_handle_part(mod_mock, self.data, self.ctype, self.filename,
+                            self.payload, self.frequency)
 
     def test_exception_is_caught(self):
         """Exceptions within C{handle_part} are caught and logged."""
@@ -153,14 +175,17 @@ class TestHandlerHandlePart(MockerTestCase):
         self.mocker.result("once-per-instance")
         getattr(mod_mock, "handler_version")
         self.mocker.result(1)
-        mod_mock.handle_part(self.data, self.ctype, self.filename, self.payload)
+        mod_mock.handle_part(self.data, self.ctype, self.filename,
+                             self.payload)
         self.mocker.throw(Exception())
         # Mock log function
         logexc_mock = self.mocker.replace(logexc, passthrough=False)
         logexc_mock(ANY)
         # Mock the print_exc function
-        print_exc_mock = self.mocker.replace("traceback.print_exc", passthrough=False)
+        print_exc_mock = self.mocker.replace("traceback.print_exc",
+                                             passthrough=False)
         print_exc_mock(ARGS, KWARGS)
         self.mocker.replay()
-        
-        handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency)
+
+        handler_handle_part(mod_mock, self.data, self.ctype, self.filename,
+                            self.payload, self.frequency)
-- 
cgit v1.2.3


From f54e9394e9d9dd0496d8084f9ca9ff5abee5f41c Mon Sep 17 00:00:00 2001
From: Mike Milner <mike.milner@canonical.com>
Date: Tue, 21 Feb 2012 15:43:53 -0400
Subject: Cleanups.

---
 cloudinit/__init__.py           |  3 +--
 tests/unittests/test__init__.py | 12 ++++++++----
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/cloudinit/__init__.py b/cloudinit/__init__.py
index 82390eeb..f3541ee5 100644
--- a/cloudinit/__init__.py
+++ b/cloudinit/__init__.py
@@ -589,11 +589,10 @@ def partwalker_handle_handler(pdata, _ctype, _filename, payload):
     modfname = modname + ".py"
     util.write_file("%s/%s" % (pdata['handlerdir'], modfname), payload, 0600)
 
-    pdata['handlercount'] = curcount + 1
-
     try:
         mod = __import__(modname)
         handler_register(mod, pdata['handlers'], pdata['data'], frequency)
+        pdata['handlercount'] = curcount + 1
     except:
         util.logexc(log)
         traceback.print_exc(file=sys.stderr)
diff --git a/tests/unittests/test__init__.py b/tests/unittests/test__init__.py
index d273748a..e157fa77 100644
--- a/tests/unittests/test__init__.py
+++ b/tests/unittests/test__init__.py
@@ -49,7 +49,7 @@ class TestPartwalkerHandleHandler(MockerTestCase):
         self.assertEqual(1, self.data["handlercount"])
 
     def test_import_error(self):
-        """Payload gets written to file and added to C{pdata}."""
+        """Module import errors are logged. No handler added to C{pdata}"""
         # Mock the __import__ builtin
         import_mock = self.mocker.replace("__builtin__.__import__")
         import_mock(self.expected_module_name)
@@ -67,8 +67,10 @@ class TestPartwalkerHandleHandler(MockerTestCase):
         partwalker_handle_handler(self.data, self.ctype, self.filename,
                                   self.payload)
 
+        self.assertEqual(0, self.data["handlercount"])
+
     def test_attribute_error(self):
-        """Payload gets written to file and added to C{pdata}."""
+        """Attribute errors are logged. No handler added to C{pdata}"""
         # Mock the __import__ builtin
         import_mock = self.mocker.replace("__builtin__.__import__")
         import_mock(self.expected_module_name)
@@ -92,6 +94,8 @@ class TestPartwalkerHandleHandler(MockerTestCase):
         partwalker_handle_handler(self.data, self.ctype, self.filename,
                                   self.payload)
 
+        self.assertEqual(0, self.data["handlercount"])
+
 
 class TestHandlerHandlePart(MockerTestCase):
     def setUp(self):
@@ -147,9 +151,9 @@ class TestHandlerHandlePart(MockerTestCase):
         getattr(mod_mock, "frequency")
         self.mocker.result("always")
         getattr(mod_mock, "handler_version")
-        self.mocker.result(2)
+        self.mocker.result(1)
         mod_mock.handle_part(self.data, self.ctype, self.filename,
-                             self.payload, self.frequency)
+                             self.payload)
         self.mocker.replay()
 
         handler_handle_part(mod_mock, self.data, self.ctype, self.filename,
-- 
cgit v1.2.3


From dd628f06f9661ae3b9a72a95d744dfbb5244c173 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Tue, 28 Feb 2012 18:34:04 -0500
Subject: address change in name of lxc-is-container to running-in-container

Also improves the logic in is_container following ubuntu's
/etc/init/container-detect.conf .

LP: #941955
---
 cloudinit/CloudConfig/cc_resizefs.py |  4 +--
 cloudinit/util.py                    | 67 ++++++++++++++++++++++++++++--------
 2 files changed, 55 insertions(+), 16 deletions(-)

diff --git a/cloudinit/CloudConfig/cc_resizefs.py b/cloudinit/CloudConfig/cc_resizefs.py
index 0186d4d2..c76cc664 100644
--- a/cloudinit/CloudConfig/cc_resizefs.py
+++ b/cloudinit/CloudConfig/cc_resizefs.py
@@ -49,8 +49,8 @@ def handle(_name, cfg, _cloud, log, args):
         dev = os.makedev(os.major(st_dev), os.minor(st_dev))
         os.mknod(devpth, 0400 | stat.S_IFBLK, dev)
     except:
-        if util.islxc():
-            log.debug("inside lxc, ignoring mknod failure in resizefs")
+        if util.is_container():
+            log.debug("inside container, ignoring mknod failure in resizefs")
             return
         log.warn("Failed to make device node to resize /")
         raise
diff --git a/cloudinit/util.py b/cloudinit/util.py
index 780578e2..c93a17c4 100644
--- a/cloudinit/util.py
+++ b/cloudinit/util.py
@@ -516,30 +516,69 @@ def dos2unix(string):
     return(string.replace('\r\n', '\n'))
 
 
-def islxc():
-    # is this host running lxc?
+def is_container():
+    # is this running in a cgroup other than /
+    for helper in ('running-in-container', 'lxc-is-container'):
+        try:
+            # try to run a helper program. if it returns true
+            # then we're inside a container. otherwise, no
+            sp = subprocess.Popen(helper, stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE)
+            sp.communicate(None)
+            return(sp.returncode == 0)
+        except OSError as e:
+            if e.errno != errno.ENOENT:
+                raise
+
+    # this code is largely from the logic in
+    # ubuntu's /etc/init/container-detect.conf
     try:
-        with open("/proc/1/cgroup") as f:
-            if f.read() == "/":
-                return True
+        # Detect old-style libvirt
+        # Detect OpenVZ containers
+        pid1env = get_proc_env(1)
+        if "container" in pid1env:
+            return True
+
+        if "LIBVIRT_LXC_UUID" in pid1env:
+            return True
+
     except IOError as e:
         if e.errno != errno.ENOENT:
-            raise
+            pass
+
+    # Detect OpenVZ containers
+    if os.path.isdir("/proc/vz") and not os.path.isdir("/proc/bc"):
+        return True
 
     try:
-        # try to run a program named 'lxc-is-container'. if it returns true,
-        # then we're inside a container. otherwise, no
-        sp = subprocess.Popen(['lxc-is-container'], stdout=subprocess.PIPE,
-                              stderr=subprocess.PIPE)
-        sp.communicate(None)
-        return(sp.returncode == 0)
-    except OSError as e:
+        # Detect Vserver containers
+        with open("/proc/self/status") as fp:
+            lines = fp.read().splitlines()
+            for line in lines:
+                if line.startswith("VxID:"):
+                    (_key, val) = line.strip().split(":", 1)
+                    if val != "0":
+                        return True
+    except IOError as e:
         if e.errno != errno.ENOENT:
-            raise
+            pass
 
     return False
 
 
+def get_proc_env(pid):
+    # return the environment in a dict that a given process id was started with
+    env = {}
+    with open("/proc/%s/environ" % pid) as fp:
+        toks = fp.read().split("\0")
+        for tok in toks:
+            if tok == "":
+                continue
+            (name, val) = tok.split("=", 1)
+            env[name] = val
+    return env
+
+
 def get_hostname_fqdn(cfg, cloud):
     # return the hostname and fqdn from 'cfg'.  If not found in cfg,
     # then fall back to data from cloud
-- 
cgit v1.2.3


From f7eba5ca8aaaccd6b88f40c5c6f30715bd185069 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Tue, 28 Feb 2012 18:48:58 -0500
Subject: DataSourceNoCloud: fix local cloud sources other than from devices

The purely local non-device (vfat/iso9660) sources were broken by the
last set of changes here.  This restores them to functional.

If the seed is from a device, then the default behavior is to be 'net' mode.

For seed via cmdline, the user can specify 'ds=nocloud-net' and for
seed via filesystem seed dir, they can just populate the other directory.

To make it easier, when attaching a seed device, the user does not need
to specify 'dsmode' of 'net' in the metadata file.  They still can, but that is
the default.  It seems that that is more likely to be what is desired.

LP: #942695
---
 cloudinit/DataSourceNoCloud.py | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/cloudinit/DataSourceNoCloud.py b/cloudinit/DataSourceNoCloud.py
index 1e28edbd..62ecc088 100644
--- a/cloudinit/DataSourceNoCloud.py
+++ b/cloudinit/DataSourceNoCloud.py
@@ -44,7 +44,7 @@ class DataSourceNoCloud(DataSource.DataSource):
 
     def get_data(self):
         defaults = {
-            "instance-id": "nocloud", "dsmode": "net"
+            "instance-id": "nocloud", "dsmode": self.dsmode
         }
 
         found = []
@@ -80,6 +80,14 @@ class DataSourceNoCloud(DataSource.DataSource):
                     util.read_seeded)
                 md = util.mergedict(newmd, md)
                 ud = newud
+
+                # for seed from a device, the default mode is 'net'.
+                # that is more likely to be what is desired.
+                # If they want dsmode of local, then they must
+                # specify that.
+                if 'dsmode' not in md:
+                    md['dsmode'] = "net"
+
                 log.debug("using data from %s" % dev)
                 found.append(dev)
                 break
-- 
cgit v1.2.3


From a805702b98bbcafdf0b61c51a483e5f98b2bcab2 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Tue, 28 Feb 2012 19:12:33 -0500
Subject: fix docstring for is_container

---
 cloudinit/util.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/cloudinit/util.py b/cloudinit/util.py
index c93a17c4..c37f0316 100644
--- a/cloudinit/util.py
+++ b/cloudinit/util.py
@@ -517,7 +517,8 @@ def dos2unix(string):
 
 
 def is_container():
-    # is this running in a cgroup other than /
+    # is this code running in a container of some sort
+
     for helper in ('running-in-container', 'lxc-is-container'):
         try:
             # try to run a helper program. if it returns true
-- 
cgit v1.2.3


From 1676825c229e3939ec5b06c494bdcb56d39dddb1 Mon Sep 17 00:00:00 2001
From: Scott Moser <smoser@ubuntu.com>
Date: Thu, 1 Mar 2012 11:14:31 -0500
Subject: return public-keys as a list if it is a list

if public-keys in metadata are a list (rather than a dict), then
return them as such.

This allows populating NoCloud keys with:
public-keys:
 - ssh-rsa .... myname.mylabel
 - ssh-dsa .... myname.mylabel2

Or:
cat <<EOF
public-keys:
$(ssh-add -L | sed 's,^\(.*\), - "\1",')
EOF
---
 cloudinit/DataSource.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/cloudinit/DataSource.py b/cloudinit/DataSource.py
index f38e3b20..1bcb9c10 100644
--- a/cloudinit/DataSource.py
+++ b/cloudinit/DataSource.py
@@ -72,6 +72,9 @@ class DataSource:
         if isinstance(self.metadata['public-keys'], str):
             return([self.metadata['public-keys'], ])
 
+        if isinstance(self.metadata['public-keys'], list):
+            return(self.metadata['public-keys'])
+
         for _keyname, klist in self.metadata['public-keys'].items():
             # lp:506332 uec metadata service responds with
             # data that makes boto populate a string for 'klist' rather
-- 
cgit v1.2.3