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/DataSourceOpenNebula.py (14553B)

# vi: ts=4 expandtab
#
#    Copyright (C) 2012 Canonical Ltd.
#    Copyright (C) 2012 Yahoo! Inc.
#    Copyright (C) 2012-2013 CERIT Scientific Cloud
#    Copyright (C) 2012-2013 OpenNebula.org
#    Copyright (C) 2014 Consejo Superior de Investigaciones Cientificas
#
#    Author: Scott Moser <scott.moser@canonical.com>
#    Author: Joshua Harlow <harlowja@yahoo-inc.com>
#    Author: Vlastimil Holer <xholer@mail.muni.cz>
#    Author: Javier Fontan <jfontan@opennebula.org>
#    Author: Enol Fernandez <enolfc@ifca.unican.es>
#
#    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 base64
import os
import pwd
import re
import string  # pylint: disable=W0402

from cloudinit import log as logging
from cloudinit import sources
from cloudinit import util

LOG = logging.getLogger(__name__)

DEFAULT_IID = "iid-dsopennebula"
DEFAULT_MODE = 'net'
DEFAULT_PARSEUSER = 'nobody'
CONTEXT_DISK_FILES = ["context.sh"]
VALID_DSMODES = ("local", "net", "disabled")

class DataSourceOpenNebula(sources.DataSource):
    def __init__(self, sys_cfg, distro, paths):
        sources.DataSource.__init__(self, sys_cfg, distro, paths)
        self.dsmode = 'local'
        self.seed = None
        self.seed_dir = os.path.join(paths.seed_dir, 'opennebula')

def __str__(self):
        root = sources.DataSource.__str__(self)
        return "%s [seed=%s][dsmode=%s]" % (root, self.seed, self.dsmode)

def get_data(self):
        defaults = {"instance-id": DEFAULT_IID}
        results = None
        seed = None

# decide parseuser for context.sh shell reader
        parseuser = DEFAULT_PARSEUSER
        if 'parseuser' in self.ds_cfg:
            parseuser = self.ds_cfg.get('parseuser')

candidates = [self.seed_dir]
        candidates.extend(find_candidate_devs())
        for cdev in candidates:
            try:
                if os.path.isdir(self.seed_dir):
                    results = read_context_disk_dir(cdev, asuser=parseuser)
                elif cdev.startswith("/dev"):
                    results = util.mount_cb(cdev, read_context_disk_dir,
                                            data=parseuser)
            except NonContextDiskDir:
                continue
            except BrokenContextDiskDir as exc:
                raise exc
            except util.MountFailedError:
                LOG.warn("%s was not mountable" % cdev)

if results:
                seed = cdev
                LOG.debug("found datasource in %s", cdev)
                break

if not seed:
            return False

# merge fetched metadata with datasource defaults
        md = results['metadata']
        md = util.mergemanydict([md, defaults])

# check for valid user specified dsmode
        user_dsmode = results['metadata'].get('DSMODE', None)
        if user_dsmode not in VALID_DSMODES + (None,):
            LOG.warn("user specified invalid mode: %s", user_dsmode)
            user_dsmode = None

# decide dsmode
        if user_dsmode:
            dsmode = user_dsmode
        elif self.ds_cfg.get('dsmode'):
            dsmode = self.ds_cfg.get('dsmode')
        else:
            dsmode = DEFAULT_MODE

if dsmode == "disabled":
            # most likely user specified
            return False

# apply static network configuration only in 'local' dsmode
        if ('network-interfaces' in results and self.dsmode == "local"):
            LOG.debug("Updating network interfaces from %s", self)
            self.distro.apply_network(results['network-interfaces'])

if dsmode != self.dsmode:
            LOG.debug("%s: not claiming datasource, dsmode=%s", self, dsmode)
            return False

self.seed = seed
        self.metadata = md
        self.userdata_raw = results.get('userdata')
        return True

def get_hostname(self, fqdn=False, resolve_ip=None):
        if resolve_ip is None:
            if self.dsmode == 'net':
                resolve_ip = True
            else:
                resolve_ip = False
        return sources.DataSource.get_hostname(self, fqdn, resolve_ip)

class DataSourceOpenNebulaNet(DataSourceOpenNebula):
    def __init__(self, sys_cfg, distro, paths):
        DataSourceOpenNebula.__init__(self, sys_cfg, distro, paths)
        self.dsmode = 'net'

