253 lines
8.8 KiB
Python
253 lines
8.8 KiB
Python
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
|
|
|
# Copyright (C) 2012 Yahoo! Inc. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
from urlparse import urlunparse
|
|
import re
|
|
|
|
from devstack import date
|
|
from devstack import env
|
|
from devstack import settings
|
|
from devstack import shell as sh
|
|
from devstack import utils
|
|
|
|
from devstack.components import keystone
|
|
|
|
#general extraction cfg keys
|
|
CFG_MAKE = {
|
|
'ADMIN_PASSWORD': ('passwords', 'horizon_keystone_admin'),
|
|
'SERVICE_PASSWORD': ('passwords', 'service_password'),
|
|
'MYSQL_PASSWORD': ('passwords', 'sql'),
|
|
'RABBIT_PASSWORD': ('passwords', 'rabbit'),
|
|
'SERVICE_TOKEN': ('passwords', 'service_token'),
|
|
'FLAT_INTERFACE': ('nova', 'flat_interface'),
|
|
'HOST_IP': ('host', 'ip'),
|
|
}
|
|
|
|
#default ports
|
|
EC2_PORT = 8773
|
|
S3_PORT = 3333
|
|
|
|
#how we know if a line is an export or if it isn't (simpe edition)
|
|
EXP_PAT = re.compile("^\s*export\s+(.*?)=(.*?)$", re.IGNORECASE)
|
|
|
|
#how we unquote a string (simple edition)
|
|
QUOTED_PAT = re.compile(r"^\s*[\"](.*)[\"]\s*$")
|
|
|
|
|
|
class RcWriter(object):
|
|
def __init__(self, cfg):
|
|
self.cfg = cfg
|
|
|
|
def _make_export(self, export_name, value):
|
|
escaped_val = sh.shellquote(value)
|
|
full_line = "export %s=%s" % (export_name, escaped_val)
|
|
return full_line
|
|
|
|
def _make_dict_export(self, kvs):
|
|
lines = list()
|
|
for var_name in sorted(kvs.keys()):
|
|
var_value = kvs.get(var_name)
|
|
if var_value is not None:
|
|
lines.append(self._make_export(var_name, str(var_value)))
|
|
return lines
|
|
|
|
def _get_ec2_envs(self):
|
|
to_set = dict()
|
|
ip = self.cfg.get('host', 'ip')
|
|
ec2_url_default = urlunparse(('http', "%s:%s" % (ip, EC2_PORT), "services/Cloud", '', '', ''))
|
|
to_set['EC2_URL'] = self.cfg.getdefaulted('extern', 'ec2_url', ec2_url_default, auto_pw=False)
|
|
s3_url_default = urlunparse(('http', "%s:%s" % (ip, S3_PORT), "services/Cloud", '', '', ''))
|
|
to_set['S3_URL'] = self.cfg.getdefaulted('extern', 's3_url', s3_url_default, auto_pw=False)
|
|
to_set['EC2_CERT'] = self.cfg.get('extern', 'ec2_cert_fn', auto_pw=False)
|
|
to_set['EC2_USER_ID'] = self.cfg.get('extern', 'ec2_user_id', auto_pw=False)
|
|
return to_set
|
|
|
|
def _generate_ec2_env(self):
|
|
lines = list()
|
|
lines.append('# EC2 and/or S3 stuff')
|
|
lines.extend(self._make_dict_export(self._get_ec2_envs()))
|
|
lines.append("")
|
|
return lines
|
|
|
|
def _get_general_envs(self):
|
|
to_set = dict()
|
|
for (out_name, cfg_data) in CFG_MAKE.items():
|
|
(section, key) = (cfg_data)
|
|
to_set[out_name] = self.cfg.get(section, key, auto_pw=False)
|
|
return to_set
|
|
|
|
def _generate_general(self):
|
|
lines = list()
|
|
lines.append('# General stuff')
|
|
lines.extend(self._make_dict_export(self._get_general_envs()))
|
|
lines.append("")
|
|
return lines
|
|
|
|
def _generate_lines(self):
|
|
lines = list()
|
|
lines.append('# Generated on %s' % (date.rcf8222date()))
|
|
lines.append("")
|
|
lines.extend(self._generate_general())
|
|
lines.extend(self._generate_ec2_env())
|
|
lines.extend(self._generate_nova_env())
|
|
lines.extend(self._generate_os_env())
|
|
lines.extend(self._generate_euca_env())
|
|
lines.extend(self._generate_extern_inc())
|
|
lines.extend(self._generate_aliases())
|
|
return lines
|
|
|
|
def update(self, fn):
|
|
current_vars = RcReader().extract(fn)
|
|
possible_vars = dict()
|
|
possible_vars.update(self._get_general_envs())
|
|
possible_vars.update(self._get_ec2_envs())
|
|
possible_vars.update(self._get_os_envs())
|
|
possible_vars.update(self._get_euca_envs())
|
|
possible_vars.update(self._get_nova_envs())
|
|
new_vars = dict()
|
|
updated_vars = dict()
|
|
for (key, value) in possible_vars.items():
|
|
if value is not None:
|
|
if key in current_vars and (current_vars.get(key) != value):
|
|
updated_vars[key] = value
|
|
elif key not in current_vars:
|
|
new_vars[key] = value
|
|
if new_vars or updated_vars:
|
|
lines = list()
|
|
lines.append("")
|
|
lines.append('# Updated on %s' % (date.rcf8222date()))
|
|
lines.append("")
|
|
if new_vars:
|
|
lines.append('# New stuff')
|
|
lines.extend(self._make_dict_export(new_vars))
|
|
lines.append("")
|
|
if updated_vars:
|
|
lines.append('# Updated stuff')
|
|
lines.extend(self._make_dict_export(updated_vars))
|
|
lines.append("")
|
|
append_contents = utils.joinlinesep(*lines)
|
|
sh.append_file(fn, append_contents)
|
|
return len(new_vars) + len(updated_vars)
|
|
else:
|
|
return 0
|
|
|
|
def write(self, fn):
|
|
contents = utils.joinlinesep(*self._generate_lines())
|
|
sh.write_file(fn, contents)
|
|
|
|
def _get_os_envs(self):
|
|
key_params = keystone.get_shared_params(self.cfg)
|
|
to_set = dict()
|
|
to_set['OS_PASSWORD'] = key_params['ADMIN_PASSWORD']
|
|
to_set['OS_TENANT_NAME'] = key_params['DEMO_TENANT_NAME']
|
|
to_set['OS_USERNAME'] = key_params['DEMO_USER_NAME']
|
|
# this seems named weirdly the OS_AUTH_URL is the keystone SERVICE_ENDPOINT endpoint
|
|
# todo: describe more why this is the case
|
|
to_set['OS_AUTH_URL'] = key_params['SERVICE_ENDPOINT']
|
|
return to_set
|
|
|
|
def _generate_os_env(self):
|
|
lines = list()
|
|
lines.append('# Openstack stuff')
|
|
lines.extend(self._make_dict_export(self._get_os_envs()))
|
|
lines.append("")
|
|
return lines
|
|
|
|
def _generate_aliases(self):
|
|
lines = list()
|
|
lines.append('# Alias stuff')
|
|
export_inc = """
|
|
alias ec2-bundle-image="ec2-bundle-image --cert ${EC2_CERT} --privatekey ${EC2_PRIVATE_KEY} --user ${EC2_USER_ID} --ec2cert ${NOVA_CERT}"
|
|
alias ec2-upload-bundle="ec2-upload-bundle -a ${EC2_ACCESS_KEY} -s ${EC2_SECRET_KEY} --url ${S3_URL} --ec2cert ${NOVA_CERT}"
|
|
"""
|
|
lines.append(export_inc.strip())
|
|
lines.append("")
|
|
return lines
|
|
|
|
def _get_euca_envs(self):
|
|
to_set = dict()
|
|
to_set['EUCALYPTUS_CERT'] = self.cfg.get('extern', 'nova_cert_fn', auto_pw=False)
|
|
return to_set
|
|
|
|
def _generate_euca_env(self):
|
|
lines = list()
|
|
lines.append('# Eucalyptus stuff')
|
|
lines.extend(self._make_dict_export(self._get_euca_envs()))
|
|
lines.append("")
|
|
return lines
|
|
|
|
def _get_nova_envs(self):
|
|
to_set = dict()
|
|
to_set['NOVA_VERSION'] = self.cfg.get('nova', 'nova_version', auto_pw=False)
|
|
to_set['NOVA_CERT'] = self.cfg.get('extern', 'nova_cert_fn', auto_pw=False)
|
|
return to_set
|
|
|
|
def _generate_nova_env(self):
|
|
lines = list()
|
|
lines.append('# Nova stuff')
|
|
lines.extend(self._make_dict_export(self._get_nova_envs()))
|
|
lines.append("")
|
|
return lines
|
|
|
|
def _generate_extern_inc(self):
|
|
lines = list()
|
|
lines.append('# External includes stuff')
|
|
extern_tpl = """
|
|
|
|
# Use stored ec2 env variables
|
|
if [ -f "{ec2rc_fn}" ]; then
|
|
source "{ec2rc_fn}"
|
|
fi
|
|
|
|
# Allow local overrides of env variables
|
|
if [ -f "{localrc_fn}" ]; then
|
|
source "{localrc_fn}"
|
|
fi
|
|
|
|
"""
|
|
extern_inc = extern_tpl.format(ec2rc_fn=sh.abspth(settings.EC2RC_FN),
|
|
localrc_fn=sh.abspth(settings.LOCALRC_FN))
|
|
lines.append(extern_inc.strip())
|
|
lines.append("")
|
|
return lines
|
|
|
|
|
|
class RcReader(object):
|
|
def __init__(self):
|
|
pass
|
|
|
|
def extract(self, fn):
|
|
extracted_vars = dict()
|
|
contents = sh.load_file(fn)
|
|
for line in contents.splitlines():
|
|
if line.lstrip().startswith("#"):
|
|
continue
|
|
m = EXP_PAT.search(line)
|
|
if m:
|
|
key = m.group(1).strip()
|
|
value = m.group(2).strip()
|
|
quoted_mtch = QUOTED_PAT.match(value)
|
|
if quoted_mtch:
|
|
value = quoted_mtch.group(1).decode('string_escape').strip()
|
|
extracted_vars[key] = value
|
|
return extracted_vars
|
|
|
|
def load(self, fn):
|
|
kvs = self.extract(fn)
|
|
for (key, value) in kvs.items():
|
|
env.set(key, value)
|
|
return len(kvs)
|