+/*
+ * Copyright © 2016-2017 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
package org.openecomp.sdc.enrichment.impl.tosca;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
+import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
import org.openecomp.sdc.datatypes.error.ErrorMessage;
import org.openecomp.sdc.enrichment.impl.tosca.model.PortMirroringConnectionPointDescription;
-import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
+import org.openecomp.sdc.tosca.datatypes.ToscaElementTypes;
import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
import org.openecomp.sdc.tosca.datatypes.model.CapabilityAssignment;
import org.openecomp.sdc.tosca.datatypes.model.Import;
import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
+import org.openecomp.sdc.tosca.datatypes.model.NodeType;
import org.openecomp.sdc.tosca.datatypes.model.PropertyDefinition;
import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
import org.openecomp.sdc.tosca.services.DataModelUtil;
+import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
import org.openecomp.sdc.tosca.services.ToscaConstants;
import org.openecomp.sdc.tosca.services.ToscaUtil;
+import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil;
import org.openecomp.sdc.translator.services.heattotosca.globaltypes.GlobalTypesGenerator;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
+import java.util.Set;
import java.util.stream.Collectors;
import static org.openecomp.sdc.tosca.services.DataModelUtil.getClonedObject;
//Map of substitution service template name and the list of ports with link requirement from
// the abstract
private Map<String, List<String>> portNodeTemplateIdsFromAbstract = new HashMap<>();
- private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
private Map<String, ServiceTemplate> globalTypesServiceTemplate =
- GlobalTypesGenerator.getGlobalTypesServiceTemplate();
+ GlobalTypesGenerator.getGlobalTypesServiceTemplate(OnboardingTypesEnum.ZIP);
/**
* Enrich tosca for port mirroring.
* @return the map Error descriptor map
*/
public Map<String, List<ErrorMessage>> enrich(ToscaServiceModel toscaServiceModel) {
- mdcDataDebugMessage.debugEntryMessage(null);
Map<String, List<ErrorMessage>> errors = new HashMap<>();
Map<String, ServiceTemplate> serviceTemplates = toscaServiceModel.getServiceTemplates();
serviceTemplates.entrySet().stream()
filterExternalPorts(toscaServiceModel);
//Handle external port changes
handleExternalPorts(toscaServiceModel);
- mdcDataDebugMessage.debugExitMessage(null);
return errors;
}
if (Objects.nonNull(nodeTemplates)) {
//Get all concrete port node templates from the service template
Map<String, NodeTemplate> serviceTemplatePortNodeTemplates = nodeTemplates.entrySet().stream()
- .filter(nodeTemplateEntry -> isPortNodeTemplate(nodeTemplateEntry.getValue()))
+ .filter(nodeTemplateEntry -> (Objects.nonNull(nodeTemplateEntry.getValue()))
+ && (isPortNodeTemplate(nodeTemplateEntry.getValue().getType())))
.collect(Collectors.toMap(nodeTemplateEntry -> nodeTemplateEntry.getKey(),
nodeTemplateEntry -> nodeTemplateEntry.getValue()));
addPortMirroringSubstitutionMappingCapability(serviceTemplate,
externalPortNodeTemplateId);
}
- handleExternalPortProperties(externalNodeTemplate.getValue());
+ handleExternalPortProperties(externalNodeTemplate.getValue(), serviceTemplate, toscaServiceModel);
}
addGlobalTypeImport(serviceTemplate);
}
}
}
- private void handleExternalPortProperties(NodeTemplate portNodeTemplate) {
+ private void handleExternalPortProperties(NodeTemplate portNodeTemplate,
+ ServiceTemplate serviceTemplate,
+ ToscaServiceModel toscaServiceModel){
- ServiceTemplate serviceTemplate = globalTypesServiceTemplate.get("openecomp/nodes.yml");
+ ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
String externalPortType = portNodeTemplate.getType();
Map<String, PropertyDefinition> globalTypesportProperties = new HashMap<>();
- globalTypesportProperties.putAll(
- serviceTemplate.getNode_types().get("org.openecomp.resource.cp.nodes.network.Port")
- .getProperties());
- globalTypesportProperties
- .putAll(serviceTemplate.getNode_types().get(externalPortType).getProperties());
+ NodeType flatNodeType =
+ (NodeType) toscaAnalyzerService.getFlatEntity(ToscaElementTypes.NODE_TYPE, externalPortType, serviceTemplate, toscaServiceModel);
+ globalTypesportProperties.putAll(flatNodeType.getProperties());
Map<String, Object> properties = portNodeTemplate.getProperties();
Map<String, Object> filteredProperties = new HashMap<>();
- if (MapUtils.isEmpty(properties)) {
+ if(MapUtils.isEmpty(properties)){
return;
}
- for (Map.Entry<String, Object> propertyEntry : properties.entrySet()) {
- if (globalTypesportProperties.containsKey(propertyEntry.getKey())) {
+ for(Map.Entry<String, Object> propertyEntry: properties.entrySet()){
+ if(globalTypesportProperties.containsKey(propertyEntry.getKey())){
filteredProperties.put(propertyEntry.getKey(), propertyEntry.getValue());
}
}
- if (!MapUtils.isEmpty(filteredProperties)) {
+ if(!MapUtils.isEmpty(filteredProperties)) {
portNodeTemplate.setProperties(filteredProperties);
- } else {
+ }else{
portNodeTemplate.setProperties(null);
}
}
private void addPortMirroringCapability(NodeTemplate portNodeTemplate) {
- List<Map<String, CapabilityAssignment>> capabilities = portNodeTemplate.getCapabilities();
- if (Objects.isNull(capabilities)) {
- capabilities = new ArrayList<>();
- }
Map<String, Object> portMirroringCapabilityProperties = new HashMap<>();
PortMirroringConnectionPointDescription connectionPoint = new
PortMirroringConnectionPointDescription();
imports.add(openecompIndexImport);
}
- private boolean isPortNodeTemplate(NodeTemplate nodeTemplate) {
- String nodeType = nodeTemplate.getType();
+ private boolean isPortNodeTemplate(String nodeType) {
//Check if node corresponds to a concrete port node
- if (nodeType.equals(ToscaNodeType.NEUTRON_PORT)
- || nodeType.equals(ToscaNodeType.CONTRAILV2_VIRTUAL_MACHINE_INTERFACE)
- || nodeType.equals(ToscaNodeType.CONTRAIL_PORT)
- || nodeType.equals(ToscaNodeType.NETWORK_PORT)
- || nodeType.equals(ToscaNodeType.NATIVE_NETWORK_PORT)) {
- return true;
- }
- return false;
+ Set<String> portNodeTypes = getPortNodeTypes();
+ return Objects.nonNull(nodeType)
+ && portNodeTypes.contains(nodeType);
+ }
+
+ private Set<String> getPortNodeTypes(){
+ return new HashSet<>(Arrays.asList(ToscaNodeType.NEUTRON_PORT,
+ ToscaNodeType.CONTRAILV2_VIRTUAL_MACHINE_INTERFACE,
+ ToscaNodeType.CONTRAIL_PORT));
}
private boolean isSubstitutableNodeTemplate(NodeTemplate nodeTemplate) {