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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
package org.openecomp.sdc.toscaparser.api.elements;
import java.util.LinkedHashMap;
import java.util.Map;
import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
public class PropertyDef {
private static final String PROPERTY_KEYNAME_DEFAULT = "default";
private static final String PROPERTY_KEYNAME_REQUIRED = "required";
private static final String PROPERTY_KEYNAME_STATUS = "status";
private static final String VALID_PROPERTY_KEYNAMES[] = {
PROPERTY_KEYNAME_DEFAULT,
PROPERTY_KEYNAME_REQUIRED,
PROPERTY_KEYNAME_STATUS};
private static final boolean PROPERTY_REQUIRED_DEFAULT = true;
private static final String VALID_REQUIRED_VALUES[] = {"true", "false"};
private static final String PROPERTY_STATUS_SUPPORTED = "supported";
private static final String PROPERTY_STATUS_EXPERIMENTAL = "experimental";
private static final String VALID_STATUS_VALUES[] = {
PROPERTY_STATUS_SUPPORTED, PROPERTY_STATUS_EXPERIMENTAL};
private static final String PROPERTY_STATUS_DEFAULT = PROPERTY_STATUS_SUPPORTED;
private String name;
private Object value;
private LinkedHashMap<String,Object> schema;
private String _status;
private boolean _required;
public PropertyDef(String pdName, Object pdValue,
LinkedHashMap<String,Object> pdSchema) {
name = pdName;
value = pdValue;
schema = pdSchema;
_status = PROPERTY_STATUS_DEFAULT;
_required = PROPERTY_REQUIRED_DEFAULT;
if(schema != null) {
// Validate required 'type' property exists
if(schema.get("type") == null) {
//msg = (_('Schema definition of "%(pname)s" must have a "type" '
// 'attribute.') % dict(pname=self.name))
ExceptionCollector.appendException(String.format(
"InvalidSchemaError: Schema definition of \"%s\" must have a \"type\" attribute",name));
}
_loadRequiredAttrFromSchema();
_loadStatusAttrFromSchema();
}
}
public Object getDefault() {
if(schema != null) {
for(Map.Entry<String,Object> me: schema.entrySet()) {
if(me.getKey().equals(PROPERTY_KEYNAME_DEFAULT)) {
return me.getValue();
}
}
}
return null;
}
public boolean isRequired() {
return _required;
}
private void _loadRequiredAttrFromSchema() {
// IF 'required' keyname exists verify it's a boolean,
// if so override default
Object val = schema.get(PROPERTY_KEYNAME_REQUIRED);
if(val != null) {
if(val instanceof Boolean) {
_required = (boolean)val;
}
else {
//valid_values = ', '.join(self.VALID_REQUIRED_VALUES)
//attr = self.PROPERTY_KEYNAME_REQUIRED
//TOSCAException.generate_inv_schema_property_error(self,
// attr,
// value,
// valid_values)
ExceptionCollector.appendException(String.format(
"Schema definition of \"%s\" has \"required\" attribute with an invalid value",
name));
}
}
}
public String getStatus() {
return _status;
}
private void _loadStatusAttrFromSchema() {
// IF 'status' keyname exists verify it's a boolean,
// if so override default
String sts = (String)schema.get(PROPERTY_KEYNAME_STATUS);
if(sts != null) {
boolean bFound = false;
for(String vsv: VALID_STATUS_VALUES) {
if(vsv.equals(sts)) {
bFound = true;
break;
}
}
if(bFound) {
_status = sts;
}
else {
//valid_values = ', '.join(self.VALID_STATUS_VALUES)
//attr = self.PROPERTY_KEYNAME_STATUS
//TOSCAException.generate_inv_schema_property_error(self,
// attr,
// value,
// valid_values)
ExceptionCollector.appendWarning(String.format(
"Schema definition of \"%s\" has \"status\" attribute with an invalid value",
name));
}
}
}
public String getName() {
return name;
}
public LinkedHashMap<String,Object> getSchema() {
return schema;
}
public Object getPDValue() {
// there's getValue in EntityType...
return value;
}
}
/*python
from toscaparser.common.exception import ExceptionCollector
from toscaparser.common.exception import InvalidSchemaError
from toscaparser.common.exception import TOSCAException
from toscaparser.utils.gettextutils import _
class PropertyDef(object):
'''TOSCA built-in Property type.'''
VALID_PROPERTY_KEYNAMES = (PROPERTY_KEYNAME_DEFAULT,
PROPERTY_KEYNAME_REQUIRED,
PROPERTY_KEYNAME_STATUS) = \
('default', 'required', 'status')
PROPERTY_REQUIRED_DEFAULT = True
VALID_REQUIRED_VALUES = ['true', 'false']
VALID_STATUS_VALUES = (PROPERTY_STATUS_SUPPORTED,
PROPERTY_STATUS_EXPERIMENTAL) = \
('supported', 'experimental')
PROPERTY_STATUS_DEFAULT = PROPERTY_STATUS_SUPPORTED
def __init__(self, name, value=None, schema=None):
self.name = name
self.value = value
self.schema = schema
self._status = self.PROPERTY_STATUS_DEFAULT
self._required = self.PROPERTY_REQUIRED_DEFAULT
# Validate required 'type' property exists
try:
self.schema['type']
except KeyError:
msg = (_('Schema definition of "%(pname)s" must have a "type" '
'attribute.') % dict(pname=self.name))
ExceptionCollector.appendException(
InvalidSchemaError(message=msg))
if self.schema:
self._load_required_attr_from_schema()
self._load_status_attr_from_schema()
@property
def default(self):
if self.schema:
for prop_key, prop_value in self.schema.items():
if prop_key == self.PROPERTY_KEYNAME_DEFAULT:
return prop_value
return None
@property
def required(self):
return self._required
def _load_required_attr_from_schema(self):
# IF 'required' keyname exists verify it's a boolean,
# if so override default
if self.PROPERTY_KEYNAME_REQUIRED in self.schema:
value = self.schema[self.PROPERTY_KEYNAME_REQUIRED]
if isinstance(value, bool):
self._required = value
else:
valid_values = ', '.join(self.VALID_REQUIRED_VALUES)
attr = self.PROPERTY_KEYNAME_REQUIRED
TOSCAException.generate_inv_schema_property_error(self,
attr,
value,
valid_values)
@property
def status(self):
return self._status
def _load_status_attr_from_schema(self):
# IF 'status' keyname exists verify it's a valid value,
# if so override default
if self.PROPERTY_KEYNAME_STATUS in self.schema:
value = self.schema[self.PROPERTY_KEYNAME_STATUS]
if value in self.VALID_STATUS_VALUES:
self._status = value
else:
valid_values = ', '.join(self.VALID_STATUS_VALUES)
attr = self.PROPERTY_KEYNAME_STATUS
TOSCAException.generate_inv_schema_property_error(self,
attr,
value,
valid_values)
*/
|
