import org.apache.commons.lang3.StringUtils;
import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
-import org.openecomp.sdc.be.datatypes.elements.*;
+import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.CompositionDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.GroupInstanceDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.InterfaceDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.MapArtifactDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.MapCapabiltyProperty;
+import org.openecomp.sdc.be.datatypes.elements.MapGroupsDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.MapListCapabiltyDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.MapListRequirementDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.MapPropertiesDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.RelationshipInstDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
import org.openecomp.sdc.be.model.AdditionalInformationDefinition;
import org.openecomp.sdc.be.model.ArtifactDefinition;
import org.openecomp.sdc.be.model.CapabilityDefinition;
+import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
import org.openecomp.sdc.be.model.Component;
import org.openecomp.sdc.be.model.ComponentInstance;
import org.openecomp.sdc.be.model.ComponentInstanceInput;
import org.openecomp.sdc.be.model.GroupInstance;
import org.openecomp.sdc.be.model.InputDefinition;
import org.openecomp.sdc.be.model.InterfaceDefinition;
+import org.openecomp.sdc.be.model.PolicyDefinition;
import org.openecomp.sdc.be.model.PropertyDefinition;
import org.openecomp.sdc.be.model.RelationshipImpl;
-import org.openecomp.sdc.be.model.RequirementAndRelationshipPair;
+import org.openecomp.sdc.be.model.RelationshipInfo;
import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
import org.openecomp.sdc.be.model.RequirementDefinition;
import org.openecomp.sdc.be.model.Resource;
return null;
}
}
+
+ public static boolean isAtomicComponent(Component component) {
+ ComponentTypeEnum componentType = component.getComponentType();
+ if (!componentType.equals(ComponentTypeEnum.RESOURCE)) {
+ return false;
+ }
+ Resource resource = (Resource) component;
+ ResourceTypeEnum resType = resource.getResourceType();
+ return isAtomicComponent(resType);
+ }
+
+ public static boolean isAtomicComponent(ResourceTypeEnum resourceType) {
+ if (resourceType == null) {
+ return false;
+ }
+ return resourceType.isAtomicType();
+ }
// **********************************************************
public static VertexTypeEnum getVertexType(Component component) {
return vertexType;
}
- public static boolean isAtomicComponent(ResourceTypeEnum resourceType) {
- if (resourceType == null || resourceType == ResourceTypeEnum.VF || resourceType == ResourceTypeEnum.PNF || resourceType == ResourceTypeEnum.CVFC)
- return false;
- return true;
- }
+
private static Service convertToService(ToscaElement toscaElement) {
Service service = new Service();
convertComponentInstances(topologyTemplate, service);
convertInputs(topologyTemplate, service);
+
+ convertPolicies(topologyTemplate, service);
+
+ convertGroups(topologyTemplate, service);
+
+ convertPolicies(topologyTemplate, service);
+
+ convertGroups(topologyTemplate, service);
+
+ convertPolicies(topologyTemplate, service);
convertRelations(topologyTemplate, service);
convertServiceApiArtifacts(topologyTemplate, service);
+ convertServicePaths(topologyTemplate, service);
+
return service;
}
service.setDistributionStatus(DistributionStatusEnum.findState((String) toscaElement.getMetadataValue(JsonPresentationFields.DISTRIBUTION_STATUS)));
service.setEcompGeneratedNaming((Boolean) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.ECOMP_GENERATED_NAMING, true));
service.setNamingPolicy((String) toscaElement.getMetadataValueOrDefault(JsonPresentationFields.NAMING_POLICY, StringUtils.EMPTY));
+ service.setEnvironmentContext((String) toscaElement.getMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT));
}
private static Resource convertToResource(ToscaElement toscaElement) {
resource.setCsarUUID((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_UUID));
resource.setCsarVersion((String) topologyTemplate.getMetadataValue(JsonPresentationFields.CSAR_VERSION));
resource.setImportedToscaChecksum((String) topologyTemplate.getMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM));
+ convertInterfaces(topologyTemplate, resource);
}
convertComponentInstances(topologyTemplate, resource);
convertRelations(topologyTemplate, resource);
convertInputs(topologyTemplate, resource);
convertGroups(topologyTemplate, resource);
+ convertPolicies(topologyTemplate, resource);
}
convertArtifacts(toscaElement, resource);
convertAdditionalInformation(toscaElement, resource);
return resource;
}
+ private static void convertInterfaces(TopologyTemplate toscaElement, Resource resource) {
+ Map<String, InterfaceDataDefinition> interfaces = toscaElement.getInterfaces();
+ Map<String, InterfaceDefinition> copy;
+ if (interfaces != null) {
+ copy = interfaces.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDefinition(e.getValue())));
+ } else {
+ copy = new HashMap<>();
+ }
+ resource.setInterfaces(copy);
+ }
+
private static void convertAttributes(NodeType nodeType, Resource resource) {
Map<String, PropertyDataDefinition> attributes = nodeType.getAttributes();
if (attributes != null) {
RequirementCapabilityRelDef requirementCapabilityRelDef = new RequirementCapabilityRelDef();
requirementCapabilityRelDef.setFromNode(relation.getFromId());
requirementCapabilityRelDef.setToNode(relation.getToId());
- List<RequirementAndRelationshipPair> relationships = new ArrayList<>();
- RequirementAndRelationshipPair relationshipPair = new RequirementAndRelationshipPair();
+ RelationshipInfo relationshipPair = new RelationshipInfo();
relationshipPair.setId(relation.getUniqueId());
-
relationshipPair.setCapabilityOwnerId(relation.getCapabilityOwnerId());
relationshipPair.setCapabilityUid(relation.getCapabilityId());
+ relationshipPair.setCapability(relation.getCapability());
relationshipPair.setRequirementOwnerId(relation.getRequirementOwnerId());
relationshipPair.setRequirementUid(relation.getRequirementId());
relationshipPair.setRequirement(relation.getRequirement());
RelationshipImpl relationship = new RelationshipImpl();
relationship.setType(relation.getType());
relationshipPair.setRelationships(relationship);
-
- relationships.add(relationshipPair);
+ CapabilityRequirementRelationship rel = new CapabilityRequirementRelationship();
+ rel.setRelation(relationshipPair);
+ List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
+ relationships.add(rel);
requirementCapabilityRelDef.setRelationships(relationships);
return requirementCapabilityRelDef;
}
List<RelationshipInstDataDefinition> relationsList = new ArrayList<>();
- List<RequirementAndRelationshipPair> relationship = relation.getRelationships();
+ List<CapabilityRequirementRelationship> relationship = relation.getRelationships();
relationship.forEach(p -> {
RelationshipInstDataDefinition requirementCapabilityRelDef = new RelationshipInstDataDefinition();
requirementCapabilityRelDef.setFromId(relation.getFromNode());
requirementCapabilityRelDef.setToId(relation.getToNode());
- requirementCapabilityRelDef.setUniqueId(p.getId());
- requirementCapabilityRelDef.setCapabilityOwnerId(p.getCapabilityOwnerId());
- requirementCapabilityRelDef.setCapabilityId(p.getCapabilityUid());
- requirementCapabilityRelDef.setRequirementOwnerId(p.getRequirementOwnerId());
- requirementCapabilityRelDef.setRequirementId(p.getRequirementUid());
- requirementCapabilityRelDef.setRequirement(p.getRequirement());
- requirementCapabilityRelDef.setType(p.getRelationship().getType());
- requirementCapabilityRelDef.setCapability(p.getCapability());
+ requirementCapabilityRelDef.setUniqueId(p.getRelation().getId());
+ requirementCapabilityRelDef.setCapabilityOwnerId(p.getRelation().getCapabilityOwnerId());
+ requirementCapabilityRelDef.setCapabilityId(p.getRelation().getCapabilityUid());
+ requirementCapabilityRelDef.setRequirementOwnerId(p.getRelation().getRequirementOwnerId());
+ requirementCapabilityRelDef.setRequirementId(p.getRelation().getRequirementUid());
+ requirementCapabilityRelDef.setRequirement(p.getRelation().getRequirement());
+ requirementCapabilityRelDef.setType(p.getRelation().getRelationship().getType());
+ requirementCapabilityRelDef.setCapability(p.getRelation().getCapability());
relationsList.add(requirementCapabilityRelDef);
});
sb.append(cap.getOwnerId());
}
sb.append(CAP_PROP_DELIM).append(s).append(CAP_PROP_DELIM).append(cap.getName());
- toscaCapPropMap.put(sb.toString(), dataToCreate);
+ toscaCapPropMap.put(sb.toString(), new MapPropertiesDataDefinition(dataToCreate));
}
}
return new MapListRequirementDataDefinition(mapToscaDataDefinition);
}
- private static void convertRequirements(TopologyTemplate toscaElement, Component component) {
-
- if (CollectionUtils.isNotEmpty(component.getComponentInstances())) {
- for (ComponentInstance instance : component.getComponentInstances()) {
- Map<String, List<RequirementDefinition>> instanceRequirements = instance.getRequirements();
- if (MapUtils.isNotEmpty(instanceRequirements)) {
- addRequirementsByInstanceId(instance.getUniqueId(), instanceRequirements, component);
- }
- }
- }
- }
-
- private static void addRequirementsByInstanceId(String instanceId, Map<String, List<RequirementDefinition>> instanceRequirementsMap, Component component) {
-
- if (component.getCapabilities() == null) {
- component.setCapabilities(new HashMap<>());
- }
- List<RequirementDefinition> instanceRequirements = new ArrayList<>();
- for (List<RequirementDefinition> instRequirements : instanceRequirementsMap.values()) {
- instanceRequirements.addAll(instRequirements);
- }
- component.getRequirements().put(instanceId, instanceRequirements);
- }
-
- private static void convertCapabilities(TopologyTemplate toscaElement, Component component) {
-
- if (CollectionUtils.isNotEmpty(component.getComponentInstances())) {
- for (ComponentInstance instance : component.getComponentInstances()) {
- Map<String, List<CapabilityDefinition>> instanceCapabilities = instance.getCapabilities();
- if (MapUtils.isNotEmpty(instanceCapabilities)) {
- addCapabilitiesByInstanceId(instance.getUniqueId(), instanceCapabilities, component);
- }
- }
- }
- }
-
- private static void addCapabilitiesByInstanceId(String instanceId, Map<String, List<CapabilityDefinition>> instanceCapabilitiesMap, Component component) {
-
- if (component.getCapabilities() == null) {
- component.setCapabilities(new HashMap<>());
- }
- List<CapabilityDefinition> instanceCapabilities = new ArrayList<>();
- for (List<CapabilityDefinition> instCapabilitis : instanceCapabilitiesMap.values()) {
- instanceCapabilities.addAll(instCapabilitis);
- }
- component.getCapabilities().put(instanceId, instanceCapabilities);
- }
-
@SuppressWarnings("unchecked")
private static void convertComponentFields(Component component, ToscaElement toscaElement) {
component.setName(toscaElement.getName());
resource.setVendorRelease((String) toscaElement.getMetadataValue(JsonPresentationFields.VENDOR_RELEASE));
// field isn't mandatory , but shouldn't be null(should be an empty string instead)
if (((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER)) != null){
- resource.setResourceVendorModelNumber(((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER)));
+ resource.setResourceVendorModelNumber((String) toscaElement.getMetadataValue(JsonPresentationFields.RESOURCE_VENDOR_MODEL_NUMBER));
} else {
resource.setResourceVendorModelNumber("");
}
} else if (component.getComponentType() == ComponentTypeEnum.SERVICE) {
Service service = (Service) component;
if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE)) != null){
- service.setServiceType(((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE)));
+ service.setServiceType((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_TYPE));
} else {
service.setServiceType("");
}
if (((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE)) != null){
- service.setServiceRole(((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE)));
+ service.setServiceRole((String) toscaElement.getMetadataValue(JsonPresentationFields.SERVICE_ROLE));
} else {
service.setServiceRole("");
}
}
service.setServiceApiArtifacts(copy);
}
+ private static void convertServicePaths(TopologyTemplate topologyTemplate, Service service) {
+ Map<String, ForwardingPathDataDefinition> servicePaths = topologyTemplate.getForwardingPaths();
+ Map<String, ForwardingPathDataDefinition> copy;
+ if (servicePaths != null) {
+ copy = servicePaths.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ForwardingPathDataDefinition(e.getValue())));
+
+ } else {
+ copy = new HashMap<>();
+ }
+ service.setForwardingPaths(copy);
+ }
private static void convertArtifacts(Component component, ToscaElement toscaElement) {
Map<String, ArtifactDefinition> artifacts = component.getArtifacts();
}
component.setGroups(groupDefinitions);
}
+
+ private static void convertPolicies(TopologyTemplate toscaElement, Component component) {
+ Map<String, PolicyDataDefinition> policies = toscaElement.getPolicies();
+ Map<String, PolicyDefinition> policyDefinitions = null;
+ if (MapUtils.isNotEmpty(policies)) {
+ policyDefinitions = policies.values().stream().map(p -> new PolicyDefinition(p)).collect(Collectors.toMap(p->p.getUniqueId(), p->p));
+ }
+ component.setPolicies(policyDefinitions);
+ }
private static void convertGroups(Component component, TopologyTemplate toscaElement) {
List<GroupDefinition> groupDefinitions = component.getGroups();
Map<String, GroupDataDefinition> groups = new HashMap<>();
if (groupDefinitions != null && groups.isEmpty()) {
- groups = groupDefinitions.stream().collect((Collectors.toMap(pr -> pr.getName(), pr -> new GroupDataDefinition(pr))));
+ groups = groupDefinitions.stream().collect(Collectors.toMap(pr -> pr.getName(), pr -> new GroupDataDefinition(pr)));
}
toscaElement.setGroups(groups);
-
+ }
+
+ private static void convertPolicies(Component component, TopologyTemplate toscaElement) {
+ Map<String, PolicyDefinition> policyDefinitions = component.getPolicies();
+ Map<String, PolicyDataDefinition> policies = new HashMap<>();
+ if (MapUtils.isNotEmpty(policyDefinitions)) {
+ policies = policyDefinitions.values().stream().collect((Collectors.toMap(p -> p.getUniqueId(), p -> new PolicyDataDefinition(p))));
+ }
+ toscaElement.setPolicies(policies);
}
private static void convertRequirements(NodeType toscaElement, Component component) {
topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_UUID, resource.getCsarUUID());
topologyTemplate.setMetadataValue(JsonPresentationFields.CSAR_VERSION, resource.getCsarVersion());
topologyTemplate.setMetadataValue(JsonPresentationFields.IMPORTED_TOSCA_CHECKSUM, resource.getImportedToscaChecksum());
+ convertInterfaces(resource, topologyTemplate);
}
if (componentType == ComponentTypeEnum.SERVICE) {
convertServiceSpecificEntities((Service) component, topologyTemplate);
convertInputs(component, topologyTemplate);
convertCapabilities(component, topologyTemplate);
convertGroups(component, topologyTemplate);
+ convertPolicies(component, topologyTemplate);
convertRequirements(component, topologyTemplate);
convertRelationsToComposition(component, topologyTemplate);
return topologyTemplate;
}
+ private static void convertInterfaces(Resource resource, TopologyTemplate topologyTemplate) {
+ Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
+ if (interfaces != null && !interfaces.isEmpty()) {
+ Map<String, InterfaceDataDefinition> copy = interfaces.entrySet().stream()
+ .collect(Collectors.toMap(Map.Entry::getKey, e -> new InterfaceDataDefinition(e.getValue())));
+ topologyTemplate.setInterfaces(copy);
+ }
+ }
+
private static void convertServiceSpecificEntities(Service service, TopologyTemplate topologyTemplate) {
convertServiceMetaData(service, topologyTemplate);
convertServiceApiArtifacts(service, topologyTemplate);
+ convertServicePaths(service,topologyTemplate);
+ }
+
+ private static void convertServicePaths(Service service, TopologyTemplate topologyTemplate) {
+ Map<String, ForwardingPathDataDefinition> servicePaths = service.getForwardingPaths();
+ if (servicePaths != null && !servicePaths.isEmpty()) {
+ Map<String, ForwardingPathDataDefinition> copy = servicePaths.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> new ForwardingPathDataDefinition(e.getValue())));
+ topologyTemplate.setForwardingPaths(copy);
+ }
}
private static void convertServiceMetaData(Service service, TopologyTemplate topologyTemplate) {
topologyTemplate.setMetadataValue(JsonPresentationFields.PROJECT_CODE, service.getProjectCode());
topologyTemplate.setMetadataValue(JsonPresentationFields.ECOMP_GENERATED_NAMING, service.isEcompGeneratedNaming());
topologyTemplate.setMetadataValue(JsonPresentationFields.NAMING_POLICY, service.getNamingPolicy());
+ topologyTemplate.setMetadataValue(JsonPresentationFields.ENVIRONMENT_CONTEXT, service.getEnvironmentContext());
}
toscaElement.setMetadataValue(JsonPresentationFields.CONTACT_ID, component.getContactId());
}
- public static boolean isAtomicComponent(Component component) {
- ComponentTypeEnum componentType = component.getComponentType();
- if (!componentType.equals(ComponentTypeEnum.RESOURCE)) {
- return false;
- }
- Resource resource = (Resource) component;
- ResourceTypeEnum resType = resource.getResourceType();
- if (resType == ResourceTypeEnum.VFC || resType == ResourceTypeEnum.VFCMT || resType == ResourceTypeEnum.VL || resType == ResourceTypeEnum.CP || resType == ResourceTypeEnum.ABSTRACT) {
- return true;
- }
- return false;
- }
+
private static void setComponentInstancesToComponent(TopologyTemplate topologyTemplate, Component component) {
} else {
instancesCapabilities.put(capabilityType, caps);
}
- if (MapUtils.isEmpty(instancesMap.get(instanceId).getCapabilities())) {
- instancesMap.get(instanceId).setCapabilities(new HashMap<>());
+ ComponentInstance instance = instancesMap.get(instanceId);
+ if (instance == null) {
+ log.error("instance is null for id {} entry {}", instanceId, entry.getValue().getToscaPresentationValue(JsonPresentationFields.NAME));
+ } else {
+ if (MapUtils.isEmpty(instance.getCapabilities())) {
+ instance.setCapabilities(new HashMap<>());
+ }
+ instance.getCapabilities().put(capabilityType, new ArrayList<>(caps));
}
- instancesMap.get(instanceId).getCapabilities().put(capabilityType, new ArrayList<>(caps));
}
}
component.setCapabilities(instancesCapabilities);
if (MapUtils.isNotEmpty(groups)) {
groupDefinitions = groups.values().stream().map(g -> new GroupDefinition(g)).collect(Collectors.toList());
}
- /*
- * if (CollectionUtils.isNotEmpty(groupDefinitions) && MapUtils.isNotEmpty(groupsProperties)) { for (GroupDefinition groupDefinition : groupDefinitions) { if (groupsProperties.containsKey(groupDefinition.getName())) { Map<String,
- * PropertyDataDefinition> properties = groupsProperties.get(groupDefinition.getName()).getMapToscaDataDefinition(); if (MapUtils.isNotEmpty(properties)) { groupDefinition.setProperties(properties.values().stream().map(p -> new
- * GroupProperty(p)).collect(Collectors.toList())); } } } }
- */
return groupDefinitions;
}