/usr/lib/python2.6/site-packages/cloudinit/sources
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
# Author: Joshua Harlow
# Author: Vlastimil Holer
# Author: Javier Fontan
# Author: Enol Fernandez
#
# 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 .
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)