Merged trunk lp:cloud-init

7 files changed, 235 insertions, 129 deletions

diff --git a/cloudinit/sources/DataSourceAltCloud.py b/cloudinit/sources/DataSourceAltCloud.py
index 69c376a5..9812bdcb 100644
--- a/cloudinit/sources/DataSourceAltCloud.py
+++ b/cloudinit/sources/DataSourceAltCloud.py
@@ -47,7 +47,7 @@ META_DATA_NOT_SUPPORTED = {
     'instance-id': 455,
     'local-hostname': 'localhost',
     'placement': {},
-    }
+}
 
 
 def read_user_data_callback(mount_dir):
@@ -73,13 +73,11 @@ def read_user_data_callback(mount_dir):
 
     # First try deltacloud_user_data_file. On failure try user_data_file.
     try:
-        with open(deltacloud_user_data_file, 'r') as user_data_f:
-            user_data = user_data_f.read().strip()
-    except:
+        user_data = util.load_file(deltacloud_user_data_file).strip()
+    except IOError:
         try:
-            with open(user_data_file, 'r') as user_data_f:
-                user_data = user_data_f.read().strip()
-        except:
+            user_data = util.load_file(user_data_file).strip()
+        except IOError:
             util.logexc(LOG, ('Failed accessing user data file.'))
             return None
 
@@ -157,11 +155,10 @@ class DataSourceAltCloud(sources.DataSource):
 
         if os.path.exists(CLOUD_INFO_FILE):
             try:
-                cloud_info = open(CLOUD_INFO_FILE)
-                cloud_type = cloud_info.read().strip().upper()
-                cloud_info.close()
-            except:
-                util.logexc(LOG, 'Unable to access cloud info file.')
+                cloud_type = util.load_file(CLOUD_INFO_FILE).strip().upper()
+            except IOError:
+                util.logexc(LOG, 'Unable to access cloud info file at %s.',
+                            CLOUD_INFO_FILE)
                 return False
         else:
             cloud_type = self.get_cloud_type()
diff --git a/cloudinit/sources/DataSourceCloudStack.py b/cloudinit/sources/DataSourceCloudStack.py
index f7ffa7cb..82e1e130 100644
--- a/cloudinit/sources/DataSourceCloudStack.py
+++ b/cloudinit/sources/DataSourceCloudStack.py
@@ -3,10 +3,12 @@
 #    Copyright (C) 2012 Canonical Ltd.
 #    Copyright (C) 2012 Cosmin Luta
 #    Copyright (C) 2012 Yahoo! Inc.
+#    Copyright (C) 2012 Gerard Dethier
 #
 #    Author: Cosmin Luta <q4break@gmail.com>
 #    Author: Scott Moser <scott.moser@canonical.com>
 #    Author: Joshua Harlow <harlowja@yahoo-inc.com>
+#    Author: Gerard Dethier <g.dethier@gmail.com>
 #
 #    This program is free software: you can redistribute it and/or modify
 #    it under the terms of the GNU General Public License version 3, as
@@ -20,14 +22,10 @@
 #    You should have received a copy of the GNU General Public License
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from socket import inet_ntoa
-from struct import pack
-
 import os
 import time
 
-import boto.utils as boto_utils
-
+from cloudinit import ec2_utils as ec2
 from cloudinit import log as logging
 from cloudinit import sources
 from cloudinit import url_helper as uhelp
@@ -41,24 +39,12 @@ class DataSourceCloudStack(sources.DataSource):
         sources.DataSource.__init__(self, sys_cfg, distro, paths)
         self.seed_dir = os.path.join(paths.seed_dir, 'cs')
         # Cloudstack has its metadata/userdata URLs located at
-        # http://<default-gateway-ip>/latest/
+        # http://<virtual-router-ip>/latest/
         self.api_ver = 'latest'
-        gw_addr = self.get_default_gateway()
-        if not gw_addr:
-            raise RuntimeError("No default gateway found!")
-        self.metadata_address = "http://%s/" % (gw_addr)
-
-    def get_default_gateway(self):
-        """Returns the default gateway ip address in the dotted format."""
-        lines = util.load_file("/proc/net/route").splitlines()
-        for line in lines:
-            items = line.split("\t")
-            if items[1] == "00000000":
-                # Found the default route, get the gateway
-                gw = inet_ntoa(pack("<L", int(items[2], 16)))
-                LOG.debug("Found default route, gateway is %s", gw)
-                return gw
-        return None
+        vr_addr = get_vr_address()
+        if not vr_addr:
+            raise RuntimeError("No virtual router found!")
+        self.metadata_address = "http://%s/" % (vr_addr)
 
     def __str__(self):
         return util.obj_name(self)
