def test_filename_with_file_source(self):
source = confuse.ConfigSource({'foo': 'foo/bar'},
filename='/baz/config.yaml')
config = _root(source)
config.config_dir = lambda: '/config/path'
valid = config['foo'].get(confuse.Filename())
self.assertEqual(valid, os.path.realpath('/config/path/foo/bar'))
def load(filename=None):
"""
Loads a file and imports the settings
:param filename: the file to import
"""
config = confuse.LazyConfig('Yatcobot', __name__)
# Add default config when in egg (using this way because egg is breaking the default way)
if len(config.sources) == 0:
default_config_text = pkg_resources.resource_string("yatcobot.config", "config_default.yaml")
default_config = confuse.ConfigSource(yaml.load(default_config_text, Loader=confuse.Loader),
'pkg/config/config_default.yaml',
True)
config.add(default_config)
# Add user specified config
if filename is not None and os.path.isfile(filename):
config.set_file(filename)
logger.info('Loading config files (From highest priority to lowest):')
config.resolve()
for i, config_source in enumerate(config.sources):
logger.info(f'{i}: Path: {config_source.filename}')
# Update template from plugins
template = Config.get_template()
Config._valid = config.get(template)
def test_filename_in_app_dir_overrides_config_source_dir(self):
source = confuse.ConfigSource({'foo': 'foo/bar'},
filename='/baz/config.yaml',
base_for_paths=True)
config = _root(source)
config.config_dir = lambda: '/config/path'
valid = config['foo'].get(confuse.Filename(in_app_dir=True))
self.assertEqual(valid, os.path.realpath('/config/path/foo/bar'))
def test_as_filename_with_default_source(self):
source = confuse.ConfigSource({'foo': 'foo/bar'},
filename='/baz/config.yaml',
default=True)
config = _root(source)
config.config_dir = lambda: '/config/path'
value = config['foo'].as_filename()
self.assertEqual(value, os.path.realpath('/config/path/foo/bar'))
def config_stack(*sources):
"""Uses Confuse config flattener to merge together nested config sources.
The main goal here is to allow multiple sources to merge smoothly rather
than completely overwrite contents for nested properties.
In this example, a is the project config and b is the config from command
arguments. We want the command arguments to overwrite the project config,
but a standard a.update(b) would not give the desired results
a = {'foo': {'bar': 42, 'baz': 24}}
b = {'foo': {'bar': 123}}
>>> a.update(b)
>>> a
{'foo': {'bar': 123}}
Instead config stack gives us a union:
>>> config_stack(a, b)
{'foo': {'bar': 123, 'baz': 24}}
Warning: this is accomplished with a couple hacks -
1) To prevent Confuse from searching the filesystem for existing config
files, an unlikely name is added to the Configuration object when it's
created.
2) The resulting config object is json dumped then loaded to get convert
the ordered dictionaries to standard dicts. So.. high performance is not a
focus here.
3) Appending/extending a nested array is still not possible:
>>> b = {'foo': {'bar': [42, 24,]}}
>>> a = {'foo': {'bar': [123,]}}
>>> jetstream.utils.config_stack(a, b)
{'foo': {'bar': [42, 24]}}
"""
# Hack to prevent Confuse from accidentally finding a config file on the
# system when were just trying to create an in-memory config object
n = 'UNLIKELYAPPNAME-' + str(uuid4())
conf = confuse.Configuration(n, read=False)
for s in sources:
if s:
if isinstance(s, Mapping):
conf.set(confuse.ConfigSource(s))
else:
err = 'Config sources should return Mapping-type objects'
raise ValueError(err)
# Hack to remove the ordereddicts, they're just ugly to look at and when
# working with primitive data types coming from json/yaml files they're
# generally useless.
return json.loads(json.dumps(conf.flatten()))
def add_config(self, configfn):
self.__config.add(
confuse.ConfigSource(confuse.load_yaml(configfn), configfn))
self.update_conf()
def _add_default_source(self):
filename = self.default_config
self.add(
confuse.ConfigSource(confuse.load_yaml(filename), filename, True))
def _add_user_source(self):
if not Path(self._config).is_file():
Path(self._config).write_bytes(Path(self._default).read_bytes())
data = confuse.load_yaml(self._config, loader=self.loader)
self.add(
confuse.ConfigSource(data, filename=self._config, default=True))
def _add_default_source(self):
assert Path(self._default).is_file()
data = confuse.load_yaml(self._default, loader=self.loader)
self.add(
confuse.ConfigSource(data, filename=self._default, default=True))
def test_filename_in_app_dir_non_file_source(self):
source = confuse.ConfigSource({'foo': 'foo/bar'})
config = _root(source)
config.config_dir = lambda: '/config/path'
valid = config['foo'].get(confuse.Filename(in_app_dir=True))
self.assertEqual(valid, os.path.realpath('/config/path/foo/bar'))
'device': str,
'username': str,
'password': str,
'domain': str,
'ac_policy': str,
'intrusion_policy': str,
'file_policy': str,
'variable_set': str,
'syslog_to_server': str,
'log_to_fmc': bool,
'log_at_begin': bool,
'log_at_end': bool
}
config = confuse.Configuration('fmc-tools', __name__)
try:
config.add(confuse.ConfigSource(confuse.load_yaml('config.yaml'), 'config.yaml', True))
except confuse.ConfigReadError:
pass
config.add(confuse.ConfigSource(confuse.load_yaml('config_default.yaml'), 'config_default.yaml', True))
valid = config.get(template)
# Set variables for execution.
# Make sure your credentials are correct.
# Make sure ACP and all logging and inspection objects already exist.
loglevel = valid.loglevel
device = valid.device
username = valid.username
password = valid.password
domain = valid.domain
