133 lines
4.5 KiB
Python
133 lines
4.5 KiB
Python
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
|
|
|
# Copyright 2012 Nicira, Inc.
|
|
#
|
|
# 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 quantum.openstack.common import cfg
|
|
|
|
|
|
database_opts = [
|
|
cfg.StrOpt('sql_connection', default='sqlite://'),
|
|
cfg.IntOpt('sql_max_retries', default=-1),
|
|
cfg.IntOpt('reconnect_interval', default=2),
|
|
]
|
|
|
|
nvp_opts = [
|
|
cfg.IntOpt('max_lp_per_bridged_ls', default=64),
|
|
cfg.IntOpt('concurrent_connections', default=5),
|
|
cfg.IntOpt('failover_time', default=240)
|
|
]
|
|
|
|
cluster_opts = [
|
|
cfg.StrOpt('default_tz_uuid'),
|
|
cfg.StrOpt('nvp_cluster_uuid'),
|
|
cfg.StrOpt('nova_zone_id'),
|
|
cfg.MultiStrOpt('nvp_controller_connection')
|
|
]
|
|
|
|
cfg.CONF.register_opts(database_opts, "DATABASE")
|
|
cfg.CONF.register_opts(nvp_opts, "NVP")
|
|
|
|
|
|
class ClusterConfigOptions(cfg.CommonConfigOpts):
|
|
|
|
def __init__(self, config_options):
|
|
super(ClusterConfigOptions, self).__init__()
|
|
self._group_mappings = {}
|
|
self._config_opts = config_options._config_opts
|
|
self._cparser = config_options._cparser
|
|
self._oparser = config_options._oparser
|
|
self.register_cli_opts(self._config_opts)
|
|
|
|
def _do_get(self, name, group=None):
|
|
"""Look up an option value.
|
|
|
|
:param name: the opt name (or 'dest', more precisely)
|
|
:param group: an OptGroup
|
|
:returns: the option value, or a GroupAttr object
|
|
:raises: NoSuchOptError, NoSuchGroupError, ConfigFileValueError,
|
|
TemplateSubstitutionError
|
|
"""
|
|
if group is None and name in self._groups:
|
|
return self.GroupAttr(self, self._get_group(name))
|
|
info = self._get_opt_info(name, group)
|
|
default, opt, override = [info[k] for k in sorted(info.keys())]
|
|
if override is not None:
|
|
return override
|
|
|
|
values = []
|
|
if self._cparser is not None:
|
|
section = group.name if group is not None else 'DEFAULT'
|
|
# Check if the name of the group maps to something else in
|
|
# the conf file.Otherwise leave the section name unchanged
|
|
|
|
section = self._group_mappings.get(section, section)
|
|
try:
|
|
value = opt._get_from_config_parser(self._cparser, section)
|
|
except KeyError:
|
|
pass
|
|
except ValueError as ve:
|
|
raise cfg.ConfigFileValueError(str(ve))
|
|
else:
|
|
if not opt.multi:
|
|
# No need to continue since the last value wins
|
|
return value[-1]
|
|
values.extend(value)
|
|
|
|
name = name if group is None else group.name + '_' + name
|
|
value = self._cli_values.get(name)
|
|
if value is not None:
|
|
if not opt.multi:
|
|
return value
|
|
|
|
return value + values
|
|
|
|
if values:
|
|
return values
|
|
|
|
if default is not None:
|
|
return default
|
|
|
|
return opt.default
|
|
|
|
def register_opts(self, opts, group_internal_name=None, group=None):
|
|
"""Register multiple option schemas at once."""
|
|
if group_internal_name:
|
|
self._group_mappings[group] = group_internal_name
|
|
for opt in opts:
|
|
self.register_opt(opt, group, clear_cache=False)
|
|
|
|
|
|
def _retrieve_extra_groups(conf, key=None, delimiter=':'):
|
|
"""retrieve configuration groups not listed above."""
|
|
results = []
|
|
for parsed_file in cfg.CONF._cparser.parsed:
|
|
for parsed_item in parsed_file.keys():
|
|
if not parsed_item in cfg.CONF:
|
|
items = key and parsed_item.split(delimiter)
|
|
if not key or key == items[0]:
|
|
results.append(parsed_item)
|
|
return results
|
|
|
|
|
|
def register_cluster_groups(conf):
|
|
"""retrieve configuration groups for nvp clusters."""
|
|
cluster_names = []
|
|
cluster_tags = _retrieve_extra_groups(conf, "CLUSTER")
|
|
for tag in cluster_tags:
|
|
cluster_name = tag.split(':')[1]
|
|
conf.register_opts(cluster_opts, tag, cluster_name)
|
|
cluster_names.append(cluster_name)
|
|
return cluster_names
|