456 lines
14 KiB
Python
456 lines
14 KiB
Python
# 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
|
|
|
|
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)
|