def check_restrictions(cls, models, restrictions, action=None):
"""Check if attribute satisfied restrictions
:param models: objects which represent models in restrictions
:type models: dict
:param restrictions: list of restrictions to check
:type restrictions: list
:param action: filtering restrictions by action key
:type action: string
:returns: dict -- object with 'result' as number and 'message' as dict
"""
satisfied = []
if restrictions:
expened_restrictions = map(
cls._expand_restriction, restrictions)
# Filter by action
if action:
filterd_by_action_restrictions = filter(
lambda item: item.get('action') == action,
expened_restrictions)
else:
filterd_by_action_restrictions = expened_restrictions[:]
# Filter which restriction satisfied condition
satisfied = filter(
lambda item: Expression(
item.get('condition'), models).evaluate(),
filterd_by_action_restrictions)
return {
'result': bool(satisfied),
'message': '. '.join([item.get('message') for item in
satisfied if item.get('message')])
}
def check_roles_requirement(cls, roles, roles_metadata, models):
for role in roles:
if "depends" in roles_metadata[role]:
depends = roles_metadata[role]['depends']
for condition in depends:
expression = condition['condition']
if not Expression(expression, models).evaluate():
raise errors.InvalidData(condition['warning'])
def evaluate(condition):
try:
logger.debug("evaluate legacy condition: %s", condition)
return Expression(
Context.transform_legacy_condition(condition),
context,
strict=False).evaluate()
except Exception as e:
logger.error("Failed to evaluate legacy condition '%s': %s",
condition, e)
raise
def test_plugin_role_restrictions_normalization(self):
# checking presence and syntax of generated restriction
for role, meta in six.iteritems(
self.plugin_adapter.normalized_roles_metadata):
for condition in meta['restrictions']:
self.assertNotRaises(
errors.ParseError,
lambda: Expression(condition, {
'settings':
self.cluster.attributes.editable
},
strict=False).evaluate())
def check_roles_requirement(cls, roles, roles_metadata, models):
for role in roles:
if "restrictions" in roles_metadata[role]:
restrictions = roles_metadata[role]['restrictions']
for condition in restrictions:
expression = condition['condition']
if Expression(expression, models).evaluate():
message = condition.get('message', expression)
raise errors.InvalidNodeRole(
"Role '{}' restrictions mismatch: {}"
.format(role, message))
def _evaluate_expression(self, expression, models):
"""Evaluate expression if it exists"""
if expression:
return Expression(str(expression), models).evaluate()
def evaluate_expression(expression, models, strict):
return Expression(expression, models, strict).evaluate()
def should_execute(self):
if 'condition' not in self.task:
return True
return Expression(self.task['condition'],
self._expression_context).evaluate()
def evaluate_expression(expression, models):
return Expression(expression, models).evaluate()