class NonContextDiskDir(Exception):
    pass

class BrokenContextDiskDir(Exception):
    pass

class OpenNebulaNetwork(object):
    REG_DEV_MAC = re.compile(
                    r'^\d+: (eth\d+):.*?link\/ether (..:..:..:..:..:..) ?',
                    re.MULTILINE | re.DOTALL)

def __init__(self, ip, context):
        self.ip = ip
        self.context = context
        self.ifaces = self.get_ifaces()

def get_ifaces(self):
        return self.REG_DEV_MAC.findall(self.ip)

def mac2ip(self, mac):
        components = mac.split(':')[2:]
        return [str(int(c, 16)) for c in components]

def get_ip(self, dev, components):
        var_name = dev.upper() + '_IP'
        if var_name in self.context:
            return self.context[var_name]
        else:
            return '.'.join(components)

def get_mask(self, dev):
        var_name = dev.upper() + '_MASK'
        if var_name in self.context:
            return self.context[var_name]
        else:
            return '255.255.255.0'

def get_network(self, dev, components):
        var_name = dev.upper() + '_NETWORK'
        if var_name in self.context:
            return self.context[var_name]
        else:
            return '.'.join(components[:-1]) + '.0'

def get_gateway(self, dev):
        var_name = dev.upper() + '_GATEWAY'
        if var_name in self.context:
            return self.context[var_name]
        else:
            return None

def get_dns(self, dev):
        var_name = dev.upper() + '_DNS'
        if var_name in self.context:
            return self.context[var_name]
        else:
            return None

def get_domain(self, dev):
        var_name = dev.upper() + '_DOMAIN'
        if var_name in self.context:
            return self.context[var_name]
        else:
            return None

def gen_conf(self):
        global_dns = []
        if 'DNS' in self.context:
            global_dns.append(self.context['DNS'])

conf = []
        conf.append('auto lo')
        conf.append('iface lo inet loopback')
        conf.append('')

for i in self.ifaces:
            dev = i[0]
            mac = i[1]
            ip_components = self.mac2ip(mac)

conf.append('auto ' + dev)
            conf.append('iface ' + dev + ' inet static')
            conf.append('  address ' + self.get_ip(dev, ip_components))
            conf.append('  network ' + self.get_network(dev, ip_components))
            conf.append('  netmask ' + self.get_mask(dev))

gateway = self.get_gateway(dev)
            if gateway:
                conf.append('  gateway ' + gateway)

domain = self.get_domain(dev)
            if domain:
                conf.append('  dns-search ' + domain)

# add global DNS servers to all interfaces
            dns = self.get_dns(dev)
            if global_dns or dns:
                all_dns = global_dns
                if dns:
                    all_dns.append(dns)
                conf.append('  dns-nameservers ' + ' '.join(all_dns))

conf.append('')

return "\n".join(conf)

def find_candidate_devs():
    """
    Return a list of devices that may contain the context disk.
    """
    combined = []
    for f in ('LABEL=CONTEXT', 'LABEL=CDROM', 'TYPE=iso9660'):
        devs = util.find_devs_with(f)
        devs.sort()
        for d in devs:
            if d not in combined:
                combined.append(d)

return combined

def switch_user_cmd(user):
    return ['sudo', '-u', user]

def parse_shell_config(content, keylist=None, bash=None, asuser=None,
                       switch_user_cb=None):

if isinstance(bash, str):
        bash = [bash]
    elif bash is None:
        bash = ['bash', '-e']

if switch_user_cb is None:
        switch_user_cb = switch_user_cmd

# allvars expands to all existing variables by using '${!x*}' notation
    # where x is lower or upper case letters or '_'
    allvars = ["${!%s*}" % x for x in string.letters + "_"]

keylist_in = keylist
    if keylist is None:
        keylist = allvars
        keylist_in = []

setup = '\n'.join(('__v="";', '',))

def varprinter(vlist):
        # output '\0'.join(['_start_', key=value NULL for vars in vlist]
        return '\n'.join((
            'printf "%s\\0" _start_',
            'for __v in %s; do' % ' '.join(vlist),
            '   printf "%s=%s\\0" "$__v" "${!__v}";',
            'done',
            ''
        ))

