def test_same_list_if_expr_invquery_different_flags(self):
inventory = {
'node1': NodeInventory({'a': 1}, True),
'node2': NodeInventory({'a': 2}, True),
'node3': NodeInventory({'a': 2}, False)
}
parameters = Parameters(
{
'alpha': '$[ if exports:a == 2 ]',
'beta': '$[ +AllEnvs if exports:a == 2]'
}, SETTINGS, '')
result = {'alpha': ['node2'], 'beta': ['node2', 'node3']}
parameters.interpolate(inventory)
self.assertEqual(parameters.as_dict(), result)
def test_exports_with_refs(self):
inventory = self._make_inventory({
'node1': {
'a': 1,
'b': 2
},
'node2': {
'a': 3,
'b': 4
}
})
node3_exports = Exports({'a': '${a}', 'b': '${b}'}, SETTINGS, '')
node3_parameters = Parameters({
'name': 'node3',
'a': '${c}',
'b': 5
}, SETTINGS, '')
node3_parameters.merge({'c': 3})
node3_entity = Entity(SETTINGS,
classes=None,
applications=None,
parameters=node3_parameters,
exports=node3_exports)
node3_entity.interpolate_exports()
inventory['node3'] = NodeInventory(node3_entity.exports.as_dict(),
True)
result = {
'node1': NodeInventory({
'a': 1,
'b': 2
}, True),
'node2': NodeInventory({
'a': 3,
'b': 4
}, True),
'node3': NodeInventory({
'a': 3,
'b': 5
}, True)
}
self.assertDictEqual(inventory, result)
def _get_inventory(self, all_envs, environment, queries):
'''
Returns a dictionary of NodeInventory objects, one per matching node. Exports
which are required for the given queries (or all exports if the queries is None)
are rendered, remaining exports are left unrendered.
Args:
all_envs - if True match export values from nodes in any environment
else if False match only for nodes in the same environment as the
environment parameter
environment - node environment to match against if all_envs is False
queries - list of inventory queries to determine required export values
or if None match all exports defined by a node
'''
inventory = {}
for nodename in self._storage.enumerate_nodes():
try:
node_base = self._storage.get_node(nodename, self._settings)
if node_base.environment is None:
node_base.environment = self._settings.default_environment
except yaml.scanner.ScannerError as e:
if self._settings.inventory_ignore_failed_node:
continue
raise
if all_envs or node_base.environment == environment:
try:
node = self._node_entity(nodename)
except ClassNotFound as e:
raise InvQueryClassNotFound(e)
except ClassNameResolveError as e:
raise InvQueryClassNameResolveError(e)
if queries is None:
# This only happens if reclass is called with the --inventory option
try:
node.interpolate_exports()
except InterpolationError as e:
e.nodename = nodename
else:
node.initialise_interpolation()
for p, q in queries:
try:
node.interpolate_single_export(q)
except InterpolationError as e:
e.nodename = nodename
raise InvQueryError(q.contents,
e,
context=p,
uri=q.uri)
inventory[nodename] = NodeInventory(
node.exports.as_dict(),
node_base.environment == environment)
return inventory
def test_exports_failed_render_ignore(self):
node1_exports = Exports({'a': '${a}'}, SETTINGS, '')
node1_parameters = Parameters(
{
'name': 'node1',
'a': 1,
'exp': '$[ +IgnoreErrors exports:a ]'
}, SETTINGS, '')
node1_entity = Entity(SETTINGS,
classes=None,
applications=None,
parameters=node1_parameters,
exports=node1_exports)
node2_exports = Exports({'a': '${b}'}, SETTINGS, '')
node2_parameters = Parameters({'name': 'node1', 'a': 2}, SETTINGS, '')
node2_entity = Entity(SETTINGS,
classes=None,
applications=None,
parameters=node2_parameters,
exports=node2_exports)
node1_entity.initialise_interpolation()
node2_entity.initialise_interpolation()
queries = node1_entity.parameters.get_inv_queries()
for p, q in queries:
node1_entity.interpolate_single_export(q)
node2_entity.interpolate_single_export(q)
res_inv = {
'node1': NodeInventory({'a': 1}, True),
'node2': NodeInventory({}, True)
}
res_params = {'name': 'node1', 'a': 1, 'exp': {'node1': 1}}
inventory = self._make_inventory({
'node1':
node1_entity.exports.as_dict(),
'node2':
node2_entity.exports.as_dict()
})
node1_entity.interpolate(inventory)
self.assertDictEqual(node1_parameters.as_dict(), res_params)
self.assertDictEqual(inventory, res_inv)
def test_exports_with_nested_references(self):
inventory = self._make_inventory({
'node1': {
'alpha': {
'a': 1,
'b': 2
}
},
'node2': {
'alpha': {
'a': 3,
'b': 4
}
}
})
node3_exports = Exports({'alpha': '${alpha}'}, SETTINGS, '')
node3_parameters = Parameters(
{
'name': 'node3',
'alpha': {
'a': '${one}',
'b': '${two}'
},
'beta': '$[ exports:alpha ]',
'one': '111',
'two': '${three}',
'three': '123'
}, SETTINGS, '')
node3_entity = Entity(SETTINGS,
classes=None,
applications=None,
parameters=node3_parameters,
exports=node3_exports)
res_params = {
'name': 'node3',
'alpha': {
'a': '111',
'b': '123'
},
'beta': {
'node1': {
'a': 1,
'b': 2
},
'node2': {
'a': 3,
'b': 4
},
'node3': {
'a': '111',
'b': '123'
}
},
'one': '111',
'two': '123',
'three': '123'
}
res_inv = {
'node1': NodeInventory({'alpha': {
'a': 1,
'b': 2
}}, True),
'node2': NodeInventory({'alpha': {
'a': 3,
'b': 4
}}, True),
'node3': NodeInventory({'alpha': {
'a': '111',
'b': '123'
}}, True)
}
node3_entity.interpolate_exports()
inventory['node3'] = NodeInventory(node3_entity.exports.as_dict(),
True)
node3_entity.interpolate(inventory)
self.assertDictEqual(node3_parameters.as_dict(), res_params)
self.assertDictEqual(inventory, res_inv)
def test_exports_with_ancestor_references(self):
inventory = self._make_inventory({
'node1': {
'alpha': {
'beta': {
'a': 1,
'b': 2
}
}
},
'node2': {
'alpha': {
'beta': {
'a': 3,
'b': 4
}
}
}
})
node3_exports = Exports({'alpha': '${alpha}'}, SETTINGS, '')
node3_parameters = Parameters(
{
'name': 'node3',
'alpha': {
'beta': {
'a': 5,
'b': 6
}
},
'exp': '$[ exports:alpha:beta ]'
}, SETTINGS, '')
node3_entity = Entity(SETTINGS,
classes=None,
applications=None,
parameters=node3_parameters,
exports=node3_exports)
res_params = {
'name': 'node3',
'exp': {
'node1': {
'a': 1,
'b': 2
},
'node2': {
'a': 3,
'b': 4
},
'node3': {
'a': 5,
'b': 6
}
},
'alpha': {
'beta': {
'a': 5,
'b': 6
}
}
}
res_inv = {
'node1': NodeInventory({'alpha': {
'beta': {
'a': 1,
'b': 2
}
}}, True),
'node2': NodeInventory({'alpha': {
'beta': {
'a': 3,
'b': 4
}
}}, True),
'node3': NodeInventory({'alpha': {
'beta': {
'a': 5,
'b': 6
}
}}, True)
}
node3_entity.initialise_interpolation()
queries = node3_entity.parameters.get_inv_queries()
for p, q in queries:
node3_entity.interpolate_single_export(q)
inventory['node3'] = NodeInventory(node3_entity.exports.as_dict(),
True)
node3_entity.interpolate(inventory)
self.assertDictEqual(node3_parameters.as_dict(), res_params)
self.assertDictEqual(inventory, res_inv)
def test_reference_to_an_export(self):
inventory = self._make_inventory({
'node1': {
'a': 1,
'b': 2
},
'node2': {
'a': 3,
'b': 4
}
})
node3_exports = Exports({'a': '${a}', 'b': '${b}'}, SETTINGS, '')
node3_parameters = Parameters(
{
'name': 'node3',
'ref': '${exp}',
'a': '${c}',
'b': 5
}, SETTINGS, '')
node3_parameters.merge({'c': 3, 'exp': '$[ exports:a ]'})
node3_entity = Entity(SETTINGS,
classes=None,
applications=None,
parameters=node3_parameters,
exports=node3_exports)
node3_entity.interpolate_exports()
inventory['node3'] = NodeInventory(node3_entity.exports.as_dict(),
True)
node3_entity.interpolate(inventory)
res_inv = {
'node1': NodeInventory({
'a': 1,
'b': 2
}, True),
'node2': NodeInventory({
'a': 3,
'b': 4
}, True),
'node3': NodeInventory({
'a': 3,
'b': 5
}, True)
}
res_params = {
'a': 3,
'c': 3,
'b': 5,
'name': 'node3',
'exp': {
'node1': 1,
'node3': 3,
'node2': 3
},
'ref': {
'node1': 1,
'node3': 3,
'node2': 3
}
}
self.assertDictEqual(node3_parameters.as_dict(), res_params)
self.assertDictEqual(inventory, res_inv)
def _make_inventory(self, nodes):
return {
name: NodeInventory(node, True)
for name, node in iteritems(nodes)
}