class ConsulException(Exception):
"""Base Consul Exception"""
msg_fmt = _("An unknown exception occurred.")
def __init__(self, message=None, **kwargs):
if not message:
message = self.msg_fmt % kwargs
super(ConsulException, self).__init__(message)
def monkey_patch():
"""monkey_patch function.
If the CONF.monkey_patch set as True,
this function patches a decorator
for all functions in specified modules.
You can set decorators for each modules
using CONF.monkey_patch_modules.
The format is "Module path:Decorator function".
name - name of the function
function - object of the function
"""
# If CONF.monkey_patch is not True, this function do nothing.
if not CONF.monkey_patch:
return
if six.PY2:
is_method = inspect.ismethod
else:
def is_method(obj):
# Unbound methods became regular functions on Python 3
return inspect.ismethod(obj) or inspect.isfunction(obj)
# Get list of modules and decorators
for module_and_decorator in CONF.monkey_patch_modules:
md_value = module_and_decorator.split(':')
if len(md_value) != 2:
msg = _("'monkey_patch_modules' config option is not configured "
"correctly")
raise Exception(msg)
module, decorator_name = md_value
# import decorator function
decorator = importutils.import_class(decorator_name)
__import__(module)
# Retrieve module information using pyclbr
module_data = pyclbr.readmodule_ex(module)
for key, value in module_data.items():
# set the decorator for the class methods
if isinstance(value, pyclbr.Class):
clz = importutils.import_class("%s.%s" % (module, key))
for method, func in inspect.getmembers(clz, is_method):
setattr(
clz, method,
decorator("%s.%s.%s" % (module, key, method), func))
# set the decorator for the function
if isinstance(value, pyclbr.Function):
func = importutils.import_class("%s.%s" % (module, key))
setattr(sys.modules[module], key,
decorator("%s.%s" % (module, key), func))
class ConsulGetMembersException(ConsulException):
msg_fmt = _("Failed to get members of %(cluster)s: %(err)s.")
class ConsulAgentNotExist(ConsulException):
msg_fmt = _("Consul agent of %(cluster)s not exist.")
def serve(server, workers=None):
global _launcher
if _launcher:
raise RuntimeError(_('serve() can only be called once'))
_launcher = service.launch(CONF, server, workers=workers)
def register_cache_configurations(conf):
"""Register all configurations required for oslo.cache.
The procedure registers all configurations required for oslo.cache.
It should be called before configuring of cache region
:param conf: instance of configuration
:returns: updated configuration
"""
# register global configurations for caching
core.configure(conf)
# register specific configurations
constraint_cache_group = cfg.OptGroup('constraint_validation_cache')
constraint_cache_opts = [
cfg.IntOpt('expiration_time',
default=WEEK,
help=_(
'TTL, in seconds, for any cached item in the '
'dogpile.cache region used for caching of validation '
'constraints.')),
cfg.BoolOpt("caching",
default=True,
help=_(
'Toggle to enable/disable caching when Orchestration '
'Engine validates property constraints of stack.'
'During property validation with constraints '
'Orchestration Engine caches requests to other '
'OpenStack services. Please note that the global '
'toggle for oslo.cache(enabled=True in [cache] group) '
'must be enabled to use this feature.'))
]
conf.register_group(constraint_cache_group)
conf.register_opts(constraint_cache_opts, group=constraint_cache_group)
extension_cache_group = cfg.OptGroup('service_extension_cache')
extension_cache_opts = [
cfg.IntOpt('expiration_time',
default=WEEK,
help=_('TTL, in seconds, for any cached item in the '
'dogpile.cache region used for caching of service '
'extensions.')),
cfg.BoolOpt('caching',
default=True,
help=_(
'Toggle to enable/disable caching when Orchestration '
'Engine retrieves extensions from other OpenStack '
'services. Please note that the global toggle for '
'oslo.cache(enabled=True in [cache] group) must be '
'enabled to use this feature.'))
]
conf.register_group(extension_cache_group)
conf.register_opts(extension_cache_opts, group=extension_cache_group)
find_cache_group = cfg.OptGroup('resource_finder_cache')
find_cache_opts = [
cfg.IntOpt('expiration_time',
default=WEEK,
help=_('TTL, in seconds, for any cached item in the '
'dogpile.cache region used for caching of OpenStack '
'service finder functions.')),
cfg.BoolOpt('caching',
default=True,
help=_(
'Toggle to enable/disable caching when Orchestration '
'Engine looks for other OpenStack service resources '
'using name or id. Please note that the global '
'toggle for oslo.cache(enabled=True in [cache] group) '
'must be enabled to use this feature.'))
]
conf.register_group(find_cache_group)
conf.register_opts(find_cache_opts, group=find_cache_group)
return conf