# the rendered 'bcmd' is bash syntax that does
    # setup: declare variables we use (so they show up in 'all')
    # varprinter(allvars): print all variables known at beginning
    # content: execute the provided content
    # varprinter(keylist): print all variables known after content
    #
    # output is then a null terminated array of:
    #   literal '_start_'
    #   key=value (for each preset variable)
    #   literal '_start_'
    #   key=value (for each post set variable)
    bcmd = ('unset IFS\n' +
            setup +
            varprinter(allvars) +
            '{\n%s\n\n:\n} > /dev/null\n' % content +
            'unset IFS\n' +
            varprinter(keylist) + "\n")

cmd = []
    if asuser is not None:
        cmd = switch_user_cb(asuser)

cmd.extend(bash)

(output, _error) = util.subp(cmd, data=bcmd)

# exclude vars in bash that change on their own or that we used
    excluded = ("RANDOM", "LINENO", "SECONDS", "_", "__v")
    preset = {}
    ret = {}
    target = None
    output = output[0:-1]  # remove trailing null

# go through output.  First _start_ is for 'preset', second for 'target'.
    # Add to target only things were changed and not in volitile
    for line in output.split("\x00"):
        try:
            (key, val) = line.split("=", 1)
            if target is preset:
                target[key] = val
            elif (key not in excluded and
                  (key in keylist_in or preset.get(key) != val)):
                ret[key] = val
        except ValueError:
            if line != "_start_":
                raise
            if target is None:
                target = preset
            elif target is preset:
                target = ret

return ret

def read_context_disk_dir(source_dir, asuser=None):
    """
    read_context_disk_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 NonContextDiskDir
    """
    found = {}
    for af in CONTEXT_DISK_FILES:
        fn = os.path.join(source_dir, af)
        if os.path.isfile(fn):
            found[af] = fn

if not found:
        raise NonContextDiskDir("%s: %s" % (source_dir, "no files found"))

context = {}
    results = {'userdata': None, 'metadata': {}}

if "context.sh" in found:
        if asuser is not None:
            try:
                pwd.getpwnam(asuser)
            except KeyError as e:
                raise BrokenContextDiskDir("configured user '%s' "
                                           "does not exist", asuser)
        try:
            with open(os.path.join(source_dir, 'context.sh'), 'r') as f:
                content = f.read().strip()

context = parse_shell_config(content, asuser=asuser)
        except util.ProcessExecutionError as e:
            raise BrokenContextDiskDir("Error processing context.sh: %s" % (e))
        except IOError as e:
            raise NonContextDiskDir("Error reading context.sh: %s" % (e))
    else:
        raise NonContextDiskDir("Missing context.sh")

if not context:
        return results

results['metadata'] = context

# process single or multiple SSH keys
    ssh_key_var = None
    if "SSH_KEY" in context:
        ssh_key_var = "SSH_KEY"
    elif "SSH_PUBLIC_KEY" in context:
        ssh_key_var = "SSH_PUBLIC_KEY"

if ssh_key_var:
        lines = context.get(ssh_key_var).splitlines()
        results['metadata']['public-keys'] = [l for l in lines
            if len(l) and not l.startswith("#")]

# custom hostname -- try hostname or leave cloud-init
    # itself create hostname from IP address later
    for k in ('HOSTNAME', 'PUBLIC_IP', 'IP_PUBLIC', 'ETH0_IP'):
        if k in context:
            results['metadata']['local-hostname'] = context[k]
            break

# raw user data
    if "USER_DATA" in context:
        results['userdata'] = context["USER_DATA"]
    elif "USERDATA" in context:
        results['userdata'] = context["USERDATA"]

# b64decode user data if necessary (default)
    if 'userdata' in results:
        encoding = context.get('USERDATA_ENCODING',
                               context.get('USER_DATA_ENCODING'))
        if encoding == "base64":
            try:
                results['userdata'] = base64.b64decode(results['userdata'])
            except TypeError:
                LOG.warn("Failed base64 decoding of userdata")

# generate static /etc/network/interfaces
    # only if there are any required context variables
    # http://opennebula.org/documentation:rel3.8:cong#network_configuration
    for k in context.keys():
        if re.match(r'^ETH\d+_IP$', k):
            (out, _) = util.subp(['/sbin/ip', 'link'])
            net = OpenNebulaNetwork(out, context)
            results['network-interfaces'] = net.gen_conf()
            break

return results

# Used to match classes to dependencies
datasources = [
    (DataSourceOpenNebula, (sources.DEP_FILESYSTEM, )),
    (DataSourceOpenNebulaNet, (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: