def _get_params_attributes(ctx, runtime_properties, params_list):
params = {}
for param_name in params_list:
params[param_name] = get_field_value_recursive(ctx.logger,
runtime_properties,
params_list[param_name])
return params
def _filter_node_instances(ctx, node_ids, node_instance_ids, type_names,
operation, node_field_path, node_field_value):
filtered_node_instances = []
for node in ctx.nodes:
# no such action skip it
if operation not in node.operations:
continue
# no such node_id, skip it
if node_ids and node.id not in node_ids:
continue
# no such node type, skip it
if type_names and not next(
(type_name
for type_name in type_names if type_name in node.type_hierarchy),
None):
continue
# look more deeply, what about instance id's and properties
for instance in node.instances:
# sorry no such id in list
if node_instance_ids and instance.id not in node_instance_ids:
continue
# look to field value
if node_field_path:
# check that we have such values in properties
runtime_properties = instance._node_instance.runtime_properties
value = get_field_value_recursive(ctx.logger,
runtime_properties,
node_field_path)
if value not in node_field_value:
continue
# looks as good instance
filtered_node_instances.append(instance)
return filtered_node_instances
def _check_filter(ctx, filter_by, inputs):
if isinstance(filter_by, list):
for field_desc in filter_by:
# check type of field_desc
if not isinstance(field_desc, dict):
ctx.logger.error("Event skipped by wrong field description.")
return False
# check path
field_path = field_desc.get('path')
if not field_path:
ctx.logger.error("Event skipped by undefined key.")
return False
# possible values
field_values = field_desc.get('values')
if not field_values:
ctx.logger.error("Event skipped by undefined values.")
return False
# check that we have such values in properties
value = get_field_value_recursive(ctx.logger, inputs, field_path)
# skip events if not in subset
if value not in field_values:
ctx.logger.error(
"Event with {value} skipped by {key}:{values} rule.".
format(value=repr(value),
key=repr(field_path),
values=repr(field_values)))
return False
else:
ctx.logger.error("Filter skipped by incorrect type of rules list.")
return False
# everything looks good
return True
def test_get_field_value_recursive(self):
logger = Mock()
# check list
self.assertEqual(
'a', filters.get_field_value_recursive(logger, ['a'], ['0']))
# not in list
self.assertEqual(
None, filters.get_field_value_recursive(logger, ['a'], ['1']))
# check dict
self.assertEqual(
'a', filters.get_field_value_recursive(logger, {'0': 'a'}, ['0']))
# not in dict
self.assertEqual(
None, filters.get_field_value_recursive(logger, {'0': 'a'}, ['1']))
# check dict in list
self.assertEqual(
'b',
filters.get_field_value_recursive(logger, [{
'a': 'b'
}], ['0', 'a']))
# check dict in list
self.assertEqual(
None, filters.get_field_value_recursive(logger, 'a', ['1', 'a']))
def _get_transaction_instances(ctx,
scale_transaction_field,
scale_node_names,
scale_node_field_path,
scale_node_field_values,
all_results=False):
client = get_rest_client()
# search transaction ids
list_kwargs = {
'deployment_id': ctx.deployment.id,
'_include': ['runtime_properties', 'node_id', 'id']
}
if all_results:
list_kwargs['_get_all_results'] = True
instances = client.node_instances.list(**list_kwargs)
transaction_ids = []
node_instances = {}
instance_ids = []
for instance in instances:
runtime_properties = instance.runtime_properties
# check that we have correct node name
if scale_node_names and instance.node_id not in scale_node_names:
continue
# check that we have such values in properties
value = get_field_value_recursive(ctx.logger, runtime_properties,
scale_node_field_path)
if value not in scale_node_field_values:
continue
# save instances to scale "settings", for case when instances created
# without transaction
if not node_instances.get(instance.node_id):
node_instances[instance.node_id] = []
# save node type (instances without transaction)
if instance.id not in node_instances[instance.node_id]:
node_instances[instance.node_id].append(instance.id)
# save exact instance id (instances without transaction)
if instance.id not in instance_ids:
instance_ids.append(instance.id)
# ignore transaction
if not scale_transaction_field:
continue
# check transactions
if not runtime_properties.get(scale_transaction_field):
continue
# save transaction to list
transaction_ids.append(runtime_properties.get(scale_transaction_field))
# list will be empty if no scale_transaction_field
if not transaction_ids:
ctx.logger.debug("List nodes: {}".format(repr(node_instances)))
ctx.logger.debug("List instances: {}".format(repr(instance_ids)))
return node_instances, instance_ids
ctx.logger.debug("Transaction ids: {}".format(repr(transaction_ids)))
# search instances for remove
instances = client.node_instances.list(**list_kwargs)
for instance in instances:
runtime_properties = instance.runtime_properties
transaction_id = runtime_properties.get(scale_transaction_field)
# not our transaction, skip
if transaction_id not in transaction_ids:
continue
# no such group yet
if not node_instances.get(instance.node_id):
node_instances[instance.node_id] = []
# maybe we already have such type
if instance.id not in node_instances[instance.node_id]:
node_instances[instance.node_id].append(instance.id)
# maybe we already have such instance
if instance.id not in instance_ids:
instance_ids.append(instance.id)
ctx.logger.debug("List nodes: {}".format(repr(node_instances)))
ctx.logger.debug("List instances: {}".format(repr(instance_ids)))
return node_instances, instance_ids