def _config_adjust_root(self, contents, fn):
params = khelper.get_shared_params(**utils.merge_dicts(
self.options, khelper.get_shared_passwords(self)))
with io.BytesIO(contents) as stream:
config = cfg.create_parser(cfg.RewritableConfigParser, self)
config.readfp(stream)
config.set('DEFAULT', 'admin_token', params['service_token'])
config.set('DEFAULT', 'admin_port',
params['endpoints']['admin']['port'])
config.set('DEFAULT', 'public_port',
params['endpoints']['public']['port'])
config.set('DEFAULT', 'verbose', True)
config.set('DEFAULT', 'debug', True)
if self.get_bool_option('enable-pki'):
config.set('signing', 'token_format', 'PKI')
for (k, v) in PKI_FILES.items():
path = sh.joinpths(self.link_dir, v)
config.set('signing', k, path)
else:
config.set('signing', 'token_format', 'UUID')
config.set('catalog', 'driver',
'keystone.catalog.backends.sql.Catalog')
config.remove_option('DEFAULT', 'log_config')
config.set(
'sql', 'connection',
dbhelper.fetch_dbdsn(dbname=DB_NAME,
utf8=True,
dbtype=self.get_option('db', 'type'),
**utils.merge_dicts(
self.get_option('db'),
dbhelper.get_shared_passwords(self))))
config.set('ec2', 'driver',
"keystone.contrib.ec2.backends.sql.Ec2")
contents = config.stringify(fn)
return contents
def _config_adjust_root(self, contents, fn):
params = khelper.get_shared_params(**utils.merge_dicts(self.options, khelper.get_shared_passwords(self)))
with io.BytesIO(contents) as stream:
config = cfg.create_parser(cfg.RewritableConfigParser, self)
config.readfp(stream)
config.set("DEFAULT", "admin_token", params["service_token"])
config.set("DEFAULT", "admin_port", params["endpoints"]["admin"]["port"])
config.set("DEFAULT", "public_port", params["endpoints"]["public"]["port"])
config.set("DEFAULT", "verbose", True)
config.set("DEFAULT", "debug", True)
config.set("catalog", "driver", "keystone.catalog.backends.sql.Catalog")
config.remove_option("DEFAULT", "log_config")
config.set(
"sql",
"connection",
dbhelper.fetch_dbdsn(
dbname=DB_NAME,
utf8=True,
dbtype=self.get_option("db", "type"),
**utils.merge_dicts(self.get_option("db"), dbhelper.get_shared_passwords(self))
),
)
config.set("ec2", "driver", "keystone.contrib.ec2.backends.sql.Ec2")
contents = config.stringify(fn)
return contents
def _config_adjust_root(self, contents, fn):
params = khelper.get_shared_params(**utils.merge_dicts(self.options,
khelper.get_shared_passwords(self)))
with io.BytesIO(contents) as stream:
config = cfg.create_parser(cfg.RewritableConfigParser, self)
config.readfp(stream)
config.set('DEFAULT', 'admin_token', params['service_token'])
config.set('DEFAULT', 'admin_port', params['endpoints']['admin']['port'])
config.set('DEFAULT', 'public_port', params['endpoints']['public']['port'])
config.set('DEFAULT', 'verbose', True)
config.set('DEFAULT', 'debug', True)
if self.get_bool_option('enable-pki'):
config.set('signing', 'token_format', 'PKI')
for (k, v) in PKI_FILES.items():
path = sh.joinpths(self.link_dir, v)
config.set('signing', k, path)
else:
config.set('signing', 'token_format', 'UUID')
config.set('catalog', 'driver', 'keystone.catalog.backends.sql.Catalog')
config.remove_option('DEFAULT', 'log_config')
config.set('sql', 'connection', dbhelper.fetch_dbdsn(dbname=DB_NAME,
utf8=True,
dbtype=self.get_option('db', 'type'),
**utils.merge_dicts(self.get_option('db'),
dbhelper.get_shared_passwords(self))))
config.set('ec2', 'driver', "keystone.contrib.ec2.backends.sql.Ec2")
contents = config.stringify(fn)
return contents
def _setup_db(self):
dbhelper.drop_db(distro=self.distro,
dbtype=self.get_option('db', 'type'),
dbname=DB_NAME,
**utils.merge_dicts(self.get_option('db'),
dbhelper.get_shared_passwords(self)))
dbhelper.create_db(distro=self.distro,
dbtype=self.get_option('db', 'type'),
dbname=DB_NAME,
**utils.merge_dicts(self.get_option('db'),
dbhelper.get_shared_passwords(self)))
def _setup_db(self):
dbhelper.drop_db(distro=self.distro,
dbtype=self.get_option('db', 'type'),
dbname=DB_NAME,
**utils.merge_dicts(self.get_option('db'),
dbhelper.get_shared_passwords(self)))
dbhelper.create_db(distro=self.distro,
dbtype=self.get_option('db', 'type'),
dbname=DB_NAME,
**utils.merge_dicts(self.get_option('db'),
dbhelper.get_shared_passwords(self)))
def setup_db(self):
dbhelper.drop_db(
distro=self.installer.distro,
dbtype=self.installer.get_option("db", "type"),
dbname=self.DB_NAME,
**utils.merge_dicts(self.installer.get_option("db"), dbhelper.get_shared_passwords(self.installer))
)
dbhelper.create_db(
distro=self.installer.distro,
dbtype=self.installer.get_option("db", "type"),
dbname=self.DB_NAME,
**utils.merge_dicts(self.installer.get_option("db"), dbhelper.get_shared_passwords(self.installer))
)
def _setup_db(self):
dbhelper.drop_db(distro=self.distro,
dbtype=self.get_option('db', 'type'),
dbname=DB_NAME,
**utils.merge_dicts(self.get_option('db'),
dbhelper.get_shared_passwords(self)))
# Explicitly use latin1: to avoid lp#829209, nova expects the database to
# use latin1 by default, and then upgrades the database to utf8 (see the
# 082_essex.py in nova)
dbhelper.create_db(distro=self.distro,
dbtype=self.get_option('db', 'type'),
dbname=DB_NAME,
charset='latin1',
**utils.merge_dicts(self.get_option('db'),
dbhelper.get_shared_passwords(self)))
def _config_adjust_api_reg(self, contents, fn):
gparams = ghelper.get_shared_params(**self.options)
with io.BytesIO(contents) as stream:
config = cfg.create_parser(cfg.RewritableConfigParser, self)
config.readfp(stream)
config.set('DEFAULT', 'debug', self.get_bool_option('verbose'))
config.set('DEFAULT', 'verbose', self.get_bool_option('verbose'))
if fn in [REG_CONF]:
config.set('DEFAULT', 'bind_port', gparams['endpoints']['registry']['port'])
else:
config.set('DEFAULT', 'bind_port', gparams['endpoints']['public']['port'])
config.set('DEFAULT', 'sql_connection', dbhelper.fetch_dbdsn(dbname=DB_NAME,
utf8=True,
dbtype=self.get_option('db', 'type'),
**utils.merge_dicts(self.get_option('db'),
dbhelper.get_shared_passwords(self))))
config.remove_option('DEFAULT', 'log_file')
config.set('paste_deploy', 'flavor', self.get_option('paste_flavor'))
for (k, v) in self._fetch_keystone_params().items():
config.set('keystone_authtoken', k, v)
if fn in [API_CONF]:
config.set('DEFAULT', 'default_store', 'file')
img_store_dir = sh.joinpths(self.get_option('component_dir'), 'images')
config.set('DEFAULT', 'filesystem_store_datadir', img_store_dir)
LOG.debug("Ensuring file system store directory %r exists and is empty." % (img_store_dir))
if sh.isdir(img_store_dir):
sh.deldir(img_store_dir)
sh.mkdirslist(img_store_dir, tracewriter=self.tracewriter, adjust_suids=True)
return config.stringify(fn)
def _construct_siblings(self, name, siblings, base_params,
sibling_instances):
# First setup the sibling instance action references
for (action, _entry_point) in siblings.items():
if action not in sibling_instances:
sibling_instances[action] = {}
there_siblings = {}
for (action, entry_point) in siblings.items():
sibling_params = utils.merge_dicts(base_params,
self.cli_opts,
preserve=True)
# Give the sibling the reference to all other siblings being created
# which will be populated when they are created (now or later) for
# the same action
sibling_params['instances'] = sibling_instances[action]
a_sibling = importer.construct_entry_point(entry_point,
**sibling_params)
# Update the sibling we are returning and the corresponding
# siblings for that action (so that the sibling can have the
# correct 'sibling' instances associated with it, if it needs those...)
there_siblings[action] = a_sibling
# Update all siblings being constructed so that there siblings will
# be correct when fetched...
sibling_instances[action][name] = a_sibling
return there_siblings
def post_start(self):
if not sh.isfile(self.init_fn) and self.get_bool_option('do-init'):
self.wait_active()
LOG.info("Running commands to initialize keystone.")
(fn, contents) = utils.load_template(self.name, INIT_WHAT_FN)
LOG.debug("Initializing with contents of %s", fn)
params = {}
params['keystone'] = khelper.get_shared_params(**utils.merge_dicts(self.options, khelper.get_shared_passwords(self)))
params['glance'] = ghelper.get_shared_params(ip=self.get_option('ip'), **self.get_option('glance'))
params['nova'] = nhelper.get_shared_params(ip=self.get_option('ip'), **self.get_option('nova'))
params['quantum'] = qhelper.get_shared_params(ip=self.get_option('ip'), **self.get_option('quantum'))
params['cinder'] = chelper.get_shared_params(ip=self.get_option('ip'), **self.get_option('cinder'))
wait_urls = [
params['keystone']['endpoints']['admin']['uri'],
params['keystone']['endpoints']['public']['uri'],
]
for url in wait_urls:
utils.wait_for_url(url)
init_what = utils.load_yaml_text(contents)
init_what = utils.expand_template_deep(self._filter_init(init_what), params)
khelper.Initializer(params['keystone']['service_token'],
params['keystone']['endpoints']['admin']['uri']).initialize(**init_what)
# Writing this makes sure that we don't init again
sh.write_file(self.init_fn, utils.prettify_yaml(init_what))
LOG.info("If you wish to re-run initialization, delete %s", colorizer.quote(self.init_fn))
def load(self, distro, component, persona=None, origins_patch=None):
# NOTE (vnovikov): applying takes place before loading reference links
self._apply_persona(component, persona)
dir_opts = self._get_dir_opts(component)
distro_opts = distro.options
origins_opts = {}
if self._origins_path:
try:
origins = _origins.load(self._origins_path,
patch_file=origins_patch)
origins_opts = origins[component]
except KeyError:
pass
general_component_opts = self._base_loader.load('general')
component_specific_opts = self._base_loader.load(component)
# NOTE (vnovikov): merge order is the same as arguments order below.
merged_opts = utils.merge_dicts(
dir_opts,
distro_opts,
origins_opts,
general_component_opts,
component_specific_opts,
)
return merged_opts
def load(self, distro, component, persona=None, origins_patch=None):
# NOTE (vnovikov): applying takes place before loading reference links
self._apply_persona(component, persona)
dir_opts = self._get_dir_opts(component)
distro_opts = distro.options
origins_opts = {}
if self._origins_path:
try:
origins = _origins.load(self._origins_path,
patch_file=origins_patch)
origins_opts = origins[component]
except KeyError:
pass
component_opts = []
for conf in ('general', component):
try:
component_opts.append(self._base_loader.load(conf))
except exceptions.YamlConfigNotFoundException:
LOG.warn("Unable to find component specific configuration"
" for component '%s'", conf, exc_info=True)
# NOTE (vnovikov): merge order is the same as arguments order below.
merged_opts = utils.merge_dicts(
dir_opts,
distro_opts,
origins_opts,
*component_opts
)
return merged_opts
def fetch_dbdsn(self):
return dbhelper.fetch_dbdsn(
dbname=self.DB_NAME,
utf8=True,
dbtype=self.installer.get_option('db', 'type'),
**utils.merge_dicts(self.installer.get_option('db'),
dbhelper.get_shared_passwords(self.installer)))
def _config_adjust_paste(self, contents, fn):
params = khelper.get_shared_params(
ip=self.get_option('ip'),
service_user='******',
**utils.merge_dicts(self.get_option('keystone'),
khelper.get_shared_passwords(self)))
with io.BytesIO(contents) as stream:
config = cfg.create_parser(cfg.RewritableConfigParser, self)
config.readfp(stream)
config.set('filter:authtoken', 'auth_host',
params['endpoints']['admin']['host'])
config.set('filter:authtoken', 'auth_port',
params['endpoints']['admin']['port'])
config.set('filter:authtoken', 'auth_protocol',
params['endpoints']['admin']['protocol'])
config.set('filter:authtoken', 'service_host',
params['endpoints']['internal']['host'])
config.set('filter:authtoken', 'service_port',
params['endpoints']['internal']['port'])
config.set('filter:authtoken', 'service_protocol',
params['endpoints']['internal']['protocol'])
config.set('filter:authtoken', 'admin_tenant_name',
params['service_tenant'])
config.set('filter:authtoken', 'admin_user',
params['service_user'])
config.set('filter:authtoken', 'admin_password',
params['service_password'])
contents = config.stringify(fn)
return contents
def _config_adjust_api_reg(self, contents, fn):
gparams = ghelper.get_shared_params(**self.options)
with io.BytesIO(contents) as stream:
config = cfg.create_parser(cfg.RewritableConfigParser, self)
config.readfp(stream)
config.set('DEFAULT', 'debug', self.get_bool_option('verbose'))
config.set('DEFAULT', 'verbose', self.get_bool_option('verbose'))
if fn in [REG_CONF]:
config.set('DEFAULT', 'bind_port', gparams['endpoints']['registry']['port'])
else:
config.set('DEFAULT', 'bind_port', gparams['endpoints']['public']['port'])
config.set('DEFAULT', 'sql_connection', dbhelper.fetch_dbdsn(dbname=DB_NAME,
utf8=True,
dbtype=self.get_option('db', 'type'),
**utils.merge_dicts(self.get_option('db'),
dbhelper.get_shared_passwords(self))))
config.remove_option('DEFAULT', 'log_file')
config.set('paste_deploy', 'flavor', self.get_option('paste_flavor'))
for (k, v) in self._fetch_keystone_params().items():
config.set('keystone_authtoken', k, v)
if fn in [API_CONF]:
config.set('DEFAULT', 'default_store', 'file')
img_store_dir = sh.joinpths(self.get_option('component_dir'), 'images')
config.set('DEFAULT', 'filesystem_store_datadir', img_store_dir)
LOG.debug("Ensuring file system store directory %r exists and is empty." % (img_store_dir))
if sh.isdir(img_store_dir):
sh.deldir(img_store_dir)
sh.mkdirslist(img_store_dir, tracewriter=self.tracewriter, adjust_suids=True)
return config.stringify(fn)
def post_start(self):
if not sh.isfile(self.init_fn) and self.get_bool_option("do-init"):
self.wait_active()
LOG.info("Running commands to initialize keystone.")
(fn, contents) = utils.load_template(self.name, INIT_WHAT_FN)
LOG.debug("Initializing with contents of %s", fn)
params = {}
params["keystone"] = khelper.get_shared_params(
**utils.merge_dicts(self.options, khelper.get_shared_passwords(self))
)
params["glance"] = ghelper.get_shared_params(ip=self.get_option("ip"), **self.get_option("glance"))
params["nova"] = nhelper.get_shared_params(ip=self.get_option("ip"), **self.get_option("nova"))
wait_urls = [
params["keystone"]["endpoints"]["admin"]["uri"],
params["keystone"]["endpoints"]["public"]["uri"],
]
for url in wait_urls:
utils.wait_for_url(url)
init_what = utils.load_yaml_text(contents)
init_what = utils.expand_template_deep(self._filter_init(init_what), params)
khelper.Initializer(
params["keystone"]["service_token"], params["keystone"]["endpoints"]["admin"]["uri"]
).initialize(**init_what)
# Writing this makes sure that we don't init again
sh.write_file(self.init_fn, utils.prettify_yaml(init_what))
LOG.info("If you wish to re-run initialization, delete %s", colorizer.quote(self.init_fn))
def post_start(self):
if not sh.isfile(self.init_fn) and self.get_bool_option('do-init'):
self.wait_active()
LOG.info("Running commands to initialize keystone.")
(fn, contents) = utils.load_template(self.name, INIT_WHAT_FN)
LOG.debug("Initializing with contents of %s", fn)
params = {}
params['keystone'] = khelper.get_shared_params(**utils.merge_dicts(self.options, khelper.get_shared_passwords(self)))
params['glance'] = ghelper.get_shared_params(ip=self.get_option('ip'), **self.get_option('glance'))
params['nova'] = nhelper.get_shared_params(ip=self.get_option('ip'), **self.get_option('nova'))
params['neutron'] = net_helper.get_shared_params(ip=self.get_option('ip'), **self.get_option('neutron'))
params['cinder'] = chelper.get_shared_params(ip=self.get_option('ip'), **self.get_option('cinder'))
wait_urls = [
params['keystone']['endpoints']['admin']['uri'],
params['keystone']['endpoints']['public']['uri'],
]
for url in wait_urls:
utils.wait_for_url(url)
init_what = utils.load_yaml_text(contents)
init_what = utils.expand_template_deep(init_what, params)
try:
init_how = khelper.Initializer(params['keystone']['service_token'],
params['keystone']['endpoints']['admin']['uri'])
init_how.initialize(**init_what)
except RuntimeError:
LOG.exception("Failed to initialize keystone, is the keystone client library available?")
else:
# Writing this makes sure that we don't init again
sh.write_file(self.init_fn, utils.prettify_yaml(init_what))
LOG.info("If you wish to re-run initialization, delete %s", colorizer.quote(self.init_fn))
def _config_adjust_paste(self, contents, fn):
params = khelper.get_shared_params(
ip=self.get_option("ip"),
service_user="******",
**utils.merge_dicts(self.get_option("keystone"), khelper.get_shared_passwords(self))
)
with io.BytesIO(contents) as stream:
config = cfg.create_parser(cfg.RewritableConfigParser, self)
config.readfp(stream)
config.set("filter:authtoken", "auth_host", params["endpoints"]["admin"]["host"])
config.set("filter:authtoken", "auth_port", params["endpoints"]["admin"]["port"])
config.set("filter:authtoken", "auth_protocol", params["endpoints"]["admin"]["protocol"])
config.set("filter:authtoken", "service_host", params["endpoints"]["internal"]["host"])
config.set("filter:authtoken", "service_port", params["endpoints"]["internal"]["port"])
config.set("filter:authtoken", "service_protocol", params["endpoints"]["internal"]["protocol"])
config.set("filter:authtoken", "admin_tenant_name", params["service_tenant"])
config.set("filter:authtoken", "admin_user", params["service_user"])
config.set("filter:authtoken", "admin_password", params["service_password"])
contents = config.stringify(fn)
return contents
def fetch_dbdsn(self):
return dbhelper.fetch_dbdsn(
dbname=self.DB_NAME,
utf8=True,
dbtype=self.installer.get_option('db', 'type'),
**utils.merge_dicts(self.installer.get_option('db'),
dbhelper.get_shared_passwords(self.installer)))
def _config_adjust_api(self, contents, fn):
params = ghelper.get_shared_params(**self.options)
with io.BytesIO(contents) as stream:
config = cfg.create_parser(cfg.RewritableConfigParser, self)
config.readfp(stream)
img_store_dir = sh.joinpths(self.get_option('component_dir'),
'images')
config.set('DEFAULT', 'debug', self.get_bool_option('verbose', ))
config.set('DEFAULT', 'verbose', self.get_bool_option('verbose'))
config.set('DEFAULT', 'default_store', 'file')
config.set('DEFAULT', 'filesystem_store_datadir', img_store_dir)
config.set('DEFAULT', 'bind_port',
params['endpoints']['public']['port'])
config.set(
'DEFAULT', 'sql_connection',
dbhelper.fetch_dbdsn(dbname=DB_NAME,
utf8=True,
dbtype=self.get_option('db', 'type'),
**utils.merge_dicts(
self.get_option('db'),
dbhelper.get_shared_passwords(self))))
config.remove_option('DEFAULT', 'log_file')
config.set('paste_deploy', 'flavor',
self.get_option('paste_flavor'))
LOG.debug(
"Ensuring file system store directory %r exists and is empty."
% (img_store_dir))
sh.deldir(img_store_dir)
self.tracewriter.dirs_made(*sh.mkdirslist(img_store_dir))
return config.stringify(fn)
def _construct_instances(self, persona):
"""
Create component objects for each component in the persona.
"""
persona_subsystems = persona.wanted_subsystems or {}
persona_opts = persona.component_options or {}
wanted_components = persona.wanted_components or []
# All siblings for the current persona
instances = {}
# Keeps track of all sibling instances across all components + actions
# so that each instance or sibling instance will be connected to the
# right set of siblings....
sibling_instances = {}
for c in wanted_components:
d_component = self.distro.extract_component(c, self.lookup_name)
LOG.debug("Constructing component %r (%s)", c,
d_component.entry_point)
d_subsystems = d_component.options.pop('subsystems', {})
sibling_params = {}
sibling_params['name'] = c
# First create its siblings with a 'minimal' set of options
# This is done, so that they will work in a minimal state, they do not
# get access to the persona options since those are action specific (or could be),
# if this is not useful, we can give them full access, unsure if its worse or better...
active_subsystems = self._merge_subsystems(
distro_subsystems=d_subsystems,
desired_subsystems=persona_subsystems.get(c, []))
sibling_params['subsystems'] = active_subsystems
sibling_params['siblings'] = {
} # This gets adjusted during construction
sibling_params['passwords'] = self.passwords
sibling_params['distro'] = self.distro
sibling_params['options'] = self._merge_options(
c,
component_opts=self._get_interpolated_options(c),
distro_opts=d_component.options,
persona_opts={})
LOG.debug("Constructing %r %s siblings...", c,
len(d_component.siblings))
my_siblings = self._construct_siblings(c, d_component.siblings,
sibling_params,
sibling_instances)
# Now inject the full options and create the target instance
# with the full set of options and not the restricted set that
# siblings get...
instance_params = dict(sibling_params)
instance_params['instances'] = instances
instance_params['options'] = self._merge_options(
c,
component_opts=self._get_interpolated_options(c),
distro_opts=d_component.options,
persona_opts=persona_opts.get(c, {}))
instance_params['siblings'] = my_siblings
instance_params = utils.merge_dicts(instance_params,
self.cli_opts,
preserve=True)
instances[c] = importer.construct_entry_point(
d_component.entry_point, **instance_params)
return instances
def _setup_db(self):
dbhelper.drop_db(distro=self.distro,
dbtype=self.get_option('db', 'type'),
dbname=DB_NAME,
**utils.merge_dicts(
self.get_option('db'),
dbhelper.get_shared_passwords(self)))
# Explicitly use latin1: to avoid lp#829209, nova expects the database to
# use latin1 by default, and then upgrades the database to utf8 (see the
# 082_essex.py in nova)
dbhelper.create_db(distro=self.distro,
dbtype=self.get_option('db', 'type'),
dbname=DB_NAME,
charset='latin1',
**utils.merge_dicts(
self.get_option('db'),
dbhelper.get_shared_passwords(self)))
def env_exports(self):
params = khelper.get_shared_params(**utils.merge_dicts(self.options,
khelper.get_shared_passwords(self)))
to_set = {}
to_set['OS_PASSWORD'] = params['admin_password']
to_set['OS_TENANT_NAME'] = params['demo_tenant']
to_set['OS_USERNAME'] = params['demo_user']
to_set['OS_AUTH_URL'] = params['endpoints']['public']['uri']
to_set['SERVICE_ENDPOINT'] = params['endpoints']['admin']['uri']
return to_set
def _config_adjust_root(self, contents, fn):
params = khelper.get_shared_params(**utils.merge_dicts(self.options,
khelper.get_shared_passwords(self)))
with io.BytesIO(contents) as stream:
config = cfg.RewritableConfigParser()
config.readfp(stream)
config.set('DEFAULT', 'admin_token', params['service_token'])
config.set('DEFAULT', 'admin_port', params['endpoints']['admin']['port'])
config.set('DEFAULT', 'public_port', params['endpoints']['public']['port'])
config.set('DEFAULT', 'verbose', True)
config.set('DEFAULT', 'debug', True)
config.set('catalog', 'driver', 'keystone.catalog.backends.sql.Catalog')
config.remove_option('DEFAULT', 'log_config')
config.set('sql', 'connection', dbhelper.fetch_dbdsn(dbname=DB_NAME,
utf8=True,
dbtype=self.get_option('db', 'type'),
**utils.merge_dicts(self.get_option('db'),
dbhelper.get_shared_passwords(self))))
config.set('ec2', 'driver', "keystone.contrib.ec2.backends.sql.Ec2")
contents = config.stringify(fn)
return contents
def post_start(self):
comp.PythonRuntime.post_start(self)
if self.get_bool_option('load-images'):
# Install any images that need activating...
self.wait_active()
params = {}
params['glance'] = ghelper.get_shared_params(**self.options)
params['keystone'] = khelper.get_shared_params(ip=self.get_option('ip'),
service_user='******',
**utils.merge_dicts(self.get_option('keystone'),
khelper.get_shared_passwords(self)))
ghelper.UploadService(params).install(self._get_image_urls())
def _config_adjust_paste(self, contents, fn):
params = khelper.get_shared_params(ip=self.get_option('ip'),
service_user='******',
**utils.merge_dicts(self.get_option('keystone'),
khelper.get_shared_passwords(self)))
with io.BytesIO(contents) as stream:
config = cfg.create_parser(cfg.RewritableConfigParser, self)
config.readfp(stream)
for (k, v) in self._fetch_keystone_params().items():
config.set('filter:authtoken', k, v)
contents = config.stringify(fn)
return contents
def post_start(self):
comp.PythonRuntime.post_start(self)
if self.get_bool_option('load-images'):
# Install any images that need activating...
self.wait_active()
params = {}
params['glance'] = ghelper.get_shared_params(**self.options)
params['keystone'] = khelper.get_shared_params(
ip=self.get_option('ip'),
service_user='******',
**utils.merge_dicts(self.get_option('keystone'),
khelper.get_shared_passwords(self)))
ghelper.UploadService(params).install(self._get_image_urls())
def env_exports(self):
params = khelper.get_shared_params(**utils.merge_dicts(self.options,
khelper.get_shared_passwords(self)))
to_set = OrderedDict()
to_set['OS_PASSWORD'] = params['admin_password']
to_set['OS_TENANT_NAME'] = params['admin_tenant']
to_set['OS_USERNAME'] = params['admin_user']
to_set['OS_AUTH_URL'] = params['endpoints']['public']['uri']
for (endpoint, details) in params['endpoints'].items():
if endpoint.find('templated') != -1:
continue
to_set[("KEYSTONE_%s_URI" % (endpoint.upper()))] = details['uri']
return to_set
def env_exports(self):
params = khelper.get_shared_params(**utils.merge_dicts(self.options,
khelper.get_shared_passwords(self)))
to_set = OrderedDict()
to_set['OS_PASSWORD'] = params['admin_password']
to_set['OS_TENANT_NAME'] = params['admin_tenant']
to_set['OS_USERNAME'] = params['admin_user']
to_set['OS_AUTH_URL'] = params['endpoints']['public']['uri']
for (endpoint, details) in params['endpoints'].items():
if endpoint.find('templated') != -1:
continue
to_set[("KEYSTONE_%s_URI" % (endpoint.upper()))] = details['uri']
return to_set
def _config_adjust_paste(self, contents, fn):
params = khelper.get_shared_params(
ip=self.get_option('ip'),
service_user='******',
**utils.merge_dicts(self.get_option('keystone'),
khelper.get_shared_passwords(self)))
with io.BytesIO(contents) as stream:
config = cfg.create_parser(cfg.RewritableConfigParser, self)
config.readfp(stream)
for (k, v) in self._fetch_keystone_params().items():
config.set('filter:authtoken', k, v)
contents = config.stringify(fn)
return contents
def env_exports(self):
params = khelper.get_shared_params(**utils.merge_dicts(self.options, khelper.get_shared_passwords(self)))
to_set = OrderedDict()
to_set["OS_PASSWORD"] = params["admin_password"]
to_set["OS_TENANT_NAME"] = params["admin_tenant"]
to_set["OS_USERNAME"] = params["admin_user"]
to_set["OS_AUTH_URL"] = params["endpoints"]["public"]["uri"]
to_set["SERVICE_ENDPOINT"] = params["endpoints"]["admin"]["uri"]
for (endpoint, details) in params["endpoints"].items():
if endpoint.find("templated") != -1:
continue
to_set[("KEYSTONE_%s_URI" % (endpoint.upper()))] = details["uri"]
return to_set
def _construct_instances(self, persona):
"""
Create component objects for each component in the persona.
"""
persona_subsystems = persona.wanted_subsystems or {}
persona_opts = persona.component_options or {}
wanted_components = persona.wanted_components or []
# All siblings for the current persona
instances = {}
# Keeps track of all sibling instances across all components + actions
# so that each instance or sibling instance will be connected to the
# right set of siblings....
sibling_instances = {}
for c in wanted_components:
d_component = self.distro.extract_component(c, self.lookup_name)
LOG.debug("Constructing component %r (%s)", c, d_component.entry_point)
d_subsystems = d_component.options.pop("subsystems", {})
sibling_params = {}
sibling_params["name"] = c
# First create its siblings with a 'minimal' set of options
# This is done, so that they will work in a minimal state, they do not
# get access to the persona options since those are action specific (or could be),
# if this is not useful, we can give them full access, unsure if its worse or better...
active_subsystems = self._merge_subsystems(
distro_subsystems=d_subsystems, desired_subsystems=persona_subsystems.get(c, [])
)
sibling_params["subsystems"] = active_subsystems
sibling_params["siblings"] = {} # This gets adjusted during construction
sibling_params["passwords"] = self.passwords
sibling_params["distro"] = self.distro
sibling_params["options"] = self._merge_options(
c, component_opts=self._get_interpolated_options(c), distro_opts=d_component.options, persona_opts={}
)
LOG.debug("Constructing %r %s siblings...", c, len(d_component.siblings))
my_siblings = self._construct_siblings(c, d_component.siblings, sibling_params, sibling_instances)
# Now inject the full options and create the target instance
# with the full set of options and not the restricted set that
# siblings get...
instance_params = dict(sibling_params)
instance_params["instances"] = instances
instance_params["options"] = self._merge_options(
c,
component_opts=self._get_interpolated_options(c),
distro_opts=d_component.options,
persona_opts=persona_opts.get(c, {}),
)
instance_params["siblings"] = my_siblings
instance_params = utils.merge_dicts(instance_params, self.cli_opts, preserve=True)
instances[c] = importer.construct_entry_point(d_component.entry_point, **instance_params)
return instances
def _construct_instances(self, persona):
"""Create component objects for each component in the persona."""
# Keeps track of all sibling instances across all components + actions
# so that each instance or sibling instance will be connected to the
# right set of siblings....
sibling_instances = {}
components_created = set()
groups = []
for group in persona.matched_components:
instances = utils.OrderedDict()
for c in group:
if c in components_created:
raise RuntimeError("Can not duplicate component %s in a"
" later group %s" % (c, group.id))
d_component = self.distro.extract_component(
c, self.lookup_name, default_entry_point_creator=self._make_default_entry_points)
LOG.debug("Constructing component %r (%s)", c, d_component.entry_point)
d_subsystems = d_component.options.pop('subsystems', {})
sibling_params = {}
sibling_params['name'] = c
# First create its siblings with a 'minimal' set of options
# This is done, so that they will work in a minimal state, they do not
# get access to the persona options since those are action specific (or could be),
# if this is not useful, we can give them full access, unsure if its worse or better...
active_subsystems = self._merge_subsystems(distro_subsystems=d_subsystems,
desired_subsystems=persona.wanted_subsystems.get(c, []))
sibling_params['subsystems'] = active_subsystems
sibling_params['siblings'] = {} # This gets adjusted during construction
sibling_params['distro'] = self.distro
sibling_params['options'] = self.config_loader.load(
distro=d_component, component=c,
origins_patch=self.cli_opts.get('origins_patch'))
LOG.debug("Constructing %r %s siblings...", c, len(d_component.siblings))
my_siblings = self._construct_siblings(c, d_component.siblings, sibling_params, sibling_instances)
# Now inject the full options and create the target instance
# with the full set of options and not the restricted set that
# siblings get...
instance_params = dict(sibling_params)
instance_params['instances'] = instances
instance_params['options'] = self.config_loader.load(
distro=d_component, component=c, persona=persona,
origins_patch=self.cli_opts.get('origins_patch'))
instance_params['siblings'] = my_siblings
instance_params = utils.merge_dicts(instance_params, self.cli_opts, preserve=True)
instances[c] = importer.construct_entry_point(d_component.entry_point, **instance_params)
if c not in SPECIAL_GROUPS:
components_created.add(c)
groups.append((group.id, instances))
return groups
def _fetch_keystone_params(self):
params = khelper.get_shared_params(ip=self.get_option('ip'),
service_user='******',
**utils.merge_dicts(self.get_option('keystone'),
khelper.get_shared_passwords(self)))
return {
'auth_host': params['endpoints']['admin']['host'],
'auth_port': params['endpoints']['admin']['port'],
'auth_protocol': params['endpoints']['admin']['protocol'],
# This uses the public uri not the admin one...
'auth_uri': params['endpoints']['public']['uri'],
'admin_tenant_name': params['service_tenant'],
'admin_user': params['service_user'],
'admin_password': params['service_password'],
}
def _fetch_keystone_params(self):
params = khelper.get_shared_params(ip=self.get_option('ip'),
service_user='******',
**utils.merge_dicts(self.get_option('keystone'),
khelper.get_shared_passwords(self)))
return {
'auth_host': params['endpoints']['admin']['host'],
'auth_port': params['endpoints']['admin']['port'],
'auth_protocol': params['endpoints']['admin']['protocol'],
# This uses the public uri not the admin one...
'auth_uri': params['endpoints']['public']['uri'],
'admin_tenant_name': params['service_tenant'],
'admin_user': params['service_user'],
'admin_password': params['service_password'],
}
def _construct_siblings(self, name, siblings, params, sibling_instances):
there_siblings = {}
for (action, cls_name) in siblings.items():
if action not in sibling_instances:
sibling_instances[action] = {}
cls = importer.import_entry_point(cls_name)
sibling_params = utils.merge_dicts(params, self.cli_opts, preserve=True)
sibling_params["instances"] = sibling_instances[action]
LOG.debug("Construction of sibling component %r (%r) params are:", name, action)
utils.log_object(sibling_params, logger=LOG, level=logging.DEBUG)
a_sibling = cls(**sibling_params)
# Update the sibling we are returning and the corresponding
# siblings for that action (so that the sibling can have the
# correct 'sibling' instances associated with it, if it needs those...)
there_siblings[action] = a_sibling
sibling_instances[action][name] = a_sibling
return there_siblings
def _config_adjust_registry(self, contents, fn):
params = ghelper.get_shared_params(**self.options)
with io.BytesIO(contents) as stream:
config = cfg.RewritableConfigParser()
config.readfp(stream)
config.set('DEFAULT', 'debug', self.get_bool_option('verbose'))
config.set('DEFAULT', 'verbose', self.get_bool_option('verbose'))
config.set('DEFAULT', 'bind_port', params['endpoints']['registry']['port'])
config.set('DEFAULT', 'sql_connection', dbhelper.fetch_dbdsn(dbname=DB_NAME,
utf8=True,
dbtype=self.get_option('db', 'type'),
**utils.merge_dicts(self.get_option('db'),
dbhelper.get_shared_passwords(self))))
config.remove_option('DEFAULT', 'log_file')
config.set('paste_deploy', 'flavor', self.get_option('paste_flavor'))
return config.stringify(fn)
return contents
def load(self, distro, component, persona=None):
# NOTE (vnovikov): applying takes place before loading reference links
self._apply_persona(component, persona)
dir_opts = self._get_dir_opts(component)
distro_opts = distro.options
general_component_opts = self._base_loader.load('general')
component_specific_opts = self._base_loader.load(component)
# NOTE (vnovikov): merge order is the same as arguments order below.
merged_opts = utils.merge_dicts(
dir_opts,
distro_opts,
general_component_opts,
component_specific_opts,
)
return merged_opts
def _construct_instances(self, persona):
"""
Create component objects for each component in the persona.
"""
persona_subsystems = persona.wanted_subsystems or {}
persona_opts = persona.component_options or {}
instances = {}
sibling_instances = {}
for c in persona.wanted_components:
((cls, distro_opts),
siblings) = self.distro.extract_component(c, self.lookup_name)
LOG.debug("Constructing component %r (%s)", c, tu.obj_name(cls))
instance_params = {}
instance_params['name'] = c
# First create its siblings with a 'minimal' set of options
# This is done, so that they will work in a minimal state, they do not
# get access to the persona options since those are action specific (or could be),
# if this is not useful, we can give them full access, unsure if its worse or better...
instance_params['subsystems'] = {}
instance_params['siblings'] = {}
instance_params['passwords'] = self.passwords
instance_params['distro'] = self.distro
instance_params['options'] = self._merge_options(
c, self._get_interp_options(c), distro_opts, {})
LOG.debug("Constructing %r siblings...", c)
siblings = self._construct_siblings(c, siblings, instance_params,
sibling_instances)
# Now inject the full options
instance_params['instances'] = instances
instance_params['options'] = self._merge_options(
c, self._get_interp_options(c), distro_opts,
(persona_opts.get(c) or {}))
instance_params['subsystems'] = self._merge_subsystems(
(distro_opts.pop('subsystems', None) or {}),
(persona_subsystems.get(c) or {}))
instance_params['siblings'] = siblings
instance_params = utils.merge_dicts(instance_params,
self.cli_opts,
preserve=True)
LOG.debug("Construction of %r params are:", c)
utils.log_object(instance_params, logger=LOG, level=logging.DEBUG)
instances[c] = cls(**instance_params)
return instances
def _config_adjust_root(self, config):
params = khelper.get_shared_params(**utils.merge_dicts(self.installer.options,
khelper.get_shared_passwords(self.installer)))
config.add('admin_token', params['service_token'])
config.add('admin_port', params['endpoints']['admin']['port'])
config.add('public_port', params['endpoints']['public']['port'])
config.add('verbose', True)
config.add('debug', True)
if self.installer.get_bool_option('enable-pki'):
config.add_with_section('signing', 'token_format', 'PKI')
for (k, v) in PKI_FILES.items():
path = sh.joinpths(self.link_dir, v)
config.add_with_section('signing', k, path)
else:
config.add_with_section('signing', 'token_format', 'UUID')
config.add_with_section('catalog', 'driver', 'keystone.catalog.backends.sql.Catalog')
config.remove('DEFAULT', 'log_config')
config.add_with_section('sql', 'connection', self.fetch_dbdsn())
config.add_with_section('ec2', 'driver', "keystone.contrib.ec2.backends.sql.Ec2")
def _config_adjust_paste(self, contents, fn):
params = khelper.get_shared_params(ip=self.get_option('ip'),
service_user='******',
**utils.merge_dicts(self.get_option('keystone'),
khelper.get_shared_passwords(self)))
with io.BytesIO(contents) as stream:
config = cfg.RewritableConfigParser()
config.readfp(stream)
config.set('filter:authtoken', 'auth_host', params['endpoints']['admin']['host'])
config.set('filter:authtoken', 'auth_port', params['endpoints']['admin']['port'])
config.set('filter:authtoken', 'auth_protocol', params['endpoints']['admin']['protocol'])
# This uses the public uri not the admin one...
config.set('filter:authtoken', 'auth_uri', params['endpoints']['public']['uri'])
config.set('filter:authtoken', 'admin_tenant_name', params['service_tenant'])
config.set('filter:authtoken', 'admin_user', params['service_user'])
config.set('filter:authtoken', 'admin_password', params['service_password'])
contents = config.stringify(fn)
return contents
def _construct_siblings(self, name, siblings, params, sibling_instances):
there_siblings = {}
for (action, cls_name) in siblings.items():
if action not in sibling_instances:
sibling_instances[action] = {}
cls = importer.import_entry_point(cls_name)
sibling_params = utils.merge_dicts(params,
self.cli_opts,
preserve=True)
sibling_params['instances'] = sibling_instances[action]
LOG.debug("Construction of sibling component %r (%r) params are:",
name, action)
utils.log_object(sibling_params, logger=LOG, level=logging.DEBUG)
a_sibling = cls(**sibling_params)
# Update the sibling we are returning and the corresponding
# siblings for that action (so that the sibling can have the
# correct 'sibling' instances associated with it, if it needs those...)
there_siblings[action] = a_sibling
sibling_instances[action][name] = a_sibling
return there_siblings
def _construct_siblings(self, name, siblings, base_params, sibling_instances):
# First setup the sibling instance action references
for (action, _entry_point) in siblings.items():
if action not in sibling_instances:
sibling_instances[action] = {}
there_siblings = {}
for (action, entry_point) in siblings.items():
sibling_params = utils.merge_dicts(base_params, self.cli_opts, preserve=True)
# Give the sibling the reference to all other siblings being created
# which will be populated when they are created (now or later) for
# the same action
sibling_params['instances'] = sibling_instances[action]
a_sibling = importer.construct_entry_point(entry_point, **sibling_params)
# Update the sibling we are returning and the corresponding
# siblings for that action (so that the sibling can have the
# correct 'sibling' instances associated with it, if it needs those...)
there_siblings[action] = a_sibling
# Update all siblings being constructed so that there siblings will
# be correct when fetched...
sibling_instances[action][name] = a_sibling
return there_siblings
def _config_adjust_registry(self, contents, fn):
params = ghelper.get_shared_params(**self.options)
with io.BytesIO(contents) as stream:
config = cfg.create_parser(cfg.RewritableConfigParser, self)
config.readfp(stream)
config.set('DEFAULT', 'debug', self.get_bool_option('verbose'))
config.set('DEFAULT', 'verbose', self.get_bool_option('verbose'))
config.set('DEFAULT', 'bind_port',
params['endpoints']['registry']['port'])
config.set(
'DEFAULT', 'sql_connection',
dbhelper.fetch_dbdsn(dbname=DB_NAME,
utf8=True,
dbtype=self.get_option('db', 'type'),
**utils.merge_dicts(
self.get_option('db'),
dbhelper.get_shared_passwords(self))))
config.remove_option('DEFAULT', 'log_file')
config.set('paste_deploy', 'flavor',
self.get_option('paste_flavor'))
return config.stringify(fn)
return contents
def _config_adjust_api(self, contents, fn):
params = ghelper.get_shared_params(**self.options)
with io.BytesIO(contents) as stream:
config = cfg.RewritableConfigParser()
config.readfp(stream)
img_store_dir = sh.joinpths(self.get_option('component_dir'), 'images')
config.set('DEFAULT', 'debug', self.get_bool_option('verbose',))
config.set('DEFAULT', 'verbose', self.get_bool_option('verbose'))
config.set('DEFAULT', 'default_store', 'file')
config.set('DEFAULT', 'filesystem_store_datadir', img_store_dir)
config.set('DEFAULT', 'bind_port', params['endpoints']['public']['port'])
config.set('DEFAULT', 'sql_connection', dbhelper.fetch_dbdsn(dbname=DB_NAME,
utf8=True,
dbtype=self.get_option('db', 'type'),
**utils.merge_dicts(self.get_option('db'),
dbhelper.get_shared_passwords(self))))
config.remove_option('DEFAULT', 'log_file')
config.set('paste_deploy', 'flavor', self.get_option('paste_flavor'))
LOG.debug("Ensuring file system store directory %r exists and is empty." % (img_store_dir))
sh.deldir(img_store_dir)
self.tracewriter.dirs_made(*sh.mkdirslist(img_store_dir))
return config.stringify(fn)
def _config_adjust_root(self, config):
params = khelper.get_shared_params(
**utils.merge_dicts(self.installer.options,
khelper.get_shared_passwords(self.installer)))
config.add('admin_token', params['service_token'])
config.add('admin_port', params['endpoints']['admin']['port'])
config.add('public_port', params['endpoints']['public']['port'])
config.add('verbose', True)
config.add('debug', True)
if self.installer.get_bool_option('enable-pki'):
config.add_with_section('signing', 'token_format', 'PKI')
for (k, v) in PKI_FILES.items():
path = sh.joinpths(self.link_dir, v)
config.add_with_section('signing', k, path)
else:
config.add_with_section('signing', 'token_format', 'UUID')
config.add_with_section('catalog', 'driver',
'keystone.catalog.backends.sql.Catalog')
config.remove('DEFAULT', 'log_config')
config.add_with_section('sql', 'connection', self.fetch_dbdsn())
config.add_with_section('ec2', 'driver',
"keystone.contrib.ec2.backends.sql.Ec2")
def _construct_instances(self, persona):
"""
Create component objects for each component in the persona.
"""
persona_subsystems = persona.wanted_subsystems or {}
persona_opts = persona.component_options or {}
instances = {}
sibling_instances = {}
for c in persona.wanted_components:
((cls, distro_opts), siblings) = self.distro.extract_component(c, self.lookup_name)
LOG.debug("Constructing component %r (%s)", c, tu.obj_name(cls))
instance_params = {}
instance_params["name"] = c
# First create its siblings with a 'minimal' set of options
# This is done, so that they will work in a minimal state, they do not
# get access to the persona options since those are action specific (or could be),
# if this is not useful, we can give them full access, unsure if its worse or better...
instance_params["subsystems"] = {}
instance_params["siblings"] = {}
instance_params["passwords"] = self.passwords
instance_params["distro"] = self.distro
instance_params["options"] = self._merge_options(c, self._get_interp_options(c), distro_opts, {})
LOG.debug("Constructing %r siblings...", c)
siblings = self._construct_siblings(c, siblings, instance_params, sibling_instances)
# Now inject the full options
instance_params["instances"] = instances
instance_params["options"] = self._merge_options(
c, self._get_interp_options(c), distro_opts, (persona_opts.get(c) or {})
)
instance_params["subsystems"] = self._merge_subsystems(
(distro_opts.pop("subsystems", None) or {}), (persona_subsystems.get(c) or {})
)
instance_params["siblings"] = siblings
instance_params = utils.merge_dicts(instance_params, self.cli_opts, preserve=True)
LOG.debug("Construction of %r params are:", c)
utils.log_object(instance_params, logger=LOG, level=logging.DEBUG)
instances[c] = cls(**instance_params)
return instances
def load(self, distro, component, persona=None):
# NOTE (vnovikov): applying takes place before loading reference links
self._apply_persona(component, persona)
dir_opts = self._get_dir_opts(component)
distro_opts = distro.options
origins_opts = {}
if self._origins_path:
try:
origins_opts = utils.load_yaml(self._origins_path)[component]
except KeyError:
pass
general_component_opts = self._base_loader.load('general')
component_specific_opts = self._base_loader.load(component)
# NOTE (vnovikov): merge order is the same as arguments order below.
merged_opts = utils.merge_dicts(
dir_opts,
distro_opts,
origins_opts,
general_component_opts,
component_specific_opts,
)
return merged_opts
def get_keystone_params(self, service_user):
return khelper.get_shared_params(
ip=self.installer.get_option('ip'),
service_user=service_user,
**utils.merge_dicts(self.installer.get_option('keystone'),
khelper.get_shared_passwords(self.installer)))
def _construct_instances(self, persona):
"""Create component objects for each component in the persona."""
# Keeps track of all sibling instances across all components + actions
# so that each instance or sibling instance will be connected to the
# right set of siblings....
sibling_instances = {}
components_created = set()
groups = []
for group in persona.matched_components:
instances = utils.OrderedDict()
for c in group:
if c in components_created:
raise RuntimeError("Can not duplicate component %s in a"
" later group %s" % (c, group.id))
d_component = self.distro.extract_component(
c,
self.lookup_name,
default_entry_point_creator=self._make_default_entry_points
)
LOG.debug("Constructing component %r (%s)", c,
d_component.entry_point)
d_subsystems = d_component.options.pop('subsystems', {})
sibling_params = {}
sibling_params['name'] = c
# First create its siblings with a 'minimal' set of options
# This is done, so that they will work in a minimal state, they do not
# get access to the persona options since those are action specific (or could be),
# if this is not useful, we can give them full access, unsure if its worse or better...
active_subsystems = self._merge_subsystems(
distro_subsystems=d_subsystems,
desired_subsystems=persona.wanted_subsystems.get(c, []))
sibling_params['subsystems'] = active_subsystems
sibling_params['siblings'] = {
} # This gets adjusted during construction
sibling_params['distro'] = self.distro
sibling_params['options'] = self.config_loader.load(
distro=d_component,
component=c,
origins_patch=self.cli_opts.get('origins_patch'))
LOG.debug("Constructing %r %s siblings...", c,
len(d_component.siblings))
my_siblings = self._construct_siblings(c, d_component.siblings,
sibling_params,
sibling_instances)
# Now inject the full options and create the target instance
# with the full set of options and not the restricted set that
# siblings get...
instance_params = dict(sibling_params)
instance_params['instances'] = instances
instance_params['options'] = self.config_loader.load(
distro=d_component,
component=c,
persona=persona,
origins_patch=self.cli_opts.get('origins_patch'))
instance_params['siblings'] = my_siblings
instance_params = utils.merge_dicts(instance_params,
self.cli_opts,
preserve=True)
instances[c] = importer.construct_entry_point(
d_component.entry_point, **instance_params)
if c not in SPECIAL_GROUPS:
components_created.add(c)
groups.append((group.id, instances))
return groups
def generate(self, fn):
# Everything built goes in here
nova_conf = Conf(fn, self.installer)
# Used more than once so we calculate it ahead of time
hostip = self.installer.get_option('ip')
nova_conf.add('verbose', self.installer.get_bool_option('verbose'))
# Allow destination machine to match source for resize.
nova_conf.add('allow_resize_to_same_host', True)
# Which scheduler do u want?
nova_conf.add(
'compute_scheduler_driver',
self.installer.get_option(
'scheduler',
default_value='nova.scheduler.filter_scheduler.FilterScheduler'
))
# Rate limit the api??
nova_conf.add('api_rate_limit',
self.installer.get_bool_option('api_rate_limit'))
# Setup nova network/settings
self._configure_network_settings(nova_conf)
# Setup nova volume/settings
if self.installer.get_option('volumes'):
self._configure_vols(nova_conf)
# The ip of where we are running
nova_conf.add('my_ip', hostip)
# Setup your sql connection
dbdsn = dbhelper.fetch_dbdsn(
dbname=DB_NAME,
utf8=True,
dbtype=self.installer.get_option('db', 'type'),
**utils.merge_dicts(self.installer.get_option('db'),
dbhelper.get_shared_passwords(self.installer)))
nova_conf.add('sql_connection', dbdsn)
# Configure anything libvirt related?
virt_driver = canon_virt_driver(
self.installer.get_option('virt_driver'))
if virt_driver == 'libvirt':
self._configure_libvirt(
lv.canon_libvirt_type(
self.installer.get_option('libvirt_type')), nova_conf)
# How instances will be presented
instance_template = "%s%s" % (
self.installer.get_option('instance_name_prefix'),
self.installer.get_option('instance_name_postfix'))
if not instance_template:
instance_template = 'instance-%08x'
nova_conf.add('instance_name_template', instance_template)
# Enable the standard extensions
nova_conf.add(
'osapi_compute_extension',
'nova.api.openstack.compute.contrib.standard_extensions')
# Auth will be using keystone
nova_conf.add('auth_strategy', 'keystone')
# Is config drive being forced?
if self.installer.get_bool_option('force_cfg_drive'):
nova_conf.add('force_config_drive', 'always')
# Don't always force images to raw
nova_conf.add('force_raw_images',
self.installer.get_bool_option('force_raw_images'))
# Add a checksum for images fetched to a hypervisor
nova_conf.add('checksum_base_images',
self.installer.get_bool_option('checksum_base_images'))
# Vnc settings setup
self._configure_vnc(nova_conf)
# Where our paste config is
nova_conf.add('api_paste_config',
self.installer.target_config(PASTE_CONF))
# What our imaging service will be
self._configure_image_service(nova_conf, hostip)
# Configs for ec2 / s3 stuff
nova_conf.add(
'ec2_dmz_host',
self.installer.get_option('ec2_dmz_host', default_value=hostip))
nova_conf.add('s3_host', hostip)
# How is your message queue setup?
mq_type = canon_mq_type(self.installer.get_option('mq-type'))
if mq_type == 'rabbit':
nova_conf.add(
'rabbit_host',
self.installer.get_option('rabbit',
'host',
default_value=hostip))
nova_conf.add('rabbit_password',
rbhelper.get_shared_passwords(self.installer)['pw'])
nova_conf.add('rabbit_userid',
self.installer.get_option('rabbit', 'user_id'))
nova_conf.add('rpc_backend', 'nova.rpc.impl_kombu')
# The USB tablet device is meant to improve mouse behavior in
# the VNC console, but it has the side effect of increasing
# the CPU usage of an idle VM tenfold.
nova_conf.add('use_usb_tablet', False)
# Where instances will be stored
instances_path = self.installer.get_option('instances_path')
if not instances_path:
instances_path = sh.joinpths(
self.installer.get_option('component_dir'), 'instances')
self._configure_instances_path(instances_path, nova_conf)
# Is this a multihost setup?
self._configure_multihost(nova_conf)
# Handle any virt driver specifics
self._configure_virt_driver(nova_conf)
# Annnnnd extract to finish
return self._get_content(nova_conf)
def _merge_options(self, name, distro_opts, component_opts, persona_opts):
return utils.merge_dicts(self._get_component_dirs(name),
distro_opts, component_opts, persona_opts)
