FM / sources

/usr/lib/python2.6/site-packages/cloudinit/sources/

/usr/lib/python2.6/site-packages/cloudinit/sources

Name	Size	Mode	Actions
helpers/	-	0755	rm
DataSourceAliYun.py	1956	0644	edit dl rm
DataSourceAliYun.pyc	3094	0644	edit dl rm
DataSourceAliYun.pyo	3094	0644	edit dl rm
DataSourceAltCloud.py	9324	0644	edit dl rm
DataSourceAltCloud.pyc	8069	0644	edit dl rm
DataSourceAltCloud.pyo	8069	0644	edit dl rm
DataSourceAzure.py	20625	0644	edit dl rm
DataSourceAzure.pyc	20444	0644	edit dl rm
DataSourceAzure.pyo	20444	0644	edit dl rm
DataSourceCloudSigma.py	4811	0644	edit dl rm
DataSourceCloudSigma.pyc	5061	0644	edit dl rm
DataSourceCloudSigma.pyo	5061	0644	edit dl rm
DataSourceCloudStack.py	6955	0644	edit dl rm
DataSourceCloudStack.pyc	6538	0644	edit dl rm
DataSourceCloudStack.pyo	6538	0644	edit dl rm
DataSourceConfigDrive.py	9942	0644	edit dl rm
DataSourceConfigDrive.pyc	8463	0644	edit dl rm
DataSourceConfigDrive.pyo	8463	0644	edit dl rm
DataSourceEc2.py	13615	0644	edit dl rm
DataSourceEc2.pyc	12537	0644	edit dl rm
DataSourceEc2.pyo	12537	0644	edit dl rm
DataSourceGCE.py	4867	0644	edit dl rm
DataSourceGCE.pyc	4669	0644	edit dl rm
DataSourceGCE.pyo	4669	0644	edit dl rm
DataSourceMAAS.py	13663	0644	edit dl rm
DataSourceMAAS.pyc	13194	0644	edit dl rm
DataSourceMAAS.pyo	13194	0644	edit dl rm
DataSourceNoCloud.py	10215	0644	edit dl rm
DataSourceNoCloud.pyc	6890	0644	edit dl rm
DataSourceNoCloud.pyo	6890	0644	edit dl rm
DataSourceNone.py	1846	0644	edit dl rm
DataSourceNone.pyc	1887	0644	edit dl rm
DataSourceNone.pyo	1887	0644	edit dl rm
DataSourceOpenNebula.py	14553	0644	edit dl rm
DataSourceOpenNebula.pyc	13624	0644	edit dl rm
DataSourceOpenNebula.pyo	13624	0644	edit dl rm
DataSourceOpenStack.py	6643	0644	edit dl rm
DataSourceOpenStack.pyc	5806	0644	edit dl rm
DataSourceOpenStack.pyo	5806	0644	edit dl rm
DataSourceOVF.py	9395	0644	edit dl rm
DataSourceOVF.pyc	8598	0644	edit dl rm
DataSourceOVF.pyo	8598	0644	edit dl rm
DataSourceSmartOS.py	15375	0644	edit dl rm
DataSourceSmartOS.pyc	11650	0644	edit dl rm
DataSourceSmartOS.pyo	11650	0644	edit dl rm
__init__.py	10169	0644	edit dl rm
__init__.pyc	9085	0644	edit dl rm
__init__.pyo	9085	0644	edit dl rm

Edit: /usr/lib/python2.6/site-packages/cloudinit/sources/DataSourceEc2.py (13615B)

# vi: ts=4 expandtab
#
#    Copyright (C) 2009-2010 Canonical Ltd.
#    Copyright (C) 2012 Hewlett-Packard Development Company, L.P.
#    Copyright (C) 2012 Yahoo! Inc.
#
#    Author: Scott Moser <scott.moser@canonical.com>
#    Author: Juerg Hafliger <juerg.haefliger@hp.com>
#    Author: Joshua Harlow <harlowja@yahoo-inc.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 textwrap
import time

from cloudinit import ec2_utils as ec2
from cloudinit import log as logging
from cloudinit import sources
from cloudinit import url_helper as uhelp
from cloudinit import util

LOG = logging.getLogger(__name__)

# Which version we are requesting of the ec2 metadata apis
DEF_MD_VERSION = '2009-04-04'

STRICT_ID_PATH = ("datasource", "Ec2", "strict_id")
STRICT_ID_DEFAULT = "warn"

class Platforms(object):
    ALIYUN = "AliYun"
    AWS = "AWS"
    SEEDED = "Seeded"
    # UNKNOWN indicates no positive id.  If strict_id is 'warn' or 'false',
    # then an attempt at the Ec2 Metadata service will be made.
    UNKNOWN = "Unknown"
    # NO_EC2_METADATA indicates this platform does not have a Ec2 metadata
    # service available. No attempt at the Ec2 Metadata service will be made.
    NO_EC2_METADATA = "No-EC2-Metadata"

