def __init__(self, *args, **kwargs):
name = kwargs.pop('namespace', config.DEFAULT)
flatten = kwargs.pop('flatten', True)
config_data = dict(*args, **kwargs)
self.namespace = config.get_namespace(name)
self.config_data = dict(loader.flatten_dict(config_data)) if flatten else config_data
self.old_values = None
def setup_configuration_values(self):
validator = mock.Mock(return_value=2)
self.name = 'test_namespace'
self.namespace = config.get_namespace(self.name)
self.config_key = 'something'
self.value_proxy = proxy.ValueProxy(
validator, self.namespace, self.config_key)
def setup_configuration_values(self):
validator = mock.Mock(return_value=2)
self.name = 'test_namespace'
self.namespace = config.get_namespace(self.name)
self.config_key = 'something'
self.value_proxy = proxy.ValueProxy(validator, self.namespace,
self.config_key)
def __init__(self, *args, **kwargs):
name = kwargs.pop('namespace', config.DEFAULT)
flatten = kwargs.pop('flatten', True)
config_data = dict(*args, **kwargs)
self.namespace = config.get_namespace(name)
self.config_data = (dict(loader.flatten_dict(config_data)) if flatten
else config_data)
self.old_values = None
def proxy_register(key_name,
default=UndefToken,
help=None,
namespace=None):
name = namespace or getter_namespace or config.DEFAULT
namespace = config.get_namespace(name)
return proxy_factory.build(validator, namespace, key_name, default,
help)
def proxy_register(key_name, default=UndefToken, help=None, namespace=None):
name = namespace or getter_namespace or config.DEFAULT
namespace = config.get_namespace(name)
args = validator, namespace.get_config_values(), key_name, default
value_proxy = proxy.ValueProxy(*args)
namespace.register_proxy(value_proxy)
config.add_config_key_description(key_name, validator, default, name, help)
return value_proxy
def test_build_getter(self):
validator = mock.Mock()
getter = getters.build_getter(validator)
assert callable(getter), "Getter is not callable"
value_proxy = getter('the_name')
namespace = config.get_namespace(config.DEFAULT)
assert_in(id(value_proxy), namespace.value_proxies)
assert_equal(value_proxy.config_key, "the_name")
assert_equal(value_proxy.namespace, namespace)
def proxy_register(key_name,
default=UndefToken,
help=None,
namespace=None):
name = namespace or getter_namespace or config.DEFAULT
namespace = config.get_namespace(name)
value_proxy = proxy.ValueProxy(validator, namespace, key_name, default)
register_value_proxy(namespace, value_proxy, help)
return value_proxy
def test_build_getter(self):
validator = mock.Mock()
getter = getters.build_getter(validator)
assert callable(getter), "Getter is not callable"
value_proxy = getter('the_name')
namespace = config.get_namespace(config.DEFAULT)
assert value_proxy is namespace.get_value_proxies()[-1]
assert_equal(value_proxy.config_key, "the_name")
assert_equal(value_proxy.value_cache, namespace.configuration_values)
def test_build_getter(self):
validator = mock.Mock()
getter = getters.build_getter(validator)
assert callable(getter), "Getter is not callable"
value_proxy = getter('the_name')
namespace = config.get_namespace(config.DEFAULT)
assert_in(id(value_proxy), namespace.value_proxies)
assert_equal(value_proxy.config_key, "the_name")
assert_equal(value_proxy.namespace, namespace)
def test_build_getter_with_getter_namespace(self):
validator = mock.Mock()
name = 'the stars'
getter = getters.build_getter(validator, getter_namespace=name)
assert callable(getter), "Getter is not callable"
value_proxy = getter('the_name')
namespace = config.get_namespace(name)
assert_in(id(value_proxy), namespace.value_proxies)
assert_equal(value_proxy.config_key, "the_name")
assert_equal(value_proxy.namespace, namespace)
def test_build_getter_with_getter_namespace(self):
validator = mock.Mock()
name = 'the stars'
getter = getters.build_getter(validator, getter_namespace=name)
assert callable(getter), "Getter is not callable"
value_proxy = getter('the_name')
namespace = config.get_namespace(name)
assert_in(id(value_proxy), namespace.value_proxies)
assert_equal(value_proxy.config_key, "the_name")
assert_equal(value_proxy.namespace, namespace)
def test_getters(self):
get_conf = getters.NamespaceGetters('the_space')
proxies = [
get_conf.get_bool('is_it'),
get_conf.get_time('when')
]
namespace = config.get_namespace(get_conf.namespace)
for i in xrange(len(proxies)):
assert proxies[i] is namespace.value_proxies[i]
def loader(*args, **kwargs):
err_on_unknown = kwargs.pop('error_on_unknown', False)
err_on_dupe = kwargs.pop('error_on_duplicate', False)
name = kwargs.pop('namespace', config.DEFAULT)
config_data = load_config_data(loader_func, *args, **kwargs)
config_data = dict(flatten_dict(config_data))
namespace = config.get_namespace(name)
namespace.apply_config_data(config_data, err_on_unknown, err_on_dupe)
return config_data
def loader(*args, **kwargs):
err_on_unknown = kwargs.pop('error_on_unknown', False)
err_on_dupe = kwargs.pop('error_on_duplicate', False)
name = kwargs.pop('namespace', config.DEFAULT)
config_data = load_config_data(loader_func, *args, **kwargs)
config_data = dict(flatten_dict(config_data))
namespace = config.get_namespace(name)
namespace.apply_config_data(config_data, err_on_unknown, err_on_dupe)
return config_data
def test_getters(self):
get_conf = getters.NamespaceGetters(self.namespace)
proxies = [
get_conf.get_bool('is_it'),
get_conf.get_time('when'),
get_conf.get_list_of_bool('options')
]
namespace = config.get_namespace(get_conf.namespace)
for proxy in proxies:
assert_in(id(proxy), namespace.value_proxies)
def test_getters(self):
get_conf = getters.NamespaceGetters(self.namespace)
proxies = [
get_conf.get_bool('is_it'),
get_conf.get_time('when'),
get_conf.get_list_of_bool('options')
]
namespace = config.get_namespace(get_conf.namespace)
for proxy in proxies:
assert_in(id(proxy), namespace.value_proxies)
def loader(*args, **kwargs):
error_on_unknown = kwargs.pop('error_on_unknown', False)
error_on_duplicate = kwargs.pop('error_on_duplicate', False)
name = kwargs.pop('namespace', config.DEFAULT)
config_data = load_config_data(loader_func, *args, **kwargs)
config_data = dict(flatten_dict(config_data))
namespace = config.get_namespace(name)
namespace.validate_keys(config_data.keys(), error_on_unknown)
namespace.has_duplicate_keys(config_data, error_on_duplicate)
namespace.update_values(config_data)
return config_data
def loader(*args, **kwargs):
err_on_unknown = kwargs.pop('error_on_unknown', False)
log_keys_only = kwargs.pop('log_keys_only', False)
err_on_dupe = kwargs.pop('error_on_duplicate', False)
flatten = kwargs.pop('flatten', True)
name = kwargs.pop('namespace', config.DEFAULT)
config_data = load_config_data(loader_func, *args, **kwargs)
if flatten:
config_data = dict(flatten_dict(config_data))
namespace = config.get_namespace(name)
namespace.apply_config_data(
config_data,
err_on_unknown,
err_on_dupe,
log_keys_only=log_keys_only,
)
return config_data
def loader(*args, **kwargs):
err_on_unknown = kwargs.pop('error_on_unknown', False)
log_keys_only = kwargs.pop('log_keys_only', False)
err_on_dupe = kwargs.pop('error_on_duplicate', False)
flatten = kwargs.pop('flatten', True)
name = kwargs.pop('namespace', config.DEFAULT)
config_data = load_config_data(loader_func, *args, **kwargs)
if flatten:
config_data = dict(flatten_dict(config_data))
namespace = config.get_namespace(name)
namespace.apply_config_data(
config_data,
err_on_unknown,
err_on_dupe,
log_keys_only=log_keys_only,
)
return config_data
def parse_config(config_file: str, watch_config: bool = False):
""" Parses yaml config file (if indicated)
:param str config_file: config file path
:param bool watch_config: perform necessary setup to enable configuration hot swaps
"""
with open(config_file) as f:
config_data = yaml.safe_load(f)
config_probe_names = {
key
for key in config_data if not key.startswith('_')
}
current_probe_names = {ns.name for ns in _get_probe_namespaces()}
if watch_config and current_probe_names and config_probe_names != current_probe_names:
# probes added or removed, triggering restart
_drop_namespaces(current_probe_names - config_probe_names)
return _clear_and_restart()
for key in config_probe_names:
probe_config = config_data[key]
config_namespace = get_namespace(key)
current_values = config_namespace.get_config_values().copy()
if key not in HOTSWAP_CALLBACK_NAMESPACE:
# First time loading
callback_method = partial(_forward_config_change,
SimpleQueue()) if watch_config else None
DictConfiguration({key: callback_method},
namespace=HOTSWAP_CALLBACK_NAMESPACE.name)
elif watch_config:
is_different = probe_config != current_values
if is_different and _non_hotswap_settings(
probe_config) != _non_hotswap_settings(current_values):
# Non hot-swappable setting changed -> restart
return _clear_and_restart()
elif is_different:
# Only hot-swappable settings changed, trigger proble filters reload
HOTSWAP_CALLBACK_NAMESPACE[key](probe_config)
# staticconf does clear namespaces before reloads, so we do it ourselves
config_namespace.clear()
DictConfiguration(probe_config, namespace=key, flatten=False)
def test_get_namespace_existing(self):
name = 'the_common_name'
namespace = config.get_namespace(name)
assert_equal(namespace, config.get_namespace(name))
def test_get_namespace_new(self):
name = 'some_unlikely_name'
assert name not in config.configuration_namespaces
config.get_namespace(name)
assert name in config.configuration_namespaces
def __init__(self, *args, **kwargs):
name = kwargs.pop('namespace', config.DEFAULT)
self.namespace = config.get_namespace(name)
self.config_data = dict(loader.flatten_dict(dict(*args, **kwargs)))
self.old_values = None
def get_namespace(cls, attributes):
if 'namespace' not in attributes:
raise errors.ConfigurationError("ConfigSchema requires a namespace.")
return config.get_namespace(attributes['namespace'])
def reader(config_key, default=UndefToken, namespace=None):
config_namespace = config.get_namespace(namespace or reader_namespace)
return validator(_read_config(config_key, config_namespace, default))
def proxy_register(key_name, default=UndefToken, help=None, namespace=None):
name = namespace or getter_namespace or config.DEFAULT
namespace = config.get_namespace(name)
return proxy_factory.build(validator, namespace, key_name, default, help)
def get_namespace(cls, attributes):
if 'namespace' not in attributes:
raise errors.ConfigurationError(
"ConfigSchema requires a namespace.")
return config.get_namespace(attributes['namespace'])
def reader(config_key, default=UndefToken, namespace=None):
config_namespace = config.get_namespace(namespace or reader_namespace)
return validator(_read_config(config_key, config_namespace, default))
def proxy_register(key_name, default=UndefToken, help=None, namespace=None):
name = namespace or getter_namespace or config.DEFAULT
namespace = config.get_namespace(name)
value_proxy = proxy.ValueProxy(validator, namespace, key_name, default)
register_value_proxy(namespace, value_proxy, help)
return value_proxy
def test_get_namespace_new(self):
name = 'some_unlikely_name'
assert name not in config.configuration_namespaces
config.get_namespace(name)
assert name in config.configuration_namespaces
def test_get_namespace_existing(self):
name = 'the_common_name'
namespace = config.get_namespace(name)
assert_equal(namespace, config.get_namespace(name))
from typing import Optional
from typing import Tuple
import staticconf.config
import yaml
from staticconf.config import ConfigNamespace
from staticconf.config import ConfigurationWatcher
from staticconf.config import DEFAULT as DEFAULT_NAMESPACE
from staticconf.config import get_namespace
from staticconf.config import get_namespaces_from_names
from staticconf.loader import DictConfiguration
from pidtree_bcc.utils import never_crash
from pidtree_bcc.utils import self_restart
HOTSWAP_CALLBACK_NAMESPACE = get_namespace('__change_callbacks')
HOT_SWAPPABLE_SETTINGS = ('filters', 'excludeports', 'includeports')
@never_crash
def _forward_config_change(queue: SimpleQueue, config_data: dict):
queue.put(config_data)
def _non_hotswap_settings(config_data: dict) -> dict:
return {
k: v
for k, v in config_data.items() if k not in HOT_SWAPPABLE_SETTINGS
}
