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
|
package org.openecomp.sdc.toscaparser.api.elements;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;
import org.openecomp.sdc.toscaparser.api.UnsupportedType;
import org.openecomp.sdc.toscaparser.api.common.ExceptionCollector;
import org.openecomp.sdc.toscaparser.api.elements.AttributeDef;
import org.openecomp.sdc.toscaparser.api.elements.EntityType;
import org.openecomp.sdc.toscaparser.api.elements.PropertyDef;
import org.openecomp.sdc.toscaparser.api.utils.ThreadLocalsHolder;
public class StatefulEntityType extends EntityType {
// Class representing TOSCA states
public static final String interfacesNodeLifecycleOperations[] = {
"create", "configure", "start", "stop", "delete"};
public static final String interfacesRelationshipConfigureOperations[] = {
"post_configure_source", "post_configure_target", "add_target", "remove_target"};
public StatefulEntityType() {
// void constructor for subclasses that don't want super
}
@SuppressWarnings("unchecked")
public StatefulEntityType(String entityType, String prefix, LinkedHashMap<String,Object> customDef) {
String entireEntityType = entityType;
if(UnsupportedType.validateType(entireEntityType)) {
defs = null;
}
else {
if(entityType.startsWith(TOSCA + ":")) {
entityType = entityType.substring(TOSCA.length()+1);
entireEntityType = prefix + entityType;
}
if(!entityType.startsWith(TOSCA)) {
entireEntityType = prefix + entityType;
}
if(TOSCA_DEF.get(entireEntityType) != null) {
defs = (LinkedHashMap<String,Object> )TOSCA_DEF.get(entireEntityType);
entityType = entireEntityType;
}
else if(customDef != null && customDef.get(entityType) != null) {
defs = (LinkedHashMap<String,Object> )customDef.get(entityType);
}
else{
defs = null;
ThreadLocalsHolder.getCollector().appendException(String.format(
"InvalidTypeError: \"%s\" is not a valid type",entityType));
}
}
type = entityType;
}
@SuppressWarnings("unchecked")
public ArrayList<PropertyDef> getPropertiesDefObjects() {
// Return a list of property definition objects
ArrayList<PropertyDef> properties = new ArrayList<PropertyDef>();
LinkedHashMap<String,Object> props = (LinkedHashMap<String,Object>)getDefinition(PROPERTIES);
if(props != null) {
for(Map.Entry<String,Object> me: props.entrySet()) {
String pdname = me.getKey();
Object to = me.getValue();
if(to == null || !(to instanceof LinkedHashMap)) {
String s = to == null ? "null" : to.getClass().getSimpleName();
ThreadLocalsHolder.getCollector().appendException(String.format(
"Unexpected type error: property \"%s\" has type \"%s\" (expected dict)",pdname,s));
continue;
}
LinkedHashMap<String,Object> pdschema = (LinkedHashMap<String,Object>)to;
properties.add(new PropertyDef(pdname,null,pdschema));
}
}
return properties;
}
public LinkedHashMap<String,PropertyDef> getPropertiesDef() {
LinkedHashMap<String,PropertyDef> pds = new LinkedHashMap<String,PropertyDef>();
for(PropertyDef pd: getPropertiesDefObjects()) {
pds.put(pd.getName(),pd);
}
return pds;
}
public PropertyDef getPropertyDefValue(String name) {
// Return the property definition associated with a given name
PropertyDef pd = null;
LinkedHashMap<String,PropertyDef> propsDef = getPropertiesDef();
if(propsDef != null) {
pd = propsDef.get(name);
}
return pd;
}
public ArrayList<AttributeDef> getAttributesDefObjects() {
// Return a list of attribute definition objects
@SuppressWarnings("unchecked")
LinkedHashMap<String,Object> attrs = (LinkedHashMap<String,Object>)getValue(ATTRIBUTES,null,true);
ArrayList<AttributeDef> ads = new ArrayList<>();
if(attrs != null) {
for(Map.Entry<String,Object> me: attrs.entrySet()) {
String attr = me.getKey();
@SuppressWarnings("unchecked")
LinkedHashMap<String,Object> adschema = (LinkedHashMap<String,Object>)me.getValue();
ads.add(new AttributeDef(attr,null,adschema));
}
}
return ads;
}
public LinkedHashMap<String,AttributeDef> getAttributesDef() {
// Return a dictionary of attribute definition name-object pairs
LinkedHashMap<String,AttributeDef> ads = new LinkedHashMap<>();
for(AttributeDef ado: getAttributesDefObjects()) {
ads.put(((AttributeDef)ado).getName(),ado);
}
return ads;
}
public AttributeDef getAttributeDefValue(String name) {
// Return the attribute definition associated with a given name
AttributeDef ad = null;
LinkedHashMap<String,AttributeDef> attrsDef = getAttributesDef();
if(attrsDef != null) {
ad = attrsDef.get(name);
}
return ad;
}
public String getType() {
return type;
}
}
/*python
from toscaparser.common.exception import InvalidTypeError
from toscaparser.elements.attribute_definition import AttributeDef
from toscaparser.elements.entity_type import EntityType
from toscaparser.elements.property_definition import PropertyDef
from toscaparser.unsupportedtype import UnsupportedType
class StatefulEntityType(EntityType):
'''Class representing TOSCA states.'''
interfaces_node_lifecycle_operations = ['create',
'configure', 'start',
'stop', 'delete']
interfaces_relationship_configure_operations = ['post_configure_source',
'post_configure_target',
'add_target',
'remove_target']
def __init__(self, entitytype, prefix, custom_def=None):
entire_entitytype = entitytype
if UnsupportedType.validate_type(entire_entitytype):
self.defs = None
else:
if entitytype.startswith(self.TOSCA + ":"):
entitytype = entitytype[(len(self.TOSCA) + 1):]
entire_entitytype = prefix + entitytype
if not entitytype.startswith(self.TOSCA):
entire_entitytype = prefix + entitytype
if entire_entitytype in list(self.TOSCA_DEF.keys()):
self.defs = self.TOSCA_DEF[entire_entitytype]
entitytype = entire_entitytype
elif custom_def and entitytype in list(custom_def.keys()):
self.defs = custom_def[entitytype]
else:
self.defs = None
ExceptionCollector.appendException(
InvalidTypeError(what=entitytype))
self.type = entitytype
def get_properties_def_objects(self):
'''Return a list of property definition objects.'''
properties = []
props = self.get_definition(self.PROPERTIES)
if props:
for prop, schema in props.items():
properties.append(PropertyDef(prop, None, schema))
return properties
def get_properties_def(self):
'''Return a dictionary of property definition name-object pairs.'''
return {prop.name: prop
for prop in self.get_properties_def_objects()}
def get_property_def_value(self, name):
'''Return the property definition associated with a given name.'''
props_def = self.get_properties_def()
if props_def and name in props_def.keys():
return props_def[name].value
def get_attributes_def_objects(self):
'''Return a list of attribute definition objects.'''
attrs = self.get_value(self.ATTRIBUTES, parent=True)
if attrs:
return [AttributeDef(attr, None, schema)
for attr, schema in attrs.items()]
return []
def get_attributes_def(self):
'''Return a dictionary of attribute definition name-object pairs.'''
return {attr.name: attr
for attr in self.get_attributes_def_objects()}
def get_attribute_def_value(self, name):
'''Return the attribute definition associated with a given name.'''
attrs_def = self.get_attributes_def()
if attrs_def and name in attrs_def.keys():
return attrs_def[name].value
*/
|