class DataSourceEc2(sources.DataSource):
    # Default metadata urls that will be used if none are provided
    # They will be checked for 'resolveability' and some of the
    # following may be discarded if they do not resolve
    metadata_urls = ["http://169.254.169.254", "http://instance-data.:8773"]
    _cloud_platform = None

def __init__(self, sys_cfg, distro, paths):
        sources.DataSource.__init__(self, sys_cfg, distro, paths)
        self.metadata_address = None
        self.seed_dir = os.path.join(paths.seed_dir, "ec2")
        self.api_ver = DEF_MD_VERSION

def get_data(self):
        seed_ret = {}
        if util.read_optional_seed(seed_ret, base=(self.seed_dir + "/")):
            self.userdata_raw = seed_ret['user-data']
            self.metadata = seed_ret['meta-data']
            LOG.debug("Using seeded ec2 data from %s", self.seed_dir)
            self._cloud_platform = Platforms.SEEDED
            return True

strict_mode, _sleep = read_strict_mode(
            util.get_cfg_by_path(self.sys_cfg, STRICT_ID_PATH,
                                 STRICT_ID_DEFAULT), ("warn", None))

LOG.debug("strict_mode: %s, cloud_platform=%s",
                  strict_mode, self.cloud_platform)
        if strict_mode == "true" and self.cloud_platform == Platforms.UNKNOWN:
            return False
        elif self.cloud_platform == Platforms.NO_EC2_METADATA:
            return False

try:
            if not self.wait_for_metadata_service():
                return False
            start_time = time.time()
            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 %.3f seconds",
                      time.time() - start_time)
            return True
        except Exception:
            util.logexc(LOG, "Failed reading from metadata address %s",
                        self.metadata_address)
            return False

@property
    def launch_index(self):
        if not self.metadata:
            return None
        return self.metadata.get('ami-launch-index')

def get_instance_id(self):
        return self.metadata['instance-id']

def _get_url_settings(self):
        mcfg = self.ds_cfg
        if not mcfg:
            mcfg = {}
        max_wait = 120
        try:
            max_wait = int(mcfg.get("max_wait", max_wait))
        except Exception:
            util.logexc(LOG, "Failed to get max wait. using %s", max_wait)

timeout = 50
        try:
            timeout = max(0, int(mcfg.get("timeout", timeout)))
        except Exception:
            util.logexc(LOG, "Failed to get timeout, using %s", timeout)

return (max_wait, timeout)

def wait_for_metadata_service(self):
        mcfg = self.ds_cfg
        if not mcfg:
            mcfg = {}

(max_wait, timeout) = self._get_url_settings()
        if max_wait <= 0:
            return False

# Remove addresses from the list that wont resolve.
        mdurls = mcfg.get("metadata_urls", self.metadata_urls)
        filtered = [x for x in mdurls if util.is_resolvable_url(x)]

if set(filtered) != set(mdurls):
            LOG.debug("Removed the following from metadata urls: %s",
                      list((set(mdurls) - set(filtered))))

if len(filtered):
            mdurls = filtered
        else:
            LOG.warn("Empty metadata url list! using default list")
            mdurls = self.metadata_urls

urls = []
        url2base = {}
        for url in mdurls:
            cur = "%s/%s/meta-data/instance-id" % (url, self.api_ver)
            urls.append(cur)
            url2base[cur] = url

start_time = time.time()
        url = uhelp.wait_for_url(urls=urls, max_wait=max_wait,
                                timeout=timeout, status_cb=LOG.warn)

if url:
            LOG.debug("Using metadata source: '%s'", url2base[url])
        else:
            LOG.critical("Giving up on md from %s after %s seconds",
                            urls, int(time.time() - start_time))

self.metadata_address = url2base.get(url)
        return bool(url)

def device_name_to_device(self, name):
        # Consult metadata service, that has
        #  ephemeral0: sdb
        # and return 'sdb' for input 'ephemeral0'
        if 'block-device-mapping' not in self.metadata:
            return None

# Example:
        # 'block-device-mapping':
        # {'ami': '/dev/sda1',
        # 'ephemeral0': '/dev/sdb',
        # 'root': '/dev/sda1'}
        found = None
        bdm_items = self.metadata['block-device-mapping'].iteritems()
        for (entname, device) in bdm_items:
            if entname == name:
                found = device
                break
            # LP: #513842 mapping in Euca has 'ephemeral' not 'ephemeral0'
            if entname == "ephemeral" and name == "ephemeral0":
                found = device

if found is None:
            LOG.debug("Unable to convert %s to a device", name)
            return None

ofound = found
        if not found.startswith("/"):
            found = "/dev/%s" % found

if os.path.exists(found):
            return found

remapped = self._remap_device(os.path.basename(found))
        if remapped:
            LOG.debug("Remapped device name %s => %s", found, remapped)
            return remapped

# On t1.micro, ephemeral0 will appear in block-device-mapping from
        # metadata, but it will not exist on disk (and never will)
        # at this point, we've verified that the path did not exist
        # in the special case of 'ephemeral0' return None to avoid bogus
        # fstab entry (LP: #744019)
        if name == "ephemeral0":
            return None
        return ofound

