2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
21 package org.openecomp.sdc.be.model.jsontitan.utils;
23 import java.util.ArrayList;
24 import java.util.HashMap;
25 import java.util.List;
27 import java.util.Map.Entry;
28 import java.util.Optional;
29 import java.util.function.BiConsumer;
30 import java.util.function.Function;
31 import java.util.stream.Collectors;
33 import org.apache.commons.collections.CollectionUtils;
34 import org.apache.commons.collections.MapUtils;
35 import org.apache.commons.lang3.StringUtils;
36 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
37 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
38 import org.openecomp.sdc.be.datatypes.elements.*;
39 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
40 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
41 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
42 import org.openecomp.sdc.be.model.AdditionalInformationDefinition;
43 import org.openecomp.sdc.be.model.ArtifactDefinition;
44 import org.openecomp.sdc.be.model.CapabilityDefinition;
45 import org.openecomp.sdc.be.model.Component;
46 import org.openecomp.sdc.be.model.ComponentInstance;
47 import org.openecomp.sdc.be.model.ComponentInstanceInput;
48 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
49 import org.openecomp.sdc.be.model.DistributionStatusEnum;
50 import org.openecomp.sdc.be.model.GroupDefinition;
51 import org.openecomp.sdc.be.model.GroupInstance;
52 import org.openecomp.sdc.be.model.InputDefinition;
53 import org.openecomp.sdc.be.model.InterfaceDefinition;
54 import org.openecomp.sdc.be.model.PropertyDefinition;
55 import org.openecomp.sdc.be.model.RelationshipImpl;
56 import org.openecomp.sdc.be.model.RequirementAndRelationshipPair;
57 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
58 import org.openecomp.sdc.be.model.RequirementDefinition;
59 import org.openecomp.sdc.be.model.Resource;
60 import org.openecomp.sdc.be.model.Service;
61 import org.openecomp.sdc.be.model.jsontitan.datamodel.NodeType;
62 import org.openecomp.sdc.be.model.jsontitan.datamodel.TopologyTemplate;
63 import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElement;
64 import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum;
65 import org.openecomp.sdc.be.model.jsontitan.enums.JsonConstantKeysEnum;
66 import org.openecomp.sdc.be.resources.data.ComponentMetadataData;
67 import org.openecomp.sdc.be.resources.data.ProductMetadataData;
68 import org.openecomp.sdc.be.resources.data.ResourceMetadataData;
69 import org.openecomp.sdc.be.resources.data.ServiceMetadataData;
70 import org.slf4j.Logger;
71 import org.slf4j.LoggerFactory;
73 public class ModelConverter {
74 public static final String CAP_PROP_DELIM = "#";
75 private static Logger log = LoggerFactory.getLogger(ModelConverter.class.getName());
77 @SuppressWarnings("unchecked")
78 public static <T extends ToscaElement> T convertToToscaElement(Component component) {
79 if (isAtomicComponent(component)) {
80 return (T) convertToNodeType(component);
82 return (T) convertToTopologyTemplate(component);
85 @SuppressWarnings("unchecked")
86 public static <T extends Component> T convertFromToscaElement(ToscaElement toscaElement) {
87 switch (toscaElement.getComponentType()) {
89 return (T) convertToResource(toscaElement);
92 return (T) convertToService(toscaElement);
98 public static boolean isAtomicComponent(Component component) {
99 ComponentTypeEnum componentType = component.getComponentType();
100 if (!componentType.equals(ComponentTypeEnum.RESOURCE)) {
103 Resource resource = (Resource) component;
104 ResourceTypeEnum resType = resource.getResourceType();
105 return isAtomicComponent(resType);
108 public static boolean isAtomicComponent(ResourceTypeEnum resourceType) {
109 if (resourceType == null || resourceType == ResourceTypeEnum.VF || resourceType == ResourceTypeEnum.PNF || resourceType == ResourceTypeEnum.CVFC)
114 // **********************************************************
115 public static VertexTypeEnum getVertexType(Component component) {
116 VertexTypeEnum vertexType;
117 if (isAtomicComponent(component)) {
118 vertexType = VertexTypeEnum.NODE_TYPE;
120 vertexType = VertexTypeEnum.TOPOLOGY_TEMPLATE;
125 public static VertexTypeEnum getVertexType(String resourceTypeName) {
126 VertexTypeEnum vertexType = null;
127 ResourceTypeEnum resourceType = ResourceTypeEnum.getTypeByName(resourceTypeName);
128 if (isAtomicComponent(resourceType)) {
129 vertexType = VertexTypeEnum.NODE_TYPE;
131 vertexType = VertexTypeEnum.TOPOLOGY_TEMPLATE;
138 private static Service convertToService(ToscaElement toscaElement) {
139 Service service = new Service();
140 convertComponentFields(service, toscaElement);
142 convertServiceSpecificFields(toscaElement, service);
144 TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement;
146 convertComponentInstances(topologyTemplate, service);
148 convertInputs(topologyTemplate, service);
150 convertRelations(topologyTemplate, service);
152 convertArtifacts(topologyTemplate, service);
154 convertServiceApiArtifacts(topologyTemplate, service);
159 private static void convertServiceSpecificFields(ToscaElement toscaElement, Service service) {
160 service.setProjectCode((String) toscaElement.getMetadataValue(JsonPresentationFields.PROJECT_CODE));
161 service.setDistributionStatus(DistributionStatusEnum.findState((String) toscaElement.getMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS)));
162 service.setEcompGeneratedNaming((Boolean) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.ECOMP_GENERATED_NAMING, true));
163 service.setNamingPolicy((String) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.NAMING_POLICY, StringUtils.EMPTY));
166 private static Resource convertToResource(ToscaElement toscaElement) {
167 Resource resource = new Resource();
168 convertComponentFields(resource, toscaElement);
170 resource.setResourceType(toscaElement.getResourceType());
171 if (toscaElement.getToscaType() == ToscaElementTypeEnum.NodeType) {
172 NodeType nodeType = (NodeType) toscaElement;
173 resource.setDerivedFrom(nodeType.getDerivedFrom());
174 resource.setDerivedList(nodeType.getDerivedList());
175 resource.setAbstract((Boolean) nodeType.getMetadataValue(JsonPresentationFields.IS_ABSTRACT));
176 convertAttributes(nodeType, resource);
177 convertCapabilities(nodeType, resource);
178 convertRequirements(nodeType, resource);
179 convertInterfaces(nodeType, resource);
182 TopologyTemplate topologyTemplate = (TopologyTemplate) toscaElement;
183 if (resource.getResourceType() == ResourceTypeEnum.VF) {
184 resource.setCsarUUID((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_UUID));
185 resource.setCsarVersion((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_VERSION));
186 resource.setImportedToscaChecksum((String) topologyTemplate.getMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM));
189 convertComponentInstances(topologyTemplate, resource);
190 convertRelations(topologyTemplate, resource);
191 convertInputs(topologyTemplate, resource);
192 convertGroups(topologyTemplate, resource);
194 convertArtifacts(toscaElement, resource);
195 convertAdditionalInformation(toscaElement, resource);
200 private static void convertAttributes(NodeType nodeType, Resource resource) {
201 Map<String, PropertyDataDefinition> attributes = nodeType.getAttributes();
202 if (attributes != null) {
203 List<PropertyDefinition> attrs = attributes.values().stream().map(dataDef -> ModelConverter.fromDataDefinition(resource.getUniqueId(), dataDef)).collect(Collectors.toList());
204 resource.setAttributes(attrs);
208 private static PropertyDefinition fromDataDefinition(String resourceId, PropertyDataDefinition dataDefinition) {
209 PropertyDefinition attributeDefinition = new PropertyDefinition(dataDefinition);
210 attributeDefinition.setParentUniqueId(resourceId);
211 return attributeDefinition;
214 private static void convertInterfaces(NodeType nodeType, Resource resource) {
215 Map<String, InterfaceDataDefinition> interfaceArtifacts = nodeType.getInterfaceArtifacts();
216 if (interfaceArtifacts != null) {
217 Map<String, InterfaceDefinition> interfaces = interfaceArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new InterfaceDefinition(en.getValue())));
218 resource.setInterfaces(interfaces);
223 * Converts component instances of topology template to component instances of resource
225 * @param topologyTemplate
228 public static void convertComponentInstances(TopologyTemplate topologyTemplate, Component component) {
230 if (MapUtils.isNotEmpty(topologyTemplate.getComponentInstances())) {
232 setComponentInstancesAttributesToComponent(topologyTemplate, component);
234 setComponentInstancesPropertiesToComponent(topologyTemplate, component);
236 setComponentInstancesInputsToComponent(topologyTemplate, component);
238 setComponentInstancesToComponent(topologyTemplate, component);
240 setComponentInstancesCapabilitiesToComponentAndCI(topologyTemplate, component);
242 setComponentInstancesRequirementsToComponent(topologyTemplate, component);
244 setComponentInstancesArtifactsToComponent(topologyTemplate, component);
249 private static void setComponentInstancesArtifactsToComponent(TopologyTemplate topologyTemplate, Component component) {
250 Map<String, MapArtifactDataDefinition> instDeploymentArtifacts = topologyTemplate.getInstDeploymentArtifacts();
251 Map<String, MapArtifactDataDefinition> instanceArtifacts = topologyTemplate.getInstanceArtifacts();
253 List<ComponentInstance> instances = component.getComponentInstances();
254 if (instDeploymentArtifacts != null && instances != null) {
255 instDeploymentArtifacts.entrySet().forEach(e -> {
256 Optional<ComponentInstance> ci = instances.stream().filter(i -> i.getUniqueId().equals(e.getKey())).findFirst();
257 if (ci.isPresent()) {
258 Map<String, ArtifactDataDefinition> mapToscaDataDefinition = e.getValue().getMapToscaDataDefinition();
259 Map<String, ArtifactDefinition> deplArt = mapToscaDataDefinition.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue())));
261 ci.get().setDeploymentArtifacts(deplArt);
265 if (instanceArtifacts != null && instances != null) {
266 instanceArtifacts.entrySet().forEach(e -> {
267 Optional<ComponentInstance> ci = instances.stream().filter(i -> i.getUniqueId().equals(e.getKey())).findFirst();
268 if (ci.isPresent()) {
269 Map<String, ArtifactDataDefinition> mapToscaDataDefinition = e.getValue().getMapToscaDataDefinition();
270 Map<String, ArtifactDefinition> deplArt = mapToscaDataDefinition.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, en -> new ArtifactDefinition(en.getValue())));
272 ci.get().setArtifacts(deplArt);
279 public static void convertComponentInstances(Component component, TopologyTemplate topologyTemplate) {
281 if (!CollectionUtils.isEmpty(component.getComponentInstances())) {
283 setComponentInstancesAttributesToTopologyTemplate(component, topologyTemplate);
285 setComponentInstancesPropertiesToTopologyTemplate(component, topologyTemplate);
287 setComponentInstancesInputsToTopologyTemplate(component, topologyTemplate);
289 setComponentInstancesToTopologyTemplate(component, topologyTemplate);
291 setComponentInstancesArtifactsToTopologyTemplate(component, topologyTemplate);
295 public static void convertRelations(TopologyTemplate topologyTemplate, Component component) {
296 Map<String, RelationshipInstDataDefinition> relations = topologyTemplate.getRelations();
297 List<RequirementCapabilityRelDef> componentRelations;
298 if (relations != null && !relations.isEmpty()) {
299 componentRelations = relations.values().stream().map(ModelConverter::convertRelation).collect(Collectors.toList());
302 componentRelations = new ArrayList<>();
304 component.setComponentInstancesRelations(componentRelations);
308 public static RequirementCapabilityRelDef convertRelation(RelationshipInstDataDefinition relation) {
309 RequirementCapabilityRelDef requirementCapabilityRelDef = new RequirementCapabilityRelDef();
310 requirementCapabilityRelDef.setFromNode(relation.getFromId());
311 requirementCapabilityRelDef.setToNode(relation.getToId());
312 List<RequirementAndRelationshipPair> relationships = new ArrayList<>();
313 RequirementAndRelationshipPair relationshipPair = new RequirementAndRelationshipPair();
314 relationshipPair.setId(relation.getUniqueId());
316 relationshipPair.setCapabilityOwnerId(relation.getCapabilityOwnerId());
317 relationshipPair.setCapabilityUid(relation.getCapabilityId());
318 relationshipPair.setCapability(relation.getCapability());
319 relationshipPair.setRequirementOwnerId(relation.getRequirementOwnerId());
320 relationshipPair.setRequirementUid(relation.getRequirementId());
321 relationshipPair.setRequirement(relation.getRequirement());
322 RelationshipImpl relationship = new RelationshipImpl();
323 relationship.setType(relation.getType());
324 relationshipPair.setRelationships(relationship);
326 relationships.add(relationshipPair);
327 requirementCapabilityRelDef.setRelationships(relationships);
328 return requirementCapabilityRelDef;
331 public static List<RelationshipInstDataDefinition> convertRelationToToscaRelation(RequirementCapabilityRelDef relation) {
333 List<RelationshipInstDataDefinition> relationsList = new ArrayList<>();
335 List<RequirementAndRelationshipPair> relationship = relation.getRelationships();
336 relationship.forEach(p -> {
337 RelationshipInstDataDefinition requirementCapabilityRelDef = new RelationshipInstDataDefinition();
338 requirementCapabilityRelDef.setFromId(relation.getFromNode());
339 requirementCapabilityRelDef.setToId(relation.getToNode());
340 requirementCapabilityRelDef.setUniqueId(p.getId());
341 requirementCapabilityRelDef.setCapabilityOwnerId(p.getCapabilityOwnerId());
342 requirementCapabilityRelDef.setCapabilityId(p.getCapabilityUid());
343 requirementCapabilityRelDef.setRequirementOwnerId(p.getRequirementOwnerId());
344 requirementCapabilityRelDef.setRequirementId(p.getRequirementUid());
345 requirementCapabilityRelDef.setRequirement(p.getRequirement());
346 requirementCapabilityRelDef.setType(p.getRelationship().getType());
347 requirementCapabilityRelDef.setCapability(p.getCapability());
349 relationsList.add(requirementCapabilityRelDef);
352 return relationsList;
355 private static void convertCapabilities(Component component, TopologyTemplate topologyTemplate) {
357 if (component.getCapabilities() != null && component.getComponentInstances() != null) {
358 topologyTemplate.setCalculatedCapabilities(new HashMap<>());
359 topologyTemplate.setCalculatedCapabilitiesProperties(new HashMap<>());
360 for (ComponentInstance instance : component.getComponentInstances()) {
361 Map<String, List<CapabilityDefinition>> instCapabilities = instance.getCapabilities();
362 if (MapUtils.isNotEmpty(instCapabilities)) {
363 if (topologyTemplate.getCalculatedCapabilities() == null) {
364 topologyTemplate.setCalculatedCapabilities(new HashMap<>());
366 topologyTemplate.getCalculatedCapabilities().put(instance.getUniqueId(), convertToMapListCapabiltyDataDefinition(instCapabilities));
367 if (topologyTemplate.getCalculatedCapabilitiesProperties() == null) {
368 topologyTemplate.setCalculatedCapabilitiesProperties(new HashMap<>());
370 topologyTemplate.getCalculatedCapabilitiesProperties().put(instance.getUniqueId(), convertToMapOfMapCapabiltyProperties(instCapabilities, instance.getUniqueId()));
376 public static MapCapabiltyProperty convertToMapOfMapCapabiltyProperties(Map<String, List<CapabilityDefinition>> instCapabilities, String instanceId) {
377 return convertToMapOfMapCapabiltyProperties(instCapabilities, instanceId, false);
380 public static MapCapabiltyProperty convertToMapOfMapCapabiltyProperties(Map<String, List<CapabilityDefinition>> instCapabilities, String instanceId, boolean fromCsar) {
382 Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
384 instCapabilities.forEach(new BiConsumer<String, List<CapabilityDefinition>>() {
386 public void accept(String s, List<CapabilityDefinition> caps) {
388 if (caps != null && !caps.isEmpty()) {
390 MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition();
392 for (CapabilityDefinition cap : caps) {
393 List<ComponentInstanceProperty> capPrps = cap.getProperties();
394 if (capPrps != null) {
396 for (ComponentInstanceProperty cip : capPrps) {
397 dataToCreate.put(cip.getName(), new PropertyDataDefinition(cip));
399 // format key of capability properties :
400 // VF instance in service : instanceId#ownerId#type#capName
401 // VFC instance ion VF : instanceId#ownerId#type#capName -> instanceId=ownerId
403 StringBuffer sb = new StringBuffer(instanceId);
404 sb.append(CAP_PROP_DELIM);
406 sb.append(instanceId);
408 sb.append(cap.getOwnerId());
410 sb.append(CAP_PROP_DELIM).append(s).append(CAP_PROP_DELIM).append(cap.getName());
411 toscaCapPropMap.put(sb.toString(), dataToCreate);
419 return new MapCapabiltyProperty(toscaCapPropMap);
422 private static MapListCapabiltyDataDefinition convertToMapListCapabiltyDataDefinition(Map<String, List<CapabilityDefinition>> instCapabilities) {
424 Map<String, ListCapabilityDataDefinition> mapToscaDataDefinition = new HashMap<>();
425 for (Entry<String, List<CapabilityDefinition>> instCapability : instCapabilities.entrySet()) {
426 mapToscaDataDefinition.put(instCapability.getKey(), new ListCapabilityDataDefinition(instCapability.getValue().stream().map(iCap -> new CapabilityDataDefinition(iCap)).collect(Collectors.toList())));
429 return new MapListCapabiltyDataDefinition(mapToscaDataDefinition);
432 private static void convertRequirements(Component component, TopologyTemplate topologyTemplate) {
434 if (component.getRequirements() != null && component.getComponentInstances() != null) {
435 topologyTemplate.setCalculatedRequirements(new HashMap<>());
436 for (ComponentInstance instance : component.getComponentInstances()) {
437 Map<String, List<RequirementDefinition>> instRequirements = instance.getRequirements();
438 if (MapUtils.isNotEmpty(instRequirements)) {
439 if (topologyTemplate.getCalculatedRequirements() == null) {
440 topologyTemplate.setCalculatedRequirements(new HashMap<>());
442 topologyTemplate.getCalculatedRequirements().put(instance.getUniqueId(), convertToMapListRequirementDataDefinition(instRequirements));
448 private static MapListRequirementDataDefinition convertToMapListRequirementDataDefinition(Map<String, List<RequirementDefinition>> instRequirements) {
450 Map<String, ListRequirementDataDefinition> mapToscaDataDefinition = new HashMap<>();
451 for (Entry<String, List<RequirementDefinition>> instRequirement : instRequirements.entrySet()) {
452 mapToscaDataDefinition.put(instRequirement.getKey(), new ListRequirementDataDefinition(instRequirement.getValue().stream().map(iCap -> new RequirementDataDefinition(iCap)).collect(Collectors.toList())));
455 return new MapListRequirementDataDefinition(mapToscaDataDefinition);
458 private static void convertRequirements(TopologyTemplate toscaElement, Component component) {
460 if (CollectionUtils.isNotEmpty(component.getComponentInstances())) {
461 for (ComponentInstance instance : component.getComponentInstances()) {
462 Map<String, List<RequirementDefinition>> instanceRequirements = instance.getRequirements();
463 if (MapUtils.isNotEmpty(instanceRequirements)) {
464 addRequirementsByInstanceId(instance.getUniqueId(), instanceRequirements, component);
470 private static void addRequirementsByInstanceId(String instanceId, Map<String, List<RequirementDefinition>> instanceRequirementsMap, Component component) {
472 if (component.getCapabilities() == null) {
473 component.setCapabilities(new HashMap<>());
475 List<RequirementDefinition> instanceRequirements = new ArrayList<>();
476 for (List<RequirementDefinition> instRequirements : instanceRequirementsMap.values()) {
477 instanceRequirements.addAll(instRequirements);
479 component.getRequirements().put(instanceId, instanceRequirements);
482 private static void convertCapabilities(TopologyTemplate toscaElement, Component component) {
484 if (CollectionUtils.isNotEmpty(component.getComponentInstances())) {
485 for (ComponentInstance instance : component.getComponentInstances()) {
486 Map<String, List<CapabilityDefinition>> instanceCapabilities = instance.getCapabilities();
487 if (MapUtils.isNotEmpty(instanceCapabilities)) {
488 addCapabilitiesByInstanceId(instance.getUniqueId(), instanceCapabilities, component);
494 private static void addCapabilitiesByInstanceId(String instanceId, Map<String, List<CapabilityDefinition>> instanceCapabilitiesMap, Component component) {
496 if (component.getCapabilities() == null) {
497 component.setCapabilities(new HashMap<>());
499 List<CapabilityDefinition> instanceCapabilities = new ArrayList<>();
500 for (List<CapabilityDefinition> instCapabilitis : instanceCapabilitiesMap.values()) {
501 instanceCapabilities.addAll(instCapabilitis);
503 component.getCapabilities().put(instanceId, instanceCapabilities);
506 @SuppressWarnings("unchecked")
507 private static void convertComponentFields(Component component, ToscaElement toscaElement) {
508 component.setName(toscaElement.getName());
509 component.setAllVersions(toscaElement.getAllVersions());
510 component.setCategories(toscaElement.getCategories());
511 component.setComponentType(toscaElement.getComponentType());
512 component.setCreationDate(toscaElement.getCreationDate());
513 component.setCreatorUserId(toscaElement.getCreatorUserId());
514 component.setCreatorFullName(toscaElement.getCreatorFullName());
515 component.setLastUpdateDate(toscaElement.getLastUpdateDate());
516 component.setLastUpdaterFullName(toscaElement.getLastUpdaterFullName());
517 component.setLastUpdaterUserId(toscaElement.getLastUpdaterUserId());
518 component.setNormalizedName(toscaElement.getNormalizedName());
520 component.setLifecycleState(toscaElement.getLifecycleState());
521 component.setVersion(toscaElement.getVersion());
522 component.setHighestVersion(toscaElement.isHighestVersion());
523 component.setUniqueId(toscaElement.getUniqueId());
524 component.setSystemName((String) toscaElement.getMetadataValue(JsonPresentationFields.SYSTEM_NAME));
525 component.setDerivedFromGenericType(toscaElement.getDerivedFromGenericType());
526 component.setDerivedFromGenericVersion(toscaElement.getDerivedFromGenericVersion());
528 if (component.getComponentType() == ComponentTypeEnum.RESOURCE) {
529 Resource resource = (Resource) component;
530 resource.setAbstract((Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_ABSTRACT));
531 resource.setToscaResourceName((String) toscaElement.getMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME));
532 resource.setVendorName((String) toscaElement.getMetadataValue(JsonPresentationFields.VENDOR_NAME));
533 resource.setVendorRelease((String) toscaElement.getMetadataValue(JsonPresentationFields.VENDOR_RELEASE));
534 // field isn't mandatory , but shouldn't be null(should be an empty string instead)
535 if (((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER)) != null){
536 resource.setResourceVendorModelNumber(((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER)));
538 resource.setResourceVendorModelNumber("");
540 } else if (component.getComponentType() == ComponentTypeEnum.SERVICE) {
541 Service service = (Service) component;
542 if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE)) != null){
543 service.setServiceType(((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE)));
545 service.setServiceType("");
547 if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE)) != null){
548 service.setServiceRole(((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE)));
550 service.setServiceRole("");
553 component.setConformanceLevel((String) toscaElement.getMetadataValue(JsonPresentationFields.CONFORMANCE_LEVEL));
554 component.setIcon((String) toscaElement.getMetadataValue(JsonPresentationFields.ICON));
555 component.setDescription((String) toscaElement.getMetadataValue(JsonPresentationFields.DESCRIPTION));
556 component.setTags((List<String>) toscaElement.getMetadataValue(JsonPresentationFields.TAGS));
557 component.setInvariantUUID((String) toscaElement.getMetadataValue(JsonPresentationFields.INVARIANT_UUID));
558 component.setContactId((String) toscaElement.getMetadataValue(JsonPresentationFields.CONTACT_ID));
559 component.setUUID((String) toscaElement.getMetadataValue(JsonPresentationFields.UUID));
560 component.setIsDeleted((Boolean) toscaElement.getMetadataValue(JsonPresentationFields.IS_DELETED));
562 Map<String, PropertyDataDefinition> properties = toscaElement.getProperties();
563 if (properties != null && !properties.isEmpty()) {
564 List<PropertyDefinition> propertiesMap = properties.values().stream().map(x -> new PropertyDefinition(x)).collect(Collectors.toList());
565 ((Resource) component).setProperties(propertiesMap);
568 component.setToscaType(toscaElement.getToscaType().getValue());
571 private static NodeType convertToNodeType(Component component) {
572 Resource resource = (Resource) component;
573 NodeType nodeType = new NodeType();
574 nodeType.setDerivedFrom(resource.getDerivedFrom());
575 nodeType.setDerivedList(resource.getDerivedList());
576 nodeType.setResourceType(resource.getResourceType());
577 // nodeType.setCapabiltiesProperties(capabiltiesProperties);
578 convertCommonToscaData(component, nodeType);
579 convertAdditionalInformation(component, nodeType);
580 convertArtifacts(resource, nodeType);
581 convertCapabilities(resource, nodeType);
582 convertRequirements(resource, nodeType);
583 convertAttributes(resource, nodeType);
584 convertProperties(resource, nodeType);
585 convertInterfaces(resource, nodeType);
589 private static void convertProperties(Resource resource, NodeType nodeType) {
590 List<PropertyDefinition> properties = resource.getProperties();
591 if (properties != null && !properties.isEmpty()) {
592 Map<String, PropertyDataDefinition> propertiesMap = properties.stream().collect(Collectors.toMap(x -> x.getName(), x -> new PropertyDataDefinition(x)));
593 nodeType.setProperties(propertiesMap);
597 private static void convertInterfaces(Resource resource, NodeType nodeType) {
598 Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
599 if (interfaces != null) {
600 Map<String, InterfaceDataDefinition> interfaceArtifacts = interfaces.entrySet().stream().collect(Collectors.toMap(x -> x.getKey(), x -> new InterfaceDataDefinition(x.getValue())));
601 nodeType.setInterfaceArtifacts(interfaceArtifacts);
605 private static void convertAdditionalInformation(Component component, ToscaElement toscaElement) {
606 List<AdditionalInformationDefinition> additionalInformation = component.getAdditionalInformation();
607 if (additionalInformation != null) {
608 Map<String, AdditionalInfoParameterDataDefinition> addInfo = additionalInformation.stream().collect(Collectors.toMap(x -> x.getUniqueId(), x -> new AdditionalInfoParameterDataDefinition(x)));
609 toscaElement.setAdditionalInformation(addInfo);
613 private static void convertAdditionalInformation(ToscaElement toscaElement, Component resource) {
614 Map<String, AdditionalInfoParameterDataDefinition> additionalInformation = toscaElement.getAdditionalInformation();
615 if (additionalInformation != null) {
616 List<AdditionalInformationDefinition> addInfo = additionalInformation.values().stream().map(e -> {
617 return new AdditionalInformationDefinition(e);
618 }).collect(Collectors.toList());
619 resource.setAdditionalInformation(addInfo);
623 private static void convertArtifacts(ToscaElement toscaElement, Component component) {
624 Map<String, ArtifactDataDefinition> artifacts = toscaElement.getArtifacts();
625 Map<String, ArtifactDefinition> copy;
626 if (artifacts != null) {
627 copy = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
630 copy = new HashMap<>();
632 component.setArtifacts(copy);
634 Map<String, ArtifactDataDefinition> toscaArtifacts = toscaElement.getToscaArtifacts();
635 if (toscaArtifacts != null) {
636 copy = toscaArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
639 copy = new HashMap<>();
641 component.setToscaArtifacts(copy);
643 Map<String, ArtifactDataDefinition> deploymentArtifacts = toscaElement.getDeploymentArtifacts();
644 if (deploymentArtifacts != null) {
645 copy = deploymentArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
648 copy = new HashMap<>();
650 component.setDeploymentArtifacts(copy);
653 private static void convertServiceApiArtifacts(TopologyTemplate topologyTemplate, Service service) {
654 Map<String, ArtifactDataDefinition> serviceApiArtifacts = topologyTemplate.getServiceApiArtifacts();
655 Map<String, ArtifactDefinition> copy;
656 if (serviceApiArtifacts != null) {
657 copy = serviceApiArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDefinition(e.getValue())));
660 copy = new HashMap<>();
662 service.setServiceApiArtifacts(copy);
665 private static void convertArtifacts(Component component, ToscaElement toscaElement) {
666 Map<String, ArtifactDefinition> artifacts = component.getArtifacts();
667 if (artifacts != null) {
668 Map<String, ArtifactDataDefinition> copy = artifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
669 toscaElement.setArtifacts(copy);
672 Map<String, ArtifactDefinition> toscaArtifacts = component.getToscaArtifacts();
673 if (toscaArtifacts != null) {
674 Map<String, ArtifactDataDefinition> copy = toscaArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
675 toscaElement.setToscaArtifacts(copy);
678 Map<String, ArtifactDefinition> deploymentArtifacts = component.getDeploymentArtifacts();
679 if (deploymentArtifacts != null) {
680 Map<String, ArtifactDataDefinition> copy = deploymentArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
681 toscaElement.setDeploymentArtifacts(copy);
685 private static void convertServiceApiArtifacts(Service service, TopologyTemplate topologyTemplate) {
686 Map<String, ArtifactDefinition> serviceApiArtifacts = service.getServiceApiArtifacts();
687 if (serviceApiArtifacts != null) {
688 Map<String, ArtifactDataDefinition> copy = serviceApiArtifacts.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ArtifactDataDefinition(e.getValue())));
689 topologyTemplate.setServiceApiArtifacts(copy);
693 private static void convertCapabilities(Component component, NodeType toscaElement) {
694 Map<String, List<CapabilityDefinition>> capabilities = component.getCapabilities();
696 Map<String, ListCapabilityDataDefinition> toscaCapMap = new HashMap<>();
697 Map<String, MapPropertiesDataDefinition> toscaCapPropMap = new HashMap<>();
699 if (capabilities != null && !capabilities.isEmpty()) {
700 capabilities.forEach(new BiConsumer<String, List<CapabilityDefinition>>() {
702 public void accept(String s, List<CapabilityDefinition> caps) {
704 if (caps != null && !caps.isEmpty()) {
705 List<CapabilityDataDefinition> capList = caps.stream().map(o -> {
706 return new CapabilityDataDefinition(o);
707 }).collect(Collectors.toList());
709 ListCapabilityDataDefinition listCapabilityDataDefinition = new ListCapabilityDataDefinition(capList);
710 toscaCapMap.put(s, listCapabilityDataDefinition);
712 for (CapabilityDefinition cap : caps) {
713 List<ComponentInstanceProperty> capPrps = cap.getProperties();
714 if (capPrps != null && !capPrps.isEmpty()) {
716 MapPropertiesDataDefinition dataToCreate = new MapPropertiesDataDefinition();
717 for (ComponentInstanceProperty cip : capPrps) {
718 dataToCreate.put(cip.getName(), new PropertyDataDefinition(cip));
721 toscaCapPropMap.put(s + CAP_PROP_DELIM + cap.getName(), dataToCreate);
730 toscaElement.setCapabilties(toscaCapMap);
731 toscaElement.setCapabiltiesProperties(toscaCapPropMap);
735 private static void convertAttributes(Resource component, NodeType nodeType) {
736 List<PropertyDefinition> attributes = component.getAttributes();
737 if (attributes != null) {
738 Map<String, PropertyDataDefinition> attrsByName = attributes.stream().map(PropertyDataDefinition::new).collect(Collectors.toMap(PropertyDataDefinition::getName, Function.identity()));
739 nodeType.setAttributes(attrsByName);
743 private static void convertRequirements(Resource component, NodeType nodeType) {
744 Map<String, List<RequirementDefinition>> requirements = component.getRequirements();
746 Map<String, ListRequirementDataDefinition> toscaReqMap = new HashMap<>();
748 if (requirements != null && !requirements.isEmpty()) {
749 requirements.forEach(new BiConsumer<String, List<RequirementDefinition>>() {
751 public void accept(String s, List<RequirementDefinition> reqs) {
753 if (reqs != null && !reqs.isEmpty()) {
754 List<RequirementDataDefinition> reqList = reqs.stream().map(o -> {
755 return new RequirementDataDefinition(o);
756 }).collect(Collectors.toList());
758 ListRequirementDataDefinition listRequirementDataDefinition = new ListRequirementDataDefinition(reqList);
759 toscaReqMap.put(s, listRequirementDataDefinition);
763 nodeType.setRequirements(toscaReqMap);
767 private static void convertCapabilities(NodeType toscaElement, Component component) {
768 Map<String, ListCapabilityDataDefinition> toscaCapabilities = toscaElement.getCapabilties();
769 Map<String, MapPropertiesDataDefinition> toscaCapPropMap = toscaElement.getCapabiltiesProperties();
771 Map<String, List<CapabilityDefinition>> compCap = new HashMap<>();
772 if (toscaCapabilities == null || toscaCapabilities.isEmpty())
774 toscaCapabilities.forEach(new BiConsumer<String, ListCapabilityDataDefinition>() {
776 public void accept(String s, ListCapabilityDataDefinition cap) {
779 List<CapabilityDataDefinition> capDataList = cap.getListToscaDataDefinition();
781 if (capDataList != null && !capDataList.isEmpty()) {
782 List<CapabilityDefinition> capList = capDataList.stream().map(o -> {
784 return new CapabilityDefinition(o);
785 }).collect(Collectors.toList());
786 compCap.put(s, capList);
792 if (toscaCapPropMap != null && !toscaCapPropMap.isEmpty()) {
793 toscaCapPropMap.forEach(new BiConsumer<String, MapPropertiesDataDefinition>() {
795 public void accept(String s, MapPropertiesDataDefinition capProp) {
796 String[] result = s.split(CAP_PROP_DELIM);
797 if (capProp != null) {
798 Map<String, PropertyDataDefinition> capMap = capProp.getMapToscaDataDefinition();
800 if (capMap != null && !capMap.isEmpty()) {
801 // List<PropertyDataDefinition> list = map.values().stream().collect(Collectors.toList());
802 List<ComponentInstanceProperty> capPropsList = capMap.values().stream().map(o -> {
804 return new ComponentInstanceProperty(o);
805 }).collect(Collectors.toList());
807 List<CapabilityDefinition> cap = compCap.get(result[0]);
808 Optional<CapabilityDefinition> op = cap.stream().filter(c -> c.getName().equals(result[1])).findFirst();
809 if (op.isPresent()) {
810 op.get().setProperties(capPropsList);
820 component.setCapabilities(compCap);
824 private static void convertGroups(TopologyTemplate toscaElement, Component component) {
825 Map<String, GroupDataDefinition> toscaGroups = toscaElement.getGroups();
826 List<GroupDefinition> groupDefinitions = null;
827 if (MapUtils.isNotEmpty(toscaGroups)) {
828 groupDefinitions = toscaGroups.values().stream().map(g -> new GroupDefinition(g)).collect(Collectors.toList());
830 component.setGroups(groupDefinitions);
833 private static void convertGroups(Component component, TopologyTemplate toscaElement) {
834 List<GroupDefinition> groupDefinitions = component.getGroups();
835 Map<String, GroupDataDefinition> groups = new HashMap<>();
837 if (groupDefinitions != null && groups.isEmpty()) {
838 groups = groupDefinitions.stream().collect((Collectors.toMap(pr -> pr.getName(), pr -> new GroupDataDefinition(pr))));
840 toscaElement.setGroups(groups);
844 private static void convertRequirements(NodeType toscaElement, Component component) {
845 Map<String, ListRequirementDataDefinition> toscaRequirements = toscaElement.getRequirements();
847 Map<String, List<RequirementDefinition>> compReqs = new HashMap<>();
848 if (toscaRequirements == null || toscaRequirements.isEmpty())
850 toscaRequirements.forEach(new BiConsumer<String, ListRequirementDataDefinition>() {
852 public void accept(String s, ListRequirementDataDefinition req) {
855 List<RequirementDataDefinition> reqDataList = req.getListToscaDataDefinition();
857 if (reqDataList != null && !reqDataList.isEmpty()) {
858 List<RequirementDefinition> reqList = reqDataList.stream().map(o -> {
860 return new RequirementDefinition(o);
861 }).collect(Collectors.toList());
862 compReqs.put(s, reqList);
867 component.setRequirements(compReqs);
870 private static TopologyTemplate convertToTopologyTemplate(Component component) {
871 TopologyTemplate topologyTemplate;
872 ComponentTypeEnum componentType = component.getComponentType();
873 topologyTemplate = new TopologyTemplate();
875 if (componentType == ComponentTypeEnum.RESOURCE) {
876 Resource resource = (Resource) component;
877 topologyTemplate.setResourceType(resource.getResourceType());
878 topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_UUID, resource.getCsarUUID());
879 topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_VERSION, resource.getCsarVersion());
880 topologyTemplate.setMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM, resource.getImportedToscaChecksum());
882 if (componentType == ComponentTypeEnum.SERVICE) {
883 convertServiceSpecificEntities((Service) component, topologyTemplate);
885 convertCommonToscaData(component, topologyTemplate);
886 convertArtifacts(component, topologyTemplate);
888 convertAdditionalInformation(component, topologyTemplate);
889 convertComponentInstances(component, topologyTemplate);
891 convertInputs(component, topologyTemplate);
892 convertCapabilities(component, topologyTemplate);
893 convertGroups(component, topologyTemplate);
894 convertRequirements(component, topologyTemplate);
895 convertRelationsToComposition(component, topologyTemplate);
897 return topologyTemplate;
900 private static void convertServiceSpecificEntities(Service service, TopologyTemplate topologyTemplate) {
901 convertServiceMetaData(service, topologyTemplate);
902 convertServiceApiArtifacts(service, topologyTemplate);
905 private static void convertServiceMetaData(Service service, TopologyTemplate topologyTemplate) {
906 if (service.getDistributionStatus() != null) {
907 topologyTemplate.setMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS, service.getDistributionStatus().name());
909 topologyTemplate.setMetadataValue(JsonPresentationFields.PROJECT_CODE, service.getProjectCode());
910 topologyTemplate.setMetadataValue(JsonPresentationFields.ECOMP_GENERATED_NAMING, service.isEcompGeneratedNaming());
911 topologyTemplate.setMetadataValue(JsonPresentationFields.NAMING_POLICY, service.getNamingPolicy());
915 private static void convertRelationsToComposition(Component component, TopologyTemplate topologyTemplate) {
916 List<RequirementCapabilityRelDef> componentInstancesRelations = component.getComponentInstancesRelations();
917 if (componentInstancesRelations != null) {
918 Map<String, CompositionDataDefinition> compositions = topologyTemplate.getCompositions();
919 if (compositions == null) {
920 compositions = new HashMap<>();
922 CompositionDataDefinition compositionDataDefinition = compositions.get(JsonConstantKeysEnum.COMPOSITION.getValue());
923 if (compositionDataDefinition == null) {
924 compositionDataDefinition = new CompositionDataDefinition();
925 compositions.put(JsonConstantKeysEnum.COMPOSITION.getValue(), compositionDataDefinition);
928 Map<String, RelationshipInstDataDefinition> relations = componentInstancesRelations.stream().flatMap(x -> convertRelationToToscaRelation(x).stream()).filter(i -> i.getUniqueId() != null)
929 .collect(Collectors.toMap(i -> i.getUniqueId(), i -> i));
930 compositionDataDefinition.setRelations(relations);
934 private static void convertInputs(Component component, TopologyTemplate topologyTemplate) {
935 List<InputDefinition> inputsList = component.getInputs();
936 if (inputsList != null && !inputsList.isEmpty()) {
938 Map<String, PropertyDataDefinition> inputsMap = inputsList.stream().map(i -> new PropertyDataDefinition(i)).collect(Collectors.toMap(i -> i.getName(), i -> i));
939 topologyTemplate.setInputs(inputsMap);
944 private static void convertInputs(TopologyTemplate topologyTemplate, Component component) {
945 Map<String, PropertyDataDefinition> inputsMap = topologyTemplate.getInputs();
946 if (inputsMap != null && !inputsMap.isEmpty()) {
947 List<InputDefinition> inputsList = inputsMap.values().stream().map(i -> new InputDefinition(i)).collect(Collectors.toList());
948 component.setInputs(inputsList);
953 private static void convertCommonToscaData(Component component, ToscaElement toscaElement) {
954 toscaElement.setUUID(component.getUUID());
955 toscaElement.setUniqueId(component.getUniqueId());
956 toscaElement.setSystemName(component.getSystemName());
957 toscaElement.setLifecycleState(component.getLifecycleState());
958 toscaElement.setComponentType(component.getComponentType());
959 toscaElement.setNormalizedName(component.getNormalizedName());
960 toscaElement.setMetadataValue(JsonPresentationFields.NAME, component.getName());
961 toscaElement.setCategories(component.getCategories());
962 toscaElement.setCreatorUserId(component.getCreatorUserId());
963 toscaElement.setCreationDate(component.getCreationDate());
964 toscaElement.setCreatorFullName(component.getCreatorFullName());
965 toscaElement.setHighestVersion(component.isHighestVersion());
966 toscaElement.setLastUpdateDate(component.getLastUpdateDate());
967 toscaElement.setLastUpdaterFullName(component.getLastUpdaterFullName());
968 toscaElement.setLastUpdaterUserId(component.getLastUpdaterUserId());
969 toscaElement.setDerivedFromGenericType(component.getDerivedFromGenericType());
970 toscaElement.setDerivedFromGenericVersion(component.getDerivedFromGenericVersion());
972 toscaElement.setLifecycleState(component.getLifecycleState());
973 toscaElement.setMetadataValue(JsonPresentationFields.VERSION, component.getVersion());
974 if (component.getComponentType() == ComponentTypeEnum.RESOURCE) {
975 toscaElement.setMetadataValue(JsonPresentationFields.IS_ABSTRACT, ((Resource) component).isAbstract());
976 toscaElement.setMetadataValue(JsonPresentationFields.TOSCA_RESOURCE_NAME, ((Resource) component).getToscaResourceName());
977 toscaElement.setMetadataValue(JsonPresentationFields.VENDOR_NAME, ((Resource) component).getVendorName());
978 toscaElement.setMetadataValue(JsonPresentationFields.VENDOR_RELEASE, ((Resource) component).getVendorRelease());
979 // field isn't mandatory , but shouldn't be null(should be an empty string instead)
980 if (((Resource) component).getResourceVendorModelNumber() != null){
981 toscaElement.setMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER, ((Resource) component).getResourceVendorModelNumber());
983 toscaElement.setMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER, "");
985 } else if (component.getComponentType() == ComponentTypeEnum.SERVICE) {
986 // field isn't mandatory , but shouldn't be null(should be an empty string instead)
987 if (((Service) component).getServiceType() != null){
988 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_TYPE, ((Service) component).getServiceType());
990 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_TYPE, "");
992 if (((Service) component).getServiceRole() != null){
993 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_ROLE, ((Service) component).getServiceRole());
995 toscaElement.setMetadataValue(JsonPresentationFields.SERVICE_ROLE, "");
998 toscaElement.setMetadataValue(JsonPresentationFields.CONFORMANCE_LEVEL, component.getConformanceLevel());
999 toscaElement.setMetadataValue(JsonPresentationFields.IS_DELETED, component.getIsDeleted());
1000 toscaElement.setMetadataValue(JsonPresentationFields.ICON, component.getIcon());
1001 toscaElement.setMetadataValue(JsonPresentationFields.DESCRIPTION, component.getDescription());
1002 toscaElement.setMetadataValue(JsonPresentationFields.TAGS, component.getTags());
1003 toscaElement.setMetadataValue(JsonPresentationFields.INVARIANT_UUID, component.getInvariantUUID());
1004 toscaElement.setMetadataValue(JsonPresentationFields.CONTACT_ID, component.getContactId());
1009 private static void setComponentInstancesToComponent(TopologyTemplate topologyTemplate, Component component) {
1011 List<ComponentInstance> componentInstances = new ArrayList<>();
1012 ComponentInstance currComponentInstance;
1013 for (Map.Entry<String, ComponentInstanceDataDefinition> entry : topologyTemplate.getComponentInstances().entrySet()) {
1014 String key = entry.getKey();
1015 currComponentInstance = new ComponentInstance(topologyTemplate.getComponentInstances().get(key));
1016 if (topologyTemplate.getInstGroups() != null && topologyTemplate.getInstGroups().containsKey(key)) {
1017 List<GroupInstance> groupInstances = topologyTemplate.getInstGroups().get(key).getMapToscaDataDefinition().entrySet().stream().map(e -> new GroupInstance(e.getValue())).collect(Collectors.toList());
1018 currComponentInstance.setGroupInstances(groupInstances);
1020 componentInstances.add(currComponentInstance);
1022 component.setComponentInstances(componentInstances);
1025 private static void setComponentInstancesInputsToComponent(TopologyTemplate topologyTemplate, Component component) {
1026 if (topologyTemplate.getInstInputs() != null) {
1027 Map<String, List<ComponentInstanceInput>> inputs = new HashMap<>();
1028 for (Entry<String, MapPropertiesDataDefinition> entry : topologyTemplate.getInstInputs().entrySet()) {
1029 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1030 String key = entry.getKey();
1031 List<ComponentInstanceInput> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceInput(e.getValue())).collect(Collectors.toList());
1032 inputs.put(key, componentInstanceAttributes);
1035 component.setComponentInstancesInputs(inputs);
1039 private static void setComponentInstancesPropertiesToComponent(TopologyTemplate topologyTemplate, Component component) {
1040 if (topologyTemplate.getInstProperties() != null) {
1041 Map<String, List<ComponentInstanceProperty>> properties = new HashMap<>();
1042 for (Entry<String, MapPropertiesDataDefinition> entry : topologyTemplate.getInstProperties().entrySet()) {
1043 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1044 String key = entry.getKey();
1045 List<ComponentInstanceProperty> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceProperty(new PropertyDefinition(e.getValue())))
1046 .collect(Collectors.toList());
1047 properties.put(key, componentInstanceAttributes);
1050 component.setComponentInstancesProperties(properties);
1054 private static void setComponentInstancesAttributesToComponent(TopologyTemplate topologyTemplate, Component component) {
1055 if (topologyTemplate.getInstAttributes() != null) {
1056 Map<String, List<ComponentInstanceProperty>> attributes = new HashMap<>();
1057 for (Map.Entry<String, MapPropertiesDataDefinition> entry : topologyTemplate.getInstAttributes().entrySet()) {
1058 if (entry.getValue() != null && entry.getValue().getMapToscaDataDefinition() != null) {
1059 String key = entry.getKey();
1060 List<ComponentInstanceProperty> componentInstanceAttributes = entry.getValue().getMapToscaDataDefinition().entrySet().stream().map(e -> new ComponentInstanceProperty(new ComponentInstanceProperty(e.getValue())))
1061 .collect(Collectors.toList());
1062 attributes.put(key, componentInstanceAttributes);
1065 component.setComponentInstancesAttributes(attributes);
1069 private static void setComponentInstancesRequirementsToComponent(TopologyTemplate topologyTemplate, Component component) {
1071 if (topologyTemplate.getCalculatedRequirements() != null) {
1072 // Requirements of component organized by capability
1073 Map<String, List<RequirementDefinition>> instancesRequirements = new HashMap<>();
1075 Map<String, ComponentInstance> instancesMap = new HashMap<>();
1076 for (ComponentInstance currInstance : component.getComponentInstances()) {
1077 instancesMap.put(currInstance.getUniqueId(), currInstance);
1079 for (Map.Entry<String, MapListRequirementDataDefinition> entry : topologyTemplate.getCalculatedRequirements().entrySet()) {
1081 String instanceId = entry.getKey();
1082 // Requirements of instance organized by capability
1083 Map<String, ListRequirementDataDefinition> capsMapList = entry.getValue().getMapToscaDataDefinition();
1085 for (Entry<String, ListRequirementDataDefinition> entryTypeList : capsMapList.entrySet()) {
1086 String capabilityType = entryTypeList.getKey();
1087 List<RequirementDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream().map(cap -> new RequirementDefinition(cap)).collect(Collectors.toList());
1088 if (instancesRequirements.containsKey(capabilityType)) {
1089 instancesRequirements.get(capabilityType).addAll(caps);
1091 instancesRequirements.put(capabilityType, caps);
1093 if (MapUtils.isEmpty(instancesMap.get(instanceId).getRequirements())) {
1094 instancesMap.get(instanceId).setRequirements(new HashMap<>());
1096 instancesMap.get(instanceId).getRequirements().put(capabilityType, new ArrayList<>(caps));
1099 component.setRequirements(instancesRequirements);
1103 private static void setComponentInstancesCapabilitiesToComponentAndCI(TopologyTemplate topologyTemplate, Component component) {
1104 Map<String, MapCapabiltyProperty> calculatedCapProperties = topologyTemplate.getCalculatedCapabilitiesProperties();
1106 if (topologyTemplate.getCalculatedCapabilities() != null) {
1107 // capabilities of component organized by type
1108 Map<String, List<CapabilityDefinition>> instancesCapabilities = new HashMap<>();
1110 Map<String, ComponentInstance> instancesMap = new HashMap<>();
1111 for (ComponentInstance currInstance : component.getComponentInstances()) {
1112 instancesMap.put(currInstance.getUniqueId(), currInstance);
1114 for (Map.Entry<String, MapListCapabiltyDataDefinition> entry : topologyTemplate.getCalculatedCapabilities().entrySet()) {
1116 String instanceId = entry.getKey();
1117 // capabilities of instance organized by type
1118 Map<String, ListCapabilityDataDefinition> capsMapList = entry.getValue().getMapToscaDataDefinition();
1120 for (Entry<String, ListCapabilityDataDefinition> entryTypeList : capsMapList.entrySet()) {
1121 String capabilityType = entryTypeList.getKey();
1122 List<CapabilityDefinition> caps = entryTypeList.getValue().getListToscaDataDefinition().stream().map(cap -> mergeInstCapabiltyWithProperty(cap, instanceId, calculatedCapProperties)).collect(Collectors.toList());
1123 if (instancesCapabilities.containsKey(capabilityType)) {
1124 instancesCapabilities.get(capabilityType).addAll(caps);
1126 instancesCapabilities.put(capabilityType, caps);
1128 if (MapUtils.isEmpty(instancesMap.get(instanceId).getCapabilities())) {
1129 instancesMap.get(instanceId).setCapabilities(new HashMap<>());
1131 instancesMap.get(instanceId).getCapabilities().put(capabilityType, new ArrayList<>(caps));
1134 component.setCapabilities(instancesCapabilities);
1138 private static CapabilityDefinition mergeInstCapabiltyWithProperty(CapabilityDataDefinition cap, String instance, Map<String, MapCapabiltyProperty> calculatedCapProperties) {
1139 CapabilityDefinition capability = new CapabilityDefinition(cap);
1140 if (calculatedCapProperties != null) {
1141 MapCapabiltyProperty mapOfMapPropertiesDataDefinition = calculatedCapProperties.get(instance);
1142 if (mapOfMapPropertiesDataDefinition != null && mapOfMapPropertiesDataDefinition.getMapToscaDataDefinition() != null) {
1144 Map<String, MapPropertiesDataDefinition> toscaCapPropMap = mapOfMapPropertiesDataDefinition.getMapToscaDataDefinition();
1145 toscaCapPropMap.forEach(new BiConsumer<String, MapPropertiesDataDefinition>() {
1147 public void accept(String s, MapPropertiesDataDefinition capProp) {
1148 // format key of capability properties :
1149 // VF instance in service : instanceId#ownerId#type#capName
1150 // VFC instance ion VF : instanceId#type#capName -> instanceId=ownerId
1151 String[] result = s.split(CAP_PROP_DELIM);
1152 if (result.length < 4) {
1153 log.debug("wrong key format for capabilty, key {}", capProp);
1156 int instanceIndex = 0;
1158 int typeIndex = result.length - 2;
1159 int nameIndex = result.length - 1;
1160 if (capProp != null) {
1161 if (result[typeIndex].equals(cap.getType()) && result[nameIndex].equals(cap.getName()) && cap.getOwnerId().equals(result[ownerIndex]) && instance.equals(result[instanceIndex])) {
1163 Map<String, PropertyDataDefinition> capMap = capProp.getMapToscaDataDefinition();
1165 if (capMap != null && !capMap.isEmpty()) {
1166 // List<PropertyDataDefinition> list = map.values().stream().collect(Collectors.toList());
1167 List<ComponentInstanceProperty> capPropsList = capMap.values().stream().map(o -> {
1169 return new ComponentInstanceProperty(o);
1170 }).collect(Collectors.toList());
1172 capability.setProperties(capPropsList);
1183 private static void setComponentInstancesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1185 Map<String, ComponentInstanceDataDefinition> componentInstances = new HashMap<>();
1186 ComponentInstanceDataDefinition convertedInstance;
1187 if (component.getComponentInstances() != null) {
1188 for (ComponentInstance instance : component.getComponentInstances()) {
1189 convertedInstance = new ComponentInstanceDataDefinition(instance);
1190 if (instance.getGroupInstances() != null) {
1191 MapGroupsDataDefinition groupsMap = new MapGroupsDataDefinition();
1193 groupsMap.setMapToscaDataDefinition(instance.getGroupInstances().stream().map(e -> new GroupInstanceDataDefinition(e)).collect(Collectors.toMap(e -> e.getName(), e -> e)));
1194 if (topologyTemplate.getInstGroups() == null) {
1195 topologyTemplate.setInstGroups(new HashMap<>());
1197 topologyTemplate.getInstGroups().put(instance.getUniqueId(), groupsMap);
1199 componentInstances.put(instance.getUniqueId(), convertedInstance);
1202 topologyTemplate.setComponentInstances(componentInstances);
1206 private static void setComponentInstancesInputsToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1208 if (component.getComponentInstancesInputs() != null) {
1209 topologyTemplate.setInstInputs(new HashMap<>());
1210 MapPropertiesDataDefinition inputsMap;
1211 for (Entry<String, List<ComponentInstanceInput>> entry : component.getComponentInstancesInputs().entrySet()) {
1212 inputsMap = new MapPropertiesDataDefinition();
1214 inputsMap.setMapToscaDataDefinition(entry.getValue().stream().map(e -> new PropertyDataDefinition(e)).collect(Collectors.toMap(e -> e.getName(), e -> e)));
1216 topologyTemplate.getInstInputs().put(entry.getKey(), inputsMap);
1221 private static void setComponentInstancesPropertiesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1223 if (component.getComponentInstancesProperties() != null) {
1224 topologyTemplate.setInstProperties(new HashMap<>());
1225 MapPropertiesDataDefinition propertiesMap;
1226 for (Entry<String, List<ComponentInstanceProperty>> entry : component.getComponentInstancesProperties().entrySet()) {
1227 propertiesMap = new MapPropertiesDataDefinition();
1229 propertiesMap.setMapToscaDataDefinition(entry.getValue().stream().map(e -> new PropertyDataDefinition(e)).collect(Collectors.toMap(e -> e.getName(), e -> e)));
1231 topologyTemplate.getInstProperties().put(entry.getKey(), propertiesMap);
1236 private static void setComponentInstancesArtifactsToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1238 List<ComponentInstance> componentInstances = component.getComponentInstances();
1239 if (componentInstances != null) {
1240 topologyTemplate.setInstanceArtifacts(new HashMap<>());
1241 topologyTemplate.setInstDeploymentArtifacts(new HashMap<>());
1243 for (ComponentInstance ci : componentInstances) {
1244 Map<String, ArtifactDefinition> artifacts = ci.getArtifacts();
1245 if (artifacts != null) {
1246 Map<String, ArtifactDataDefinition> mapToscaDataDefinitionArtifact = artifacts.entrySet().stream().collect(Collectors.toMap(e -> e.getKey(), e -> new ArtifactDataDefinition(e.getValue())));
1247 MapArtifactDataDefinition insArtifact = new MapArtifactDataDefinition(mapToscaDataDefinitionArtifact);
1248 topologyTemplate.getInstanceArtifacts().put(ci.getUniqueId(), insArtifact);
1251 Map<String, ArtifactDefinition> deplArtifacts = ci.getDeploymentArtifacts();
1252 if (deplArtifacts != null) {
1253 Map<String, ArtifactDataDefinition> mapToscaDataDefinitionDepArtifact = deplArtifacts.entrySet().stream().collect(Collectors.toMap(e -> e.getKey(), e -> new ArtifactDataDefinition(e.getValue())));
1254 MapArtifactDataDefinition insDepArtifact = new MapArtifactDataDefinition(mapToscaDataDefinitionDepArtifact);
1255 topologyTemplate.getInstDeploymentArtifacts().put(ci.getUniqueId(), insDepArtifact);
1261 private static void setComponentInstancesAttributesToTopologyTemplate(Component component, TopologyTemplate topologyTemplate) {
1263 if (component.getComponentInstancesAttributes() != null) {
1264 topologyTemplate.setInstAttributes(new HashMap<>());
1265 MapPropertiesDataDefinition attributesMap;
1266 for (Entry<String, List<ComponentInstanceProperty>> entry : component.getComponentInstancesAttributes().entrySet()) {
1267 attributesMap = new MapPropertiesDataDefinition();
1269 attributesMap.setMapToscaDataDefinition(entry.getValue().stream().map(e -> new PropertyDataDefinition(e)).collect(Collectors.toMap(e -> e.getName(), e -> e)));
1271 topologyTemplate.getInstAttributes().put(entry.getKey(), attributesMap);
1276 public static ComponentMetadataData convertToComponentMetadata(GraphVertex vertex) {
1277 ComponentMetadataData metadata = null;
1278 switch (vertex.getType()) {
1280 metadata = new ServiceMetadataData(vertex.getMetadataJson());
1283 metadata = new ResourceMetadataData(vertex.getMetadataJson());
1286 metadata = new ProductMetadataData(vertex.getMetadataJson());
1291 if (metadata != null) {
1292 metadata.getMetadataDataDefinition().setUniqueId(vertex.getUniqueId());
1293 metadata.getMetadataDataDefinition().setLastUpdateDate((Long) vertex.getJsonMetadataField(JsonPresentationFields.LAST_UPDATE_DATE));
1294 metadata.getMetadataDataDefinition().setUUID((String) vertex.getJsonMetadataField(JsonPresentationFields.UUID));
1295 metadata.getMetadataDataDefinition().setState((String) vertex.getJsonMetadataField(JsonPresentationFields.LIFECYCLE_STATE));
1300 public static List<GroupDefinition> convertToGroupDefinitions(Map<String, GroupDataDefinition> groups) {
1302 List<GroupDefinition> groupDefinitions = null;
1303 if (MapUtils.isNotEmpty(groups)) {
1304 groupDefinitions = groups.values().stream().map(g -> new GroupDefinition(g)).collect(Collectors.toList());
1307 * if (CollectionUtils.isNotEmpty(groupDefinitions) && MapUtils.isNotEmpty(groupsProperties)) { for (GroupDefinition groupDefinition : groupDefinitions) { if (groupsProperties.containsKey(groupDefinition.getName())) { Map<String,
1308 * PropertyDataDefinition> properties = groupsProperties.get(groupDefinition.getName()).getMapToscaDataDefinition(); if (MapUtils.isNotEmpty(properties)) { groupDefinition.setProperties(properties.values().stream().map(p -> new
1309 * GroupProperty(p)).collect(Collectors.toList())); } } } }
1311 return groupDefinitions;