1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You 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.
import re
from aria.modeling.constraints import NodeTemplateConstraint
from aria.modeling.utils import NodeTemplateContainerHolder
from aria.modeling.functions import evaluate
from aria.parser import implements_specification
@implements_specification('3.5.2-2', 'tosca-simple-1.0')
class EvaluatingNodeTemplateConstraint(NodeTemplateConstraint):
"""
A version of :class:`NodeTemplateConstraint` with boilerplate initialization for TOSCA
constraints.
"""
def __init__(self, property_name, capability_name, constraint, as_list=False):
self.property_name = property_name
self.capability_name = capability_name
self.constraint = constraint
self.as_list = as_list
def matches(self, source_node_template, target_node_template):
# TOSCA node template constraints can refer to either capability properties or node
# template properties
if self.capability_name is not None:
# Capability property
capability = target_node_template.capability_templates.get(self.capability_name)
value = capability.properties.get(self.property_name) \
if capability is not None else None # Parameter
else:
# Node template property
value = target_node_template.properties.get(self.property_name) # Parameter
value = value.value if value is not None else None
container_holder = NodeTemplateContainerHolder(source_node_template)
if self.as_list:
constraints = []
for constraint in self.constraint:
evaluation = evaluate(constraint, container_holder)
if evaluation is not None:
constraints.append(evaluation.value)
else:
constraints.append(constraint)
constraint = constraints
else:
evaluation = evaluate(self.constraint, container_holder)
if evaluation is not None:
constraint = evaluation.value
else:
constraint = self.constraint
return self.matches_evaluated(value, constraint)
def matches_evaluated(self, value, constraint):
raise NotImplementedError
class Equal(EvaluatingNodeTemplateConstraint):
def matches_evaluated(self, value, constraint):
return value == constraint
class GreaterThan(EvaluatingNodeTemplateConstraint):
def matches_evaluated(self, value, constraint):
return value > constraint
class GreaterOrEqual(EvaluatingNodeTemplateConstraint):
def matches_evaluated(self, value, constraint):
return value >= constraint
class LessThan(EvaluatingNodeTemplateConstraint):
def matches_evaluated(self, value, constraint):
return value < constraint
class LessOrEqual(EvaluatingNodeTemplateConstraint):
def matches_evaluated(self, value, constraint):
return value <= constraint
class InRange(EvaluatingNodeTemplateConstraint):
def __init__(self, property_name, capability_name, constraint):
super(InRange, self).__init__(property_name, capability_name, constraint, as_list=True)
def matches_evaluated(self, value, constraints):
lower, upper = constraints
if value < lower:
return False
if (upper != 'UNBOUNDED') and (value > upper):
return False
return True
class ValidValues(EvaluatingNodeTemplateConstraint):
def __init__(self, property_name, capability_name, constraint):
super(ValidValues, self).__init__(property_name, capability_name, constraint, as_list=True)
def matches_evaluated(self, value, constraints):
return value in constraints
class Length(EvaluatingNodeTemplateConstraint):
def matches_evaluated(self, value, constraint):
return len(value) == constraint
class MinLength(EvaluatingNodeTemplateConstraint):
def matches_evaluated(self, value, constraint):
return len(value) >= constraint
class MaxLength(EvaluatingNodeTemplateConstraint):
def matches_evaluated(self, value, constraint):
return len(value) <= constraint
class Pattern(EvaluatingNodeTemplateConstraint):
def matches_evaluated(self, value, constraint):
# From TOSCA 1.0 3.5.2.1:
#
# "Note: Future drafts of this specification will detail the use of regular expressions and
# reference an appropriate standardized grammar."
#
# So we will just use Python's.
return re.match(constraint, unicode(value)) is not None
|