@property
    def availability_zone(self):
        try:
            return self.metadata['placement']['availability-zone']
        except KeyError:
            return None

@property
    def region(self):
        az = self.availability_zone
        if az is not None:
            return az[:-1]
        return None

@property
    def cloud_platform(self):
        if self._cloud_platform is None:
            self._cloud_platform = identify_platform()
        return self._cloud_platform

def activate(self, cfg, is_new_instance):
        if not is_new_instance:
            return
        if self.cloud_platform == Platforms.UNKNOWN:
            warn_if_necessary(
                util.get_cfg_by_path(cfg, STRICT_ID_PATH, STRICT_ID_DEFAULT))

def read_strict_mode(cfgval, default):
    try:
        return parse_strict_mode(cfgval)
    except ValueError as e:
        LOG.warn(e)
        return default

def parse_strict_mode(cfgval):
    # given a mode like:
    #    true, false, warn,[sleep]
    # return tuple with string mode (true|false|warn) and sleep.
    if cfgval is True:
        return 'true', None
    if cfgval is False:
        return 'false', None

if not cfgval:
        return 'warn', 0

mode, _, sleep = cfgval.partition(",")
    if mode not in ('true', 'false', 'warn'):
        raise ValueError(
            "Invalid mode '%s' in strict_id setting '%s': "
            "Expected one of 'true', 'false', 'warn'." % (mode, cfgval))

if sleep:
        try:
            sleep = int(sleep)
        except ValueError:
            raise ValueError("Invalid sleep '%s' in strict_id setting '%s': "
                             "not an integer" % (sleep, cfgval))
    else:
        sleep = None

return mode, sleep

def warn_if_necessary(cfgval):
    try:
        mode, sleep = parse_strict_mode(cfgval)
    except ValueError as e:
        LOG.warn(e)
        return

if mode == "false":
        return

show_warning(sleep)

def show_warning(sleep):
    message = textwrap.dedent("""
        ****************************************************************
        # This system is using the EC2 Metadata Service, but does not  #
        # appear to be running on Amazon EC2 or one of cloud-init's    #
        # known platforms that provide a EC2 Metadata service. In the  #
        # future, cloud-init may stop reading metadata from the EC2    #
        # Metadata Service unless the platform can be identified       #
        #                                                              #
        # If you are seeing this message, please file a bug against    #
        # cloud-init at https://bugs.launchpad.net/cloud-init/+filebug #
        # Make sure to include the cloud provider your instance is     #
        # running on.                                                  #
        #                                                              #
        # For more information see                                     #
        #   https://bugs.launchpad.net/cloud-init/+bug/1660385         #
        #                                                              #
        # After you have filed a bug, you can disable this warning by  #
        # launching your instance with the cloud-config below, or      #
        # putting that content into                                    #
        #    /etc/cloud/cloud.cfg.d/99-ec2-datasource.cfg              #
        #                                                              #
        # #cloud-config                                                #
        # datasource:                                                  #
        #  Ec2:                                                        #
        #   strict_id: false                                           #
        #                                                              #
        """)
    closemsg = ""
    if sleep:
        closemsg = "  [sleeping for %d seconds]  " % sleep
    message += closemsg.center(64, "*")
    print(message)
    LOG.warn(message)
    if sleep:
        time.sleep(sleep)

def identify_aws(data):
    # data is a dictionary returned by _collect_platform_data.
    if (data['uuid'].startswith('ec2') and
            (data['uuid_source'] == 'hypervisor' or
             data['uuid'] == data['serial'])):
            return Platforms.AWS

return None

def identify_platform():
    # identify the platform and return an entry in Platforms.
    data = _collect_platform_data()
    checks = (identify_aws, lambda x: Platforms.UNKNOWN)
    for checker in checks:
        try:
            result = checker(data)
            if result:
                return result
        except Exception as e:
            LOG.warn("calling %s with %s raised exception: %s",
                     checker, data, e)

def _collect_platform_data():
    # returns a dictionary with all lower case values:
    #   uuid: system-uuid from dmi or /sys/hypervisor
    #   uuid_source: 'hypervisor' (/sys/hypervisor/uuid) or 'dmi'
    #   serial: dmi 'system-serial-number' (/sys/.../product_serial)
    data = {}
    try:
        uuid = util.load_file("/sys/hypervisor/uuid").strip()
        data['uuid_source'] = 'hypervisor'
    except Exception:
        uuid = util.read_dmi_data('system-uuid')
        data['uuid_source'] = 'dmi'

if uuid is None:
        uuid = ''
    data['uuid'] = uuid.lower()

serial = util.read_dmi_data('system-serial-number')
    if serial is None:
        serial = ''

data['serial'] = serial.lower()

return data

# Used to match classes to dependencies
datasources = [
  (DataSourceEc2, (sources.DEP_FILESYSTEM, sources.DEP_NETWORK)),
]

# Return a list of data sources that match this set of dependencies
def get_datasource_list(depends):
    return sources.list_from_depends(depends, datasources)

cmd: