# Copyright 2015 Red Hat, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. """Support for introspection rules.""" import jsonpath_rw as jsonpath import jsonschema from oslo_utils import uuidutils from ironic_inspector.common.i18n import _ from ironic_inspector.db import api as db from ironic_inspector.db import model from ironic_inspector.plugins import base as plugins_base from ironic_inspector import utils LOG = utils.getProcessingLogger(__name__) _CONDITIONS_SCHEMA = None _ACTIONS_SCHEMA = None def conditions_schema(): global _CONDITIONS_SCHEMA if _CONDITIONS_SCHEMA is None: condition_plugins = [x.name for x in plugins_base.rule_conditions_manager()] _CONDITIONS_SCHEMA = { "title": "Inspector rule conditions schema", "type": "array", # we can have rules that always apply "minItems": 0, "items": { "type": "object", # field might become optional in the future, but not right now "required": ["op", "field"], "properties": { "op": { "description": "condition operator", "enum": condition_plugins }, "field": { "description": "JSON path to field for matching", "type": "string" }, "multiple": { "description": "how to treat multiple values", "enum": ["all", "any", "first"] }, "invert": { "description": "whether to invert the result", "type": "boolean" }, }, # other properties are validated by plugins "additionalProperties": True } } return _CONDITIONS_SCHEMA def actions_schema(): global _ACTIONS_SCHEMA if _ACTIONS_SCHEMA is None: action_plugins = [x.name for x in plugins_base.rule_actions_manager()] _ACTIONS_SCHEMA = { "title": "Inspector rule actions schema", "type": "array", "minItems": 1, "items": { "type": "object", "required": ["action"], "properties": { "action": { "description": "action to take", "enum": action_plugins }, }, # other properties are validated by plugins "additionalProperties": True } } return _ACTIONS_SCHEMA class IntrospectionRule(object): """High-level class representing an introspection rule.""" def __init__(self, uuid, conditions, actions, description, scope=None): """Create rule object from database data.""" self._uuid = uuid self._conditions = conditions self._actions = actions self._description = description self._scope = scope def as_dict(self, short=False): result = { 'uuid': self._uuid, 'description': self._description, 'scope': self._scope } if not short: result['conditions'] = [c.as_dict() for c in self._conditions] result['actions'] = [a.as_dict() for a in self._actions] return result @property def description(self): return self._description or self._uuid def check_conditions(self, node_info, data): """Check if conditions are true for a given node. :param node_info: a NodeInfo object :param data: introspection data :returns: True if conditions match, otherwise False """ LOG.debug('Checking rule "%s"', self.description, node_info=node_info, data=data) ext_mgr = plugins_base.rule_conditions_manager() for cond in self._conditions: scheme, path = _parse_path(cond.field) if scheme == 'node': source_data = node_info.node().to_dict() elif scheme == 'data': source_data = data field_values = jsonpath.parse(path).find(source_data) field_values = [x.value for x in field_values] cond_ext = ext_mgr[cond.op].obj if not field_values: if cond_ext.ALLOW_NONE: LOG.debug('Field with JSON path %s was not found in data', cond.field, node_info=node_info, data=data) field_values = [None] else: LOG.info('Field with JSON path %(path)s was not found ' 'in data, rule "%(rule)s" will not ' 'be applied', {'path': cond.field, 'rule': self.description}, node_info=node_info, data=data) return False for value in field_values: result = cond_ext.check(node_info, value, cond.params) if cond.invert: result = not result if (cond.multiple == 'first' or (cond.multiple == 'all' and not result) or (cond.multiple == 'any' and result)): break if not result: LOG.info('Rule "%(rule)s" will not be applied: condition ' '%(field)s %(op)s %(params)s failed', {'rule': self.description, 'field': cond.field, 'op': cond.op, 'params': cond.params}, node_info=node_info, data=data) return False LOG.info('Rule "%s" will be applied', self.description, node_info=node_info, data=data) return True def apply_actions(self, node_info, data=None): """Run actions on a node. :param node_info: NodeInfo instance :param data: introspection data """ LOG.debug('Running actions for rule "%s"', self.description, node_info=node_info, data=data) ext_mgr = plugins_base.rule_actions_manager() for act in self._actions: ext = ext_mgr[act.action].obj for formatted_param in ext.FORMATTED_PARAMS: try: initial = act.params[formatted_param] except KeyError: # Ignore parameter that wasn't given. continue else: act.params[formatted_param] = _format_value(initial, data) LOG.debug('Running action `%(action)s %(params)s`', {'action': act.action, 'params': act.params}, node_info=node_info, data=data) ext.apply(node_info, act.params) LOG.debug('Successfully applied actions', node_info=node_info, data=data) def check_scope(self, node_info): """Check if node's scope falls under rule._scope and rule is applicable :param node_info: a NodeInfo object :returns: True if conditions match, otherwise False """ if not self._scope: LOG.debug('Rule "%s" is global and will be applied if conditions ' 'are met.', self._description) return True if self._scope == node_info.node().properties.get('inspection_scope'): LOG.debug('Rule "%s" and node have a matching scope "%s and will ' 'be applied if conditions are met.', self._description, self._scope) return True else: LOG.debug('Rule\'s "%s" scope "%s" does not match node\'s scope. ' 'Rule will be ignored', self._description, self._scope) return False def _format_value(value, data): """Apply parameter formatting to a value. Format strings with the values from `data`. If `value` is a dict or list, any string members (and any nested string members) will also be formatted recursively. This includes both keys and values for dicts. :param value: The string to format, or container whose members to format. :param data: Introspection data. :returns: `value`, formatted with the parameters from `data`. """ if isinstance(value, str): # NOTE(aarefiev): verify provided value with introspection # data format specifications. # TODO(aarefiev): simple verify on import rule time. try: return value.format(data=data) except KeyError as e: raise utils.Error(_('Invalid formatting variable key ' 'provided in value %(val)s: %(e)s'), {'val': value, 'e': e}, data=data) elif isinstance(value, dict): return {_format_value(k, data): _format_value(v, data) for k, v in value.items()} elif isinstance(value, list): return [_format_value(v, data) for v in value] else: # Assume this is a 'primitive' value. return value def _parse_path(path): """Parse path, extract scheme and path. Parse path with 'node' and 'data' scheme, which links on introspection data and node info respectively. If scheme is missing in path, default is 'data'. :param path: data or node path :return: tuple (scheme, path) """ try: index = path.index('://') except ValueError: scheme = 'data' path = path else: scheme = path[:index] path = path[index + 3:] return scheme, path def _validate_conditions(conditions_json): """Validates conditions from jsonschema. :returns: a list of conditions. """ try: jsonschema.validate(conditions_json, conditions_schema()) except jsonschema.ValidationError as exc: raise utils.Error(_('Validation failed for conditions: %s') % exc) cond_mgr = plugins_base.rule_conditions_manager() conditions = [] reserved_params = {'op', 'field', 'multiple', 'invert'} for cond_json in conditions_json: field = cond_json['field'] scheme, path = _parse_path(field) if scheme not in ('node', 'data'): raise utils.Error(_('Unsupported scheme for field: %s, valid ' 'values are node:// or data://') % scheme) # verify field as JSON path try: jsonpath.parse(path) except Exception as exc: raise utils.Error(_('Unable to parse field JSON path %(field)s: ' '%(error)s') % {'field': field, 'error': exc}) plugin = cond_mgr[cond_json['op']].obj params = {k: v for k, v in cond_json.items() if k not in reserved_params} try: plugin.validate(params) except ValueError as exc: raise utils.Error(_('Invalid parameters for operator %(op)s: ' '%(error)s') % {'op': cond_json['op'], 'error': exc}) conditions.append((cond_json['field'], cond_json['op'], cond_json.get('multiple', 'any'), cond_json.get('invert', False), params)) return conditions def _validate_actions(actions_json): """Validates actions from jsonschema. :returns: a list of actions. """ try: jsonschema.validate(actions_json, actions_schema()) except jsonschema.ValidationError as exc: raise utils.Error(_('Validation failed for actions: %s') % exc) act_mgr = plugins_base.rule_actions_manager() actions = [] for action_json in actions_json: plugin = act_mgr[action_json['action']].obj params = {k: v for k, v in action_json.items() if k != 'action'} try: plugin.validate(params) except ValueError as exc: raise utils.Error(_('Invalid parameters for action %(act)s: ' '%(error)s') % {'act': action_json['action'], 'error': exc}) actions.append((action_json['action'], params)) return actions def create(conditions_json, actions_json, uuid=None, description=None, scope=None): """Create a new rule in database. :param conditions_json: list of dicts with the following keys: * op - operator * field - JSON path to field to compare Other keys are stored as is. :param actions_json: list of dicts with the following keys: * action - action type Other keys are stored as is. :param uuid: rule UUID, will be generated if empty :param description: human-readable rule description :param scope: if scope on node and rule matches, rule applies; if its empty, rule applies to all nodes. :returns: new IntrospectionRule object :raises: utils.Error on failure """ uuid = uuid or uuidutils.generate_uuid() LOG.debug('Creating rule %(uuid)s with description "%(descr)s", ' 'conditions %(conditions)s, scope "%(scope)s"' ' and actions %(actions)s', {'uuid': uuid, 'descr': description, 'scope': scope, 'conditions': conditions_json, 'actions': actions_json}) conditions = _validate_conditions(conditions_json) actions = _validate_actions(actions_json) rule = db.create_rule(uuid, conditions, actions, description, scope) LOG.info('Created rule %(uuid)s with description "%(descr)s" ' 'and scope "%(scope)s"', {'uuid': uuid, 'descr': description, 'scope': scope}) return IntrospectionRule(uuid=uuid, conditions=rule.conditions, actions=rule.actions, description=description, scope=rule.scope) def get(uuid): """Get a rule by its UUID.""" rule = db.get_rule(uuid=uuid) return IntrospectionRule(uuid=rule.uuid, actions=rule.actions, conditions=rule.conditions, description=rule.description, scope=rule.scope) def get_all(): """List all rules.""" with db.session_for_read() as session: query = session.query(model.Rule).order_by(model.Rule.created_at) return [IntrospectionRule(uuid=rule.uuid, actions=rule.actions, conditions=rule.conditions, description=rule.description, scope=rule.scope) for rule in query.all()] def delete(uuid): """Delete a rule by its UUID.""" db.delete_rule(uuid) LOG.info('Introspection rule %s was deleted', uuid) def delete_all(): """Delete all rules.""" db.delete_all_rules() LOG.info('All introspection rules were deleted') def apply(node_info, data): """Apply rules to a node.""" rules = get_all() if not rules: LOG.debug('No custom introspection rules to apply', node_info=node_info, data=data) return LOG.debug('Applying custom introspection rules', node_info=node_info, data=data) to_apply = [] for rule in rules: if (rule.check_scope(node_info) and rule.check_conditions(node_info, data)): to_apply.append(rule) if to_apply: LOG.debug('Running actions', node_info=node_info, data=data) for rule in to_apply: rule.apply_actions(node_info, data=data) else: LOG.debug('No actions to apply', node_info=node_info, data=data) LOG.info('Successfully applied custom introspection rules', node_info=node_info, data=data)