@@ -91,7 +77,7 @@ class DataSourceCloudStack(sources.DataSource):
 
         (max_wait, timeout) = self._get_url_settings()
 
-        urls = [self.metadata_address]
+        urls = [self.metadata_address + "/latest/meta-data/instance-id"]
         start_time = time.time()
         url = uhelp.wait_for_url(urls=urls, max_wait=max_wait,
                                 timeout=timeout, status_cb=LOG.warn)
@@ -116,10 +102,10 @@ class DataSourceCloudStack(sources.DataSource):
             if not self.wait_for_metadata_service():
                 return False
             start_time = time.time()
-            self.userdata_raw = boto_utils.get_instance_userdata(self.api_ver,
-                None, self.metadata_address)
-            self.metadata = boto_utils.get_instance_metadata(self.api_ver,
+            self.userdata_raw = ec2.get_instance_userdata(self.api_ver,
                 self.metadata_address)
+            self.metadata = ec2.get_instance_metadata(self.api_ver,
+                                                      self.metadata_address)
             LOG.debug("Crawl of metadata service took %s seconds",
                       int(time.time() - start_time))
             return True
@@ -136,6 +122,28 @@ class DataSourceCloudStack(sources.DataSource):
         return self.metadata['availability-zone']
 
 
+def get_vr_address():
+    # get the address of the virtual router via dhcp responses
+    # see http://bit.ly/T76eKC for documentation on the virtual router.
+    dhclient_d = "/var/lib/dhclient"
+    addresses = set()
+    dhclient_files = os.listdir(dhclient_d)
+    for file_name in dhclient_files:
+        if file_name.endswith(".lease") or file_name.endswith(".leases"):
+            with open(os.path.join(dhclient_d, file_name), "r") as fd:
+                for line in fd:
+                    if "dhcp-server-identifier" in line:
+                        words = line.strip(" ;\r\n").split(" ")
+                        if len(words) > 2:
+                            dhcp = words[2]
+                            LOG.debug("Found DHCP identifier %s", dhcp)
+                            addresses.add(dhcp)
+    if len(addresses) != 1:
+        # No unique virtual router found
+        return None
+    return addresses.pop()
+
+
 # Used to match classes to dependencies
 datasources = [
   (DataSourceCloudStack, (sources.DEP_FILESYSTEM, sources.DEP_NETWORK)),
diff --git a/cloudinit/sources/DataSourceConfigDrive.py b/cloudinit/sources/DataSourceConfigDrive.py
index b8154367..c7826851 100644
--- a/cloudinit/sources/DataSourceConfigDrive.py
+++ b/cloudinit/sources/DataSourceConfigDrive.py
@@ -48,6 +48,7 @@ class DataSourceConfigDrive(sources.DataSource):
         self.dsmode = 'local'
         self.seed_dir = os.path.join(paths.seed_dir, 'config_drive')
         self.version = None
+        self.ec2_metadata = None
 
     def __str__(self):
         mstr = "%s [%s,ver=%s]" % (util.obj_name(self), self.dsmode,
@@ -55,6 +56,74 @@ class DataSourceConfigDrive(sources.DataSource):
         mstr += "[source=%s]" % (self.source)
         return mstr
 
+    def _ec2_name_to_device(self, name):
+        if not self.ec2_metadata:
+            return None
+        bdm = self.ec2_metadata.get('block-device-mapping', {})
+        for (ent_name, device) in bdm.items():
+            if name == ent_name:
+                return device
+        return None
+
+    def _os_name_to_device(self, name):
+        device = None
+        try:
+            criteria = 'LABEL=%s' % (name)
+            if name in ['swap']:
+                criteria = 'TYPE=%s' % (name)
+            dev_entries = util.find_devs_with(criteria)
+            if dev_entries:
+                device = dev_entries[0]
+        except util.ProcessExecutionError:
+            pass
+        return device
+
+    def _validate_device_name(self, device):
+        if not device:
+            return None
+        if not device.startswith("/"):
+            device = "/dev/%s" % device
+        if os.path.exists(device):
+            return device
+        # Durn, try adjusting the mapping
+        remapped = self._remap_device(os.path.basename(device))
+        if remapped:
+            LOG.debug("Remapped device name %s => %s", device, remapped)
+            return remapped
+        return None
+
+    def device_name_to_device(self, name):
+        # Translate a 'name' to a 'physical' device
+        if not name:
+            return None
+        # Try the ec2 mapping first
+        names = [name]
+        if name == 'root':
+            names.insert(0, 'ami')
+        if name == 'ami':
+            names.append('root')
+        device = None
+        LOG.debug("Using ec2 metadata lookup to find device %s", names)
+        for n in names:
+            device = self._ec2_name_to_device(n)
+            device = self._validate_device_name(device)
+            if device:
+                break
+        # Try the openstack way second
+        if not device:
+            LOG.debug("Using os lookup to find device %s", names)
+            for n in names:
+                device = self._os_name_to_device(n)
+                device = self._validate_device_name(device)
+                if device:
+                    break
+        # Ok give up...
+        if not device:
+            return None
+        else:
+            LOG.debug("Using cfg drive lookup mapped to device %s", device)
+            return device
+
     def get_data(self):
         found = None
         md = {}
@@ -85,6 +154,16 @@ class DataSourceConfigDrive(sources.DataSource):
         md = results['metadata']
         md = util.mergedict(md, DEFAULT_METADATA)
 
+        # Perform some metadata 'fixups'
+        #
+        # OpenStack uses the 'hostname' key
+        # while most of cloud-init uses the metadata
+        # 'local-hostname' key instead so if it doesn't
+        # exist we need to make sure its copied over.
+        for (tgt, src) in [('local-hostname', 'hostname')]:
+            if tgt not in md and src in md:
+                md[tgt] = md[src]
+
         user_dsmode = results.get('dsmode', None)
         if user_dsmode not in VALID_DSMODES + (None,):
             LOG.warn("user specified invalid mode: %s" % user_dsmode)
@@ -133,15 +212,17 @@ class DataSourceConfigDrive(sources.DataSource):
 
         self.source = found
         self.metadata = md
+        self.ec2_metadata = results.get('ec2-metadata')
         self.userdata_raw = results.get('userdata')
         self.version = results['cfgdrive_ver']
 
         return True
 
     def get_public_ssh_keys(self):
-        if not 'public-keys' in self.metadata:
-            return []
-        return self.metadata['public-keys']
+        name = "public_keys"
+        if self.version == 1:
+            name = "public-keys"
+        return sources.normalize_pubkey_data(self.metadata.get(name))
 
 
 class DataSourceConfigDriveNet(DataSourceConfigDrive):
@@ -217,7 +298,7 @@ def read_config_drive_dir_v2(source_dir, version="2012-08-10"):
         ('metadata',
          "openstack/%s/meta_data.json" % version, True, json.loads),
         ('userdata', "openstack/%s/user_data" % version, False, None),
-        ('ec2-metadata', "ec2/latest/metadata.json", False, json.loads),
+        ('ec2-metadata', "ec2/latest/meta-data.json", False, json.loads),
     )
 
     results = {'userdata': None}
@@ -227,19 +308,19 @@ def read_config_drive_dir_v2(source_dir, version="2012-08-10"):
         found = False
         if os.path.isfile(fpath):
             try:
-                with open(fpath) as fp:
-                    data = fp.read()
-            except Exception as exc:
-                raise BrokenConfigDriveDir("failed to read: %s" % fpath)
+                data = util.load_file(fpath)
+            except IOError:
+                raise BrokenConfigDriveDir("Failed to read: %s" % fpath)
             found = True
         elif required:
-            raise NonConfigDriveDir("missing mandatory %s" % fpath)
+            raise NonConfigDriveDir("Missing mandatory path: %s" % fpath)
 
         if found and process:
             try:
                 data = process(data)
             except Exception as exc:
-                raise BrokenConfigDriveDir("failed to process: %s" % fpath)
+                raise BrokenConfigDriveDir(("Failed to process "
+                                            "path: %s") % fpath)
 
         if found:
             results[name] = data
@@ -255,8 +336,7 @@ def read_config_drive_dir_v2(source_dir, version="2012-08-10"):
         # do not use os.path.join here, as content_path starts with /
         cpath = os.path.sep.join((source_dir, "openstack",
                                   "./%s" % item['content_path']))
-        with open(cpath) as fp:
-            return(fp.read())
+        return util.load_file(cpath)
 
     files = {}
     try:
@@ -270,7 +350,7 @@ def read_config_drive_dir_v2(source_dir, version="2012-08-10"):
         if item:
             results['network_config'] = read_content_path(item)
     except Exception as exc:
-        raise BrokenConfigDriveDir("failed to read file %s: %s" % (item, exc))
+        raise BrokenConfigDriveDir("Failed to read file %s: %s" % (item, exc))
 
     # to openstack, user can specify meta ('nova boot --meta=key=value') and
     # those will appear under metadata['meta'].
@@ -385,8 +465,7 @@ def get_previous_iid(paths):
     # hasn't declared itself found.
     fname = os.path.join(paths.get_cpath('data'), 'instance-id')
     try:
-        with open(fname) as fp:
-            return fp.read()
+        return util.load_file(fname)
     except IOError:
         return None
 
diff --git a/cloudinit/sources/DataSourceEc2.py b/cloudinit/sources/DataSourceEc2.py
index c7ad6d54..2db53446 100644
--- a/cloudinit/sources/DataSourceEc2.py
+++ b/cloudinit/sources/DataSourceEc2.py
@@ -23,8 +23,7 @@
 import os
 import time
 
-import boto.utils as boto_utils
-
+from cloudinit import ec2_utils as ec2
 from cloudinit import log as logging
 from cloudinit import sources
 from cloudinit import url_helper as uhelp
@@ -65,10 +64,10 @@ class DataSourceEc2(sources.DataSource):
             if not self.wait_for_metadata_service():
                 return False
             start_time = time.time()
-            self.userdata_raw = boto_utils.get_instance_userdata(self.api_ver,
-                None, self.metadata_address)
-            self.metadata = boto_utils.get_instance_metadata(self.api_ver,
+            self.userdata_raw = ec2.get_instance_userdata(self.api_ver,
                 self.metadata_address)
+            self.metadata = ec2.get_instance_metadata(self.api_ver,
+                                                      self.metadata_address)
             LOG.debug("Crawl of metadata service took %s seconds",
                        int(time.time() - start_time))
             return True
@@ -86,9 +85,6 @@ class DataSourceEc2(sources.DataSource):
     def get_instance_id(self):
         return self.metadata['instance-id']
 
-    def get_availability_zone(self):
-        return self.metadata['placement']['availability-zone']
-
     def _get_url_settings(self):
         mcfg = self.ds_cfg
         if not mcfg:
@@ -151,22 +147,6 @@ class DataSourceEc2(sources.DataSource):
         self.metadata_address = url2base.get(url)
         return bool(url)
 
-    def _remap_device(self, short_name):
-        # LP: #611137
-        # the metadata service may believe that devices are named 'sda'
-        # when the kernel named them 'vda' or 'xvda'
-        # we want to return the correct value for what will actually
-        # exist in this instance
-        mappings = {"sd": ("vd", "xvd")}
-        for (nfrom, tlist) in mappings.iteritems():
-            if not short_name.startswith(nfrom):
-                continue
-            for nto in tlist:
-                cand = "/dev/%s%s" % (nto, short_name[len(nfrom):])
-                if os.path.exists(cand):
-                    return cand
-        return None
-
     def device_name_to_device(self, name):
         # Consult metadata service, that has
         #  ephemeral0: sdb
@@ -214,19 +194,6 @@ class DataSourceEc2(sources.DataSource):
             return None
         return ofound
 
-    def is_vpc(self):
-        # See: https://bugs.launchpad.net/ubuntu/+source/cloud-init/+bug/615545
-        # Detect that the machine was launched in a VPC.
-        # But I did notice that when in a VPC, meta-data
-        # does not have public-ipv4 and public-hostname
-        # listed as a possibility.
-        ph = "public-hostname"
-        p4 = "public-ipv4"
-        if ((ph not in self.metadata or self.metadata[ph] == "") and
-            (p4 not in self.metadata or self.metadata[p4] == "")):
-            return True
-        return False
-
     @property
     def availability_zone(self):
         try:
diff --git a/cloudinit/sources/DataSourceMAAS.py b/cloudinit/sources/DataSourceMAAS.py
index c568d365..b55d8a21 100644
--- a/cloudinit/sources/DataSourceMAAS.py
+++ b/cloudinit/sources/DataSourceMAAS.py
@@ -18,6 +18,7 @@
 #    You should have received a copy of the GNU General Public License
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+from email.utils import parsedate
 import errno
 import oauth.oauth as oauth
 import os
@@ -46,6 +47,7 @@ class DataSourceMAAS(sources.DataSource):
         sources.DataSource.__init__(self, sys_cfg, distro, paths)
         self.base_url = None
         self.seed_dir = os.path.join(paths.seed_dir, 'maas')
+        self.oauth_clockskew = None
 
     def __str__(self):
         return "%s [%s]" % (util.obj_name(self), self.base_url)
@@ -95,11 +97,17 @@ class DataSourceMAAS(sources.DataSource):
                 return {}
 
         consumer_secret = mcfg.get('consumer_secret', "")
+
+        timestamp = None
+        if self.oauth_clockskew:
+            timestamp = int(time.time()) + self.oauth_clockskew
+
         return oauth_headers(url=url,
                              consumer_key=mcfg['consumer_key'],
                              token_key=mcfg['token_key'],
                              token_secret=mcfg['token_secret'],
-                             consumer_secret=consumer_secret)
+                             consumer_secret=consumer_secret,
+                             timestamp=timestamp)
 
     def wait_for_metadata_service(self, url):
         mcfg = self.ds_cfg
@@ -124,7 +132,7 @@ class DataSourceMAAS(sources.DataSource):
         check_url = "%s/%s/meta-data/instance-id" % (url, MD_VERSION)
         urls = [check_url]
         url = uhelp.wait_for_url(urls=urls, max_wait=max_wait,
-                                 timeout=timeout, status_cb=LOG.warn,
+                                 timeout=timeout, exception_cb=self._except_cb,
                                  headers_cb=self.md_headers)
 
         if url:
@@ -135,6 +143,26 @@ class DataSourceMAAS(sources.DataSource):
 
         return bool(url)
 
+    def _except_cb(self, msg, exception):
+        if not (isinstance(exception, urllib2.HTTPError) and
+                (exception.code == 403 or exception.code == 401)):
+            return
+        if 'date' not in exception.headers:
+            LOG.warn("date field not in %d headers" % exception.code)
+            return
+
+        date = exception.headers['date']
+
+        try:
+            ret_time = time.mktime(parsedate(date))
+        except:
+            LOG.warn("failed to convert datetime '%s'")
+            return
+
+        self.oauth_clockskew = int(ret_time - time.time())
+        LOG.warn("set oauth clockskew to %d" % self.oauth_clockskew)
+        return
+
 
 def read_maas_seed_dir(seed_d):
     """
@@ -229,13 +257,20 @@ def check_seed_contents(content, seed):
     return (userdata, md)
 
 
-def oauth_headers(url, consumer_key, token_key, token_secret, consumer_secret):
+def oauth_headers(url, consumer_key, token_key, token_secret, consumer_secret,
+                  timestamp=None):
     consumer = oauth.OAuthConsumer(consumer_key, consumer_secret)
     token = oauth.OAuthToken(token_key, token_secret)
+
+    if timestamp is None:
+        ts = int(time.time())
+    else:
+        ts = timestamp
+
     params = {
         'oauth_version': "1.0",
         'oauth_nonce': oauth.generate_nonce(),
-        'oauth_timestamp': int(time.time()),
+        'oauth_timestamp': ts,
         'oauth_token': token.key,
         'oauth_consumer_key': consumer.key,
     }
@@ -301,9 +336,7 @@ if __name__ == "__main__":
             'token_secret': args.tsec, 'consumer_secret': args.csec}
 
         if args.config:
-            import yaml
-            with open(args.config) as fp:
-                cfg = yaml.safe_load(fp)
+            cfg = util.read_conf(args.config)
             if 'datasource' in cfg:
                 cfg = cfg['datasource']['MAAS']
             for key in creds.keys():
@@ -312,7 +345,7 @@ if __name__ == "__main__":
 
         def geturl(url, headers_cb):
             req = urllib2.Request(url, data=None, headers=headers_cb(url))
-            return(urllib2.urlopen(req).read())
+            return (urllib2.urlopen(req).read())
 
         def printurl(url, headers_cb):
             print "== %s ==\n%s\n" % (url, geturl(url, headers_cb))
diff --git a/cloudinit/sources/DataSourceOVF.py b/cloudinit/sources/DataSourceOVF.py
index 771e64eb..e90150c6 100644
--- a/cloudinit/sources/DataSourceOVF.py
+++ b/cloudinit/sources/DataSourceOVF.py
@@ -204,9 +204,8 @@ def transport_iso9660(require_iso=True):
 
         try:
             # See if we can read anything at all...??
-            with open(fullp, 'rb') as fp:
-                fp.read(512)
-        except:
+            util.peek_file(fullp, 512)
+        except IOError:
             continue
 
         try:
diff --git a/cloudinit/sources/__init__.py b/cloudinit/sources/__init__.py
index a89f4703..f98493de 100644
--- a/cloudinit/sources/__init__.py
+++ b/cloudinit/sources/__init__.py
@@ -20,9 +20,8 @@
 #    You should have received a copy of the GNU General Public License
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from email.mime.multipart import MIMEMultipart
-
 import abc
+import os
 
 from cloudinit import importer
 from cloudinit import log as logging
@@ -101,32 +100,23 @@ class DataSource(object):
         return {}
 
     def get_public_ssh_keys(self):
-        keys = []
-
-        if not self.metadata or 'public-keys' not in self.metadata:
-            return keys
-
-        if isinstance(self.metadata['public-keys'], (basestring, str)):
-            return str(self.metadata['public-keys']).splitlines()
-
-        if isinstance(self.metadata['public-keys'], (list, set)):
-            return list(self.metadata['public-keys'])
-
-        if isinstance(self.metadata['public-keys'], (dict)):
-            for (_keyname, klist) in self.metadata['public-keys'].iteritems():
-                # lp:506332 uec metadata service responds with
-                # data that makes boto populate a string for 'klist' rather
-                # than a list.
-                if isinstance(klist, (str, basestring)):
-                    klist = [klist]
-                if isinstance(klist, (list, set)):
-                    for pkey in klist:
-                        # There is an empty string at
-                        # the end of the keylist, trim it
-                        if pkey:
-                            keys.append(pkey)
-
-        return keys
+        return normalize_pubkey_data(self.metadata.get('public-keys'))
+
+    def _remap_device(self, short_name):
+        # LP: #611137
+        # the metadata service may believe that devices are named 'sda'
+        # when the kernel named them 'vda' or 'xvda'
+        # we want to return the correct value for what will actually
+        # exist in this instance
+        mappings = {"sd": ("vd", "xvd")}
+        for (nfrom, tlist) in mappings.iteritems():
+            if not short_name.startswith(nfrom):
+                continue
+            for nto in tlist:
+                cand = "/dev/%s%s" % (nto, short_name[len(nfrom):])
+                if os.path.exists(cand):
+                    return cand
+        return None
 
     def device_name_to_device(self, _name):
         # translate a 'name' to a device
@@ -173,6 +163,7 @@ class DataSource(object):
             # make up a hostname (LP: #475354) in format ip-xx.xx.xx.xx
             lhost = self.metadata['local-hostname']
             if util.is_ipv4(lhost):
+<<<<<<< TREE
                 toks = []
                 if resolve_ip:
                     toks = util.gethostbyaddr(lhost)
@@ -181,6 +172,9 @@ class DataSource(object):
                     toks = toks.split('.')
                 else:
                     toks = ["ip-%s" % lhost.replace(".", "-")]
+=======
+                toks = ["ip-%s" % lhost.replace(".", "-")]
+>>>>>>> MERGE-SOURCE
             else:
                 toks = lhost.split(".")
 
@@ -200,6 +194,35 @@ class DataSource(object):
             availability_zone=self.availability_zone)
 
 
+def normalize_pubkey_data(pubkey_data):
+    keys = []
+
+    if not pubkey_data:
+        return keys
+
+    if isinstance(pubkey_data, (basestring, str)):
+        return str(pubkey_data).splitlines()
+
+    if isinstance(pubkey_data, (list, set)):
+        return list(pubkey_data)
+
+    if isinstance(pubkey_data, (dict)):
+        for (_keyname, klist) in pubkey_data.iteritems():
+            # lp:506332 uec metadata service responds with
+            # data that makes boto populate a string for 'klist' rather
+            # than a list.
+            if isinstance(klist, (str, basestring)):
+                klist = [klist]
+            if isinstance(klist, (list, set)):
+                for pkey in klist:
+                    # There is an empty string at
+                    # the end of the keylist, trim it
+                    if pkey:
+                        keys.append(pkey)
+
+    return keys
+
+
 def find_source(sys_cfg, distro, paths, ds_deps, cfg_list, pkg_list):
     ds_list = list_sources(cfg_list, ds_deps, pkg_list)
     ds_names = [util.obj_name(f) for f in ds_list]