gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.openecomp.sdc.translator.services.heattotosca.impl.resourcetranslation;
  17
  18 import static org.openecomp.sdc.tosca.services.ToscaConstants.MANDATORY_PROPERTY_NAME;
  19 import static org.openecomp.sdc.translator.services.heattotosca.HeatToToscaLogConstants.LOG_INVALID_NETWORK_CONNECTION;
  20 import static org.openecomp.sdc.translator.services.heattotosca.HeatToToscaLogConstants.LOG_MISSING_VIRTUAL_NETWORK_INTERFACE_LIST;
  21 import static org.openecomp.sdc.translator.services.heattotosca.HeatToToscaLogConstants.LOG_MULTIPLE_SERVICE_INSTANCE_DIFF_INTERFACES;
  22 import static org.openecomp.sdc.translator.services.heattotosca.HeatToToscaLogConstants.LOG_SERVICE_TEMPLATE_PROPERTY_GET_RESOURCE;
  23 import static org.openecomp.sdc.translator.services.heattotosca.HeatToToscaLogConstants.LOG_SERVICE_TEMPLATE_PROPERTY_INVALID_TYPE;
  24 import static org.openecomp.sdc.translator.services.heattotosca.HeatToToscaLogConstants.LOG_SERVICE_TEMPLATE_PROPERTY_UNSUPPORTED_RESOURCE;
  25 import static org.openecomp.sdc.translator.services.heattotosca.HeatToToscaLogConstants.LOG_UNSUPPORTED_NETWORK_RESOURCE_CONNECTION;
  26
  27 import com.google.common.collect.ImmutableList;
  28 import java.util.ArrayList;
  29 import java.util.HashMap;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.Objects;
  33 import java.util.Optional;
  34 import org.onap.sdc.tosca.datatypes.model.AttributeDefinition;
  35 import org.onap.sdc.tosca.datatypes.model.GroupDefinition;
  36 import org.onap.sdc.tosca.datatypes.model.Import;
  37 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
  38 import org.onap.sdc.tosca.datatypes.model.NodeType;
  39 import org.onap.sdc.tosca.datatypes.model.ParameterDefinition;
  40 import org.onap.sdc.tosca.datatypes.model.PropertyDefinition;
  41 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  42 import org.onap.sdc.tosca.datatypes.model.RequirementDefinition;
  43 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
  44 import org.onap.sdc.tosca.datatypes.model.SubstitutionMapping;
  45 import org.onap.sdc.tosca.datatypes.model.TopologyTemplate;
  46 import org.openecomp.sdc.common.errors.CoreException;
  47 import org.openecomp.sdc.heat.datatypes.HeatBoolean;
  48 import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes;
  49 import org.openecomp.sdc.heat.datatypes.model.Resource;
  50 import org.openecomp.sdc.heat.services.HeatConstants;
  51 import org.openecomp.sdc.logging.api.Logger;
  52 import org.openecomp.sdc.logging.api.LoggerFactory;
  53 import org.openecomp.sdc.tosca.datatypes.ToscaCapabilityType;
  54 import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
  55 import org.openecomp.sdc.tosca.datatypes.ToscaGroupType;
  56 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
  57 import org.openecomp.sdc.tosca.datatypes.ToscaRelationshipType;
  58 import org.openecomp.sdc.tosca.services.DataModelUtil;
  59 import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
  60 import org.openecomp.sdc.tosca.services.ToscaConstants;
  61 import org.openecomp.sdc.tosca.services.ToscaUtil;
  62 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
  63 import org.openecomp.sdc.tosca.services.impl.ToscaFileOutputServiceCsarImpl;
  64 import org.openecomp.sdc.translator.datatypes.heattotosca.AttachedResourceId;
  65 import org.openecomp.sdc.translator.datatypes.heattotosca.to.ContrailServiceInstanceTo;
  66 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslateTo;
  67 import org.openecomp.sdc.translator.datatypes.heattotosca.to.TranslatedHeatResource;
  68 import org.openecomp.sdc.translator.services.heattotosca.Constants;
  69 import org.openecomp.sdc.translator.services.heattotosca.HeatToToscaUtil;
  70 import org.openecomp.sdc.translator.services.heattotosca.ResourceTranslationFactory;
  71 import org.openecomp.sdc.translator.services.heattotosca.errors.MissingMandatoryPropertyErrorBuilder;
  72 import org.openecomp.sdc.translator.services.heattotosca.globaltypes.GlobalTypesGenerator;
  73 import org.openecomp.sdc.translator.services.heattotosca.helper.ContrailTranslationHelper;
  74 import org.openecomp.sdc.translator.services.heattotosca.mapping.TranslatorHeatToToscaPropertyConverter;
  75
  76 public class ResourceTranslationContrailServiceInstanceImpl extends ResourceTranslationBase {
  77
  78     private static final String INTERFACE_LIST = "interface_list";
  79     protected static Logger logger = LoggerFactory.getLogger(ResourceTranslationContrailServiceInstanceImpl.class);
  80
  81     @Override
  82     public void translate(TranslateTo translateTo) {
  83         Resource serviceInstanceResource = translateTo.getResource();
  84         AttachedResourceId contrailServiceTemplateAttached = getServiceTemplateAttachedId(translateTo, serviceInstanceResource);
  85         if (contrailServiceTemplateAttached.isGetResource()) {
  86             translateContrailServiceInstance(translateTo, serviceInstanceResource, contrailServiceTemplateAttached);
  87         } else {
  88             logger.warn(LOG_SERVICE_TEMPLATE_PROPERTY_GET_RESOURCE, translateTo.getResourceId(), translateTo.getResource().getType());
  89         }
  90     }
  91
  92     private void translateContrailServiceInstance(TranslateTo translateTo, Resource serviceInstanceResource,
  93                                                   AttachedResourceId contrailServiceTemplateAttached) {
  94         String contrailServiceTemplateResourceId = (String) contrailServiceTemplateAttached.getEntityId();
  95         Resource contrailServiceTemplateResource = HeatToToscaUtil
  96             .getResource(translateTo.getHeatOrchestrationTemplate(), contrailServiceTemplateResourceId, translateTo.getHeatFileName());
  97         if (!contrailServiceTemplateResource.getType().equals(HeatResourcesTypes.CONTRAIL_SERVICE_TEMPLATE.getHeatResource())) {
  98             logger.warn(LOG_SERVICE_TEMPLATE_PROPERTY_INVALID_TYPE, translateTo.getResourceId(), translateTo.getResource().getType(),
  99                 contrailServiceTemplateResourceId, contrailServiceTemplateResource.getType(),
 100                 HeatResourcesTypes.CONTRAIL_SERVICE_TEMPLATE.getHeatResource());
 101             return;
 102         }
 103         Optional<String> contrailServiceTemplateTranslatedId = ResourceTranslationFactory.getInstance(contrailServiceTemplateResource)
 104             .translateResource(translateTo.getHeatFileName(), translateTo.getServiceTemplate(), translateTo.getHeatOrchestrationTemplate(),
 105                 contrailServiceTemplateResource, contrailServiceTemplateResourceId, translateTo.getContext());
 106         if (!contrailServiceTemplateTranslatedId.isPresent()) {
 107             logger.warn(LOG_SERVICE_TEMPLATE_PROPERTY_UNSUPPORTED_RESOURCE, translateTo.getResourceId(), translateTo.getResource().getType(),
 108                 contrailServiceTemplateResourceId, contrailServiceTemplateResource.getType());
 109             return;
 110         }
 111         ServiceTemplate globalSubstitutionServiceTemplate = translateTo.getContext().getTranslatedServiceTemplates()
 112             .get(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME);
 113         String contrailStId = ResourceTranslationContrailServiceTemplateImpl
 114             .getContrailSubstitutedNodeTypeId(contrailServiceTemplateTranslatedId.get());
 115         NodeType substitutedNodeType = DataModelUtil.getNodeType(globalSubstitutionServiceTemplate, contrailStId);
 116         int numberOfPorts = getServiceInstanceNumberOfPorts(serviceInstanceResource);
 117         if (substitutedNodeType.getRequirements() != null && substitutedNodeType.getRequirements().size() != numberOfPorts) {
 118             logger.warn(LOG_MULTIPLE_SERVICE_INSTANCE_DIFF_INTERFACES, contrailServiceTemplateResourceId);
 119             return;
 120         }
 121         addNetworkLinkRequirements(substitutedNodeType, numberOfPorts);
 122         NodeTemplate substitutedNodeTemplate = createSubstitutedNodeTemplate(translateTo, contrailServiceTemplateResource, contrailStId,
 123             numberOfPorts);
 124         String computeNodeTypeId = new ContrailTranslationHelper()
 125             .getComputeNodeTypeId(contrailServiceTemplateResource, contrailServiceTemplateResourceId, contrailServiceTemplateTranslatedId.get(),
 126                 translateTo.getContext());
 127         boolean orderedInterfaces = getOrderedInterfaces(contrailServiceTemplateResource);
 128         ServiceTemplate nestedServiceTemplate = createNestedServiceTemplate(translateTo, computeNodeTypeId, contrailStId, substitutedNodeTemplate,
 129             orderedInterfaces);
 130         addAbstractSubstitutionProperty(translateTo, substitutedNodeTemplate.getProperties(), nestedServiceTemplate, contrailServiceTemplateResource);
 131         translateTo.getContext().getTranslatedServiceTemplates().put(new ContrailTranslationHelper()
 132             .getSubstitutionContrailServiceTemplateMetadata(translateTo.getHeatFileName(), translateTo.getTranslatedId()), nestedServiceTemplate);
 133     }
 134
 135     private void addAbstractSubstitutionProperty(TranslateTo translateTo, Map<String, Object> substitutionProperties,
 136                                                  ServiceTemplate nestedServiceTemplate, Resource contrailServiceTemplateResource) {
 137         Map<String, Object> innerProps = new HashMap<>();
 138         innerProps.put(ToscaConstants.SUBSTITUTE_SERVICE_TEMPLATE_PROPERTY_NAME, ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
 139         Object countValue = handleScaleOutProperty(translateTo, innerProps);
 140         handleServiceScalingProperty(translateTo, innerProps, contrailServiceTemplateResource);
 141         boolean mandatory = false;
 142         if (countValue instanceof Integer && (Integer) countValue > 0) {
 143             mandatory = true;
 144         }
 145         if (countValue == null) {
 146             mandatory = true;
 147         }
 148         innerProps.put(MANDATORY_PROPERTY_NAME, mandatory);
 149         substitutionProperties.put(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME, innerProps);
 150     }
 151
 152     private Object handleScaleOutProperty(TranslateTo translateTo, Map<String, Object> innerProps) {
 153         Object scaleOutPropertyValue = translateTo.getResource().getProperties().get(HeatConstants.SCALE_OUT_PROPERTY_NAME);
 154         Object countValue = null;
 155         if (scaleOutPropertyValue instanceof Map) {
 156             countValue = TranslatorHeatToToscaPropertyConverter
 157                 .getToscaPropertyValue(translateTo.getServiceTemplate(), translateTo.getTranslatedId(), Constants.MAX_INSTANCES_PROPERTY_NAME,
 158                     ((Map) scaleOutPropertyValue).get(Constants.MAX_INSTANCES_PROPERTY_NAME), null, translateTo.getHeatFileName(),
 159                     translateTo.getHeatOrchestrationTemplate(), null, translateTo.getContext());
 160             if (countValue != null) {
 161                 innerProps.put(ToscaConstants.COUNT_PROPERTY_NAME, countValue);
 162             } else {
 163                 innerProps.put(ToscaConstants.COUNT_PROPERTY_NAME, 1);
 164             }
 165         } else {
 166             innerProps.put(ToscaConstants.COUNT_PROPERTY_NAME, 1);
 167         }
 168         return countValue;
 169     }
 170
 171     private void handleServiceScalingProperty(TranslateTo translateTo, Map<String, Object> innerProps, Resource contrailServiceTemplateResource) {
 172         Object serviceScalingPropertyValue = contrailServiceTemplateResource.getProperties().get(HeatConstants.SERVICE_SCALING_PROPERTY_NAME);
 173         Object serviceScalingValue;
 174         if (serviceScalingPropertyValue != null) {
 175             serviceScalingValue = TranslatorHeatToToscaPropertyConverter
 176                 .getToscaPropertyValue(translateTo.getServiceTemplate(), translateTo.getTranslatedId(), HeatConstants.SERVICE_SCALING_PROPERTY_NAME,
 177                     serviceScalingPropertyValue, null, translateTo.getHeatFileName(), translateTo.getHeatOrchestrationTemplate(), null,
 178                     translateTo.getContext());
 179             if (serviceScalingValue != null) {
 180                 innerProps.put(ToscaConstants.SCALING_ENABLED_PROPERTY_NAME,
 181                     (HeatBoolean.isValueBoolean(serviceScalingValue)) ? HeatBoolean.eval(serviceScalingValue) : serviceScalingValue);
 182             }
 183         }
 184     }
 185
 186     private boolean getOrderedInterfaces(Resource contrailServiceTemplate) {
 187         Object orderedInterfaces = contrailServiceTemplate.getProperties().get("ordered_interfaces");
 188         if (orderedInterfaces == null) {
 189             return false;
 190         }
 191         if (orderedInterfaces instanceof String) {
 192             return HeatBoolean.eval(orderedInterfaces);
 193         }
 194         //if get_param, set default value to true
 195         return true;
 196     }
 197
 198     private ServiceTemplate createNestedServiceTemplate(TranslateTo translateTo, String computeNodeTypeId, String substitutedNodeTypeId,
 199                                                         NodeTemplate substitutedNodeTemplate, boolean orderedInterfaces) {
 200         ServiceTemplate nestedSubstitutionServiceTemplate = new ServiceTemplate();
 201         setNestedServiceTemplateGeneralDetails(translateTo, nestedSubstitutionServiceTemplate);
 202         String heatStackGroupKey = addHeatStackGroup(translateTo, nestedSubstitutionServiceTemplate);
 203         addSubstitutionMappingEntry(nestedSubstitutionServiceTemplate, substitutedNodeTypeId);
 204         handleInputParameters(nestedSubstitutionServiceTemplate, translateTo);
 205         String computeNodeTemplateId = handleComputeNodeTemplate(translateTo, computeNodeTypeId, nestedSubstitutionServiceTemplate,
 206             heatStackGroupKey);
 207         handleOutputParameters(nestedSubstitutionServiceTemplate, computeNodeTemplateId, translateTo);
 208         handleServiceInstanceInterfaces(translateTo,
 209             new ContrailServiceInstanceTo(nestedSubstitutionServiceTemplate, substitutedNodeTemplate, heatStackGroupKey, orderedInterfaces,
 210                 computeNodeTemplateId));
 211         return nestedSubstitutionServiceTemplate;
 212     }
 213
 214     private void handleOutputParameters(ServiceTemplate nestedSubstitutionServiceTemplate, String nodeTemplateId, TranslateTo translateTo) {
 215         if (nodeTemplateId == null) {
 216             return;
 217         }
 218         ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
 219         Optional<NodeType> contrailAbstractNodeType = toscaAnalyzerService
 220             .fetchNodeType(ToscaNodeType.CONTRAIL_ABSTRACT_SUBSTITUTE, translateTo.getContext().getGlobalServiceTemplates().values());
 221         if (!contrailAbstractNodeType.isPresent()) {
 222             return;
 223         }
 224         Map<String, AttributeDefinition> contrailAbstractAttributes = contrailAbstractNodeType.get().getAttributes();
 225         Map<String, ParameterDefinition> nestedSubstitutionServiceTemplateOutputs = new HashMap<>();
 226         if (contrailAbstractAttributes == null) {
 227             return;
 228         }
 229         for (Map.Entry<String, AttributeDefinition> attributeDefinitionEntry : contrailAbstractAttributes.entrySet()) {
 230             AttributeDefinition abstractAttributeDef = attributeDefinitionEntry.getValue();
 231             if (abstractAttributeDef != null) {
 232                 Map<String, List> outputValue = new HashMap<>();
 233                 List<String> outputGetAttributeList = new ArrayList<>();
 234                 outputGetAttributeList.add(nodeTemplateId);
 235                 outputGetAttributeList.add(attributeDefinitionEntry.getKey());
 236                 outputValue.put(ToscaFunctions.GET_ATTRIBUTE.getFunctionName(), outputGetAttributeList);
 237                 nestedSubstitutionServiceTemplateOutputs
 238                     .put(attributeDefinitionEntry.getKey(), DataModelUtil.convertAttributeDefToParameterDef(abstractAttributeDef, outputValue));
 239             }
 240         }
 241         if (!nestedSubstitutionServiceTemplateOutputs.isEmpty()) {
 242             nestedSubstitutionServiceTemplate.getTopology_template().setOutputs(nestedSubstitutionServiceTemplateOutputs);
 243         }
 244     }
 245
 246     private void handleServiceInstanceInterfaces(TranslateTo translateTo, ContrailServiceInstanceTo contrailServiceInstanceTo) {
 247         Resource serviceInstanceResource = translateTo.getResource();
 248         Object interfaceListProperty = serviceInstanceResource.getProperties().get(HeatConstants.INTERFACE_LIST_PROPERTY_NAME);
 249         if (interfaceListProperty == null) {
 250             return;
 251         }
 252         if (interfaceListProperty instanceof List) {
 253             for (int index = 0; index < ((List) interfaceListProperty).size(); index++) {
 254                 Object interfaceEntry = ((List) interfaceListProperty).get(index);
 255                 handleInterface(translateTo, interfaceEntry, index, contrailServiceInstanceTo);
 256             }
 257         } else if (interfaceListProperty instanceof Map) {
 258             handleInterface(translateTo, interfaceListProperty, null, contrailServiceInstanceTo);
 259         }
 260     }
 261
 262     private void handleInterface(TranslateTo translateTo, Object interfacePropertyValue, Integer index,
 263                                  ContrailServiceInstanceTo contrailServiceInstanceTo) {
 264         if (index == null) {
 265             index = 0;
 266         }
 267         NodeTemplate portNodeTemplate = createPortNodeTemplate(index, contrailServiceInstanceTo.isOrderedInterfaces(),
 268             contrailServiceInstanceTo.getComputeNodeTemplateId());
 269         String portNodeTemplateId = Constants.SERVICE_INSTANCE_PORT_PREFIX + index;
 270         String portReqMappingKey = Constants.SERVICE_INSTANCE_LINK_PREFIX + portNodeTemplateId;
 271         DataModelUtil.addNodeTemplate(contrailServiceInstanceTo.getNestedSubstitutionServiceTemplate(), portNodeTemplateId, portNodeTemplate);
 272         updateSubstitutionMappingRequirement(contrailServiceInstanceTo.getNestedSubstitutionServiceTemplate(), portReqMappingKey, portNodeTemplateId);
 273         updateHeatStackGroup(contrailServiceInstanceTo.getNestedSubstitutionServiceTemplate(), contrailServiceInstanceTo.getHeatStackGroupKey(),
 274             portNodeTemplateId);
 275         connectPortToNetwork(translateTo, interfacePropertyValue, contrailServiceInstanceTo.getSubstitutedNodeTemplate(), portReqMappingKey);
 276     }
 277
 278     private void connectPortToNetwork(TranslateTo translateTo, Object interfacePropertyValue, NodeTemplate substitutedNodeTemplate,
 279                                       String portReqMappingKey) {
 280         List<String> validNetworksForConnections = ImmutableList.of(HeatResourcesTypes.NEUTRON_NET_RESOURCE_TYPE.getHeatResource(),
 281             HeatResourcesTypes.CONTRAIL_VIRTUAL_NETWORK_RESOURCE_TYPE.getHeatResource());
 282         if (!(interfacePropertyValue instanceof Map)) {
 283             return;
 284         }
 285         Object virtualNetworkValue = ((Map) interfacePropertyValue).get(HeatConstants.VIRTUAL_NETWORK_PROPERTY_NAME);
 286         if (virtualNetworkValue == null) {
 287             logger.warn(LOG_MISSING_VIRTUAL_NETWORK_INTERFACE_LIST, translateTo.getResourceId(), translateTo.getResource().getType());
 288             return;
 289         }
 290         Optional<AttachedResourceId> networkAttachedResourceId = HeatToToscaUtil
 291             .extractAttachedResourceId(translateTo.getHeatFileName(), translateTo.getHeatOrchestrationTemplate(), translateTo.getContext(),
 292                 virtualNetworkValue);
 293         if (!networkAttachedResourceId.isPresent()) {
 294             return;
 295         }
 296         Optional<String> networkResourceId = HeatToToscaUtil.getContrailAttachedHeatResourceId(networkAttachedResourceId.get());
 297         if (networkResourceId.isPresent()) {
 298             Resource networkResource = HeatToToscaUtil
 299                 .getResource(translateTo.getHeatOrchestrationTemplate(), networkResourceId.get(), translateTo.getHeatFileName());
 300             if (validNetworksForConnections.contains(networkResource.getType())) {
 301                 Optional<String> networkTranslatedId = getResourceTranslatedId(translateTo.getHeatFileName(),
 302                     translateTo.getHeatOrchestrationTemplate(), networkResourceId.get(), translateTo.getContext());
 303                 networkTranslatedId
 304                     .ifPresent(translatedId -> addLinkToNetworkRequirementAssignment(substitutedNodeTemplate, translatedId, portReqMappingKey));
 305             } else {
 306                 logger.warn(LOG_UNSUPPORTED_NETWORK_RESOURCE_CONNECTION, translateTo.getResourceId(), translateTo.getResource().getType());
 307             }
 308         } else if (networkAttachedResourceId.get().isGetParam() && networkAttachedResourceId.get().getEntityId() instanceof String) {
 309             TranslatedHeatResource translatedSharedResourceId = translateTo.getContext().getHeatSharedResourcesByParam()
 310                 .get(networkAttachedResourceId.get().getEntityId());
 311             if (Objects.nonNull(translatedSharedResourceId) && !HeatToToscaUtil.isHeatFileNested(translateTo, translateTo.getHeatFileName())) {
 312                 addLinkToNetworkRequirementAssignment(substitutedNodeTemplate, translatedSharedResourceId.getTranslatedId(), portReqMappingKey);
 313             }
 314         } else {
 315             logger.warn(LOG_INVALID_NETWORK_CONNECTION, translateTo.getResourceId(), translateTo.getResource().getType(),
 316                 virtualNetworkValue.toString());
 317         }
 318     }
 319
 320     private NodeTemplate createPortNodeTemplate(Integer index, boolean orderedInterfaces, String computeNodeTemplateId) {
 321         NodeTemplate portNodeTemplate = new NodeTemplate();
 322         portNodeTemplate.setType(ToscaNodeType.CONTRAIL_PORT);
 323         Map<String, Object> portProperties = new HashMap<>();
 324         portProperties.put("static_routes", DataModelUtil.createGetInputPropertyValueFromListParameter(INTERFACE_LIST, index, "static_routes"));
 325         portProperties.put("virtual_network", DataModelUtil.createGetInputPropertyValueFromListParameter(INTERFACE_LIST, index, "virtual_network"));
 326         portProperties
 327             .put("allowed_address_pairs", DataModelUtil.createGetInputPropertyValueFromListParameter(INTERFACE_LIST, index, "allowed_address_pairs"));
 328         portProperties.put("ip_address", DataModelUtil.createGetInputPropertyValueFromListParameter(INTERFACE_LIST, index, "ip_address"));
 329         portProperties.put("static_route", DataModelUtil.createGetInputPropertyValueFromListParameter("static_routes_list", index));
 330         portProperties.put("shared_ip", DataModelUtil.createGetInputPropertyValueFromListParameter("shared_ip_list", index));
 331         portProperties.put("interface_type", DataModelUtil.createGetInputPropertyValueFromListParameter("service_interface_type_list", index));
 332         if (orderedInterfaces) {
 333             portProperties.put("order", index);
 334         }
 335         portNodeTemplate.setProperties(portProperties);
 336         DataModelUtil.addBindingReqFromPortToCompute(computeNodeTemplateId, portNodeTemplate);
 337         return portNodeTemplate;
 338     }
 339
 340     private void addLinkToNetworkRequirementAssignment(NodeTemplate nodeTemplate, String connectedNodeTranslatedId, String requirementId) {
 341         if (nodeTemplate == null || connectedNodeTranslatedId == null) {
 342             return;
 343         }
 344         RequirementAssignment requirement = new RequirementAssignment();
 345         requirement.setCapability(ToscaCapabilityType.NATIVE_NETWORK_LINKABLE);
 346         requirement.setRelationship(ToscaRelationshipType.NATIVE_NETWORK_LINK_TO);
 347         requirement.setNode(connectedNodeTranslatedId);
 348         DataModelUtil.addRequirementAssignment(nodeTemplate, requirementId, requirement);
 349     }
 350
 351     private void updateHeatStackGroup(ServiceTemplate serviceTemplate, String heatStackGroupKey, String memberId) {
 352         serviceTemplate.getTopology_template().getGroups().get(heatStackGroupKey).getMembers().add(memberId);
 353     }
 354
 355     private void updateSubstitutionMappingRequirement(ServiceTemplate serviceTemplate, String portReqMappingKey, String portNodeTemplateId) {
 356         List<String> portReqMappingValue = new ArrayList<>();
 357         portReqMappingValue.add(portNodeTemplateId);
 358         portReqMappingValue.add(ToscaConstants.LINK_REQUIREMENT_ID);
 359         DataModelUtil.addSubstitutionMappingReq(serviceTemplate, portReqMappingKey, portReqMappingValue);
 360     }
 361
 362     private void addSubstitutionMappingEntry(ServiceTemplate nestedSubstitutionServiceTemplate, String substitutedNodeTypeId) {
 363         SubstitutionMapping substitutionMappings = new SubstitutionMapping();
 364         substitutionMappings.setNode_type(substitutedNodeTypeId);
 365         DataModelUtil.addSubstitutionMapping(nestedSubstitutionServiceTemplate, substitutionMappings);
 366     }
 367
 368     private void handleInputParameters(ServiceTemplate nestedSubstitutionServiceTemplate, TranslateTo translateTo) {
 369         ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
 370         Optional<NodeType> contrailAbstractNodeType = toscaAnalyzerService
 371             .fetchNodeType(ToscaNodeType.CONTRAIL_ABSTRACT_SUBSTITUTE, translateTo.getContext().getGlobalServiceTemplates().values());
 372         Map<String, ParameterDefinition> nestedSubstitutionServiceTemplateInputs = new HashMap<>();
 373         if (contrailAbstractNodeType.isPresent()) {
 374             Map<String, PropertyDefinition> contrailAbstractProperties = contrailAbstractNodeType.get().getProperties();
 375             for (Map.Entry<String, PropertyDefinition> propertyEntry : contrailAbstractProperties.entrySet()) {
 376                 PropertyDefinition abstractPropertyDef = contrailAbstractProperties.get(propertyEntry.getKey());
 377                 if (abstractPropertyDef != null) {
 378                     nestedSubstitutionServiceTemplateInputs
 379                         .put(propertyEntry.getKey(), DataModelUtil.convertPropertyDefToParameterDef(abstractPropertyDef));
 380                 }
 381             }
 382         }
 383         if (!nestedSubstitutionServiceTemplateInputs.isEmpty()) {
 384             nestedSubstitutionServiceTemplate.getTopology_template().setInputs(nestedSubstitutionServiceTemplateInputs);
 385         }
 386     }
 387
 388     private String handleComputeNodeTemplate(TranslateTo translateTo, String computeNodeTypeId, ServiceTemplate nestedSubstitutionServiceTemplate,
 389                                              String heatStackGroupKey) {
 390         ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
 391         Optional<NodeType> contrailComputeNodeType = toscaAnalyzerService
 392             .fetchNodeType(ToscaNodeType.CONTRAIL_COMPUTE, translateTo.getContext().getGlobalServiceTemplates().values());
 393         Map<String, Object> computeNodeTemplateProperties = null;
 394         if (contrailComputeNodeType.isPresent()) {
 395             Map<String, PropertyDefinition> contrailComputeProperties = contrailComputeNodeType.get().getProperties();
 396             computeNodeTemplateProperties = new HashMap<>();
 397             if (contrailComputeProperties != null) {
 398                 for (String computePropertyKey : contrailComputeProperties.keySet()) {
 399                     Map<String, Object> getInputProperty = new HashMap<>();
 400                     getInputProperty.put(ToscaFunctions.GET_INPUT.getFunctionName(), computePropertyKey);
 401                     computeNodeTemplateProperties.put(computePropertyKey, getInputProperty);
 402                 }
 403             }
 404         }
 405         NodeTemplate computeNodeTemplate = new NodeTemplate();
 406         computeNodeTemplate.setType(computeNodeTypeId);
 407         if (computeNodeTemplateProperties != null && !computeNodeTemplateProperties.isEmpty()) {
 408             computeNodeTemplate.setProperties(computeNodeTemplateProperties);
 409         }
 410         String computeNodeTemplateId = translateTo.getTranslatedId();
 411         DataModelUtil.addNodeTemplate(nestedSubstitutionServiceTemplate, computeNodeTemplateId, computeNodeTemplate);
 412         nestedSubstitutionServiceTemplate.getTopology_template().getGroups().get(heatStackGroupKey).getMembers().add(computeNodeTemplateId);
 413         return computeNodeTemplateId;
 414     }
 415
 416     private String addHeatStackGroup(TranslateTo translateTo, ServiceTemplate serviceTemplate) {
 417         GroupDefinition serviceInstanceGroupDefinition = new GroupDefinition();
 418         serviceInstanceGroupDefinition.setType(ToscaGroupType.HEAT_STACK);
 419         Map<String, Object> groupProperties = new HashMap<>();
 420         groupProperties
 421             .put("heat_file", "../" + (new ToscaFileOutputServiceCsarImpl()).getArtifactsFolderName() + "/" + translateTo.getHeatFileName());
 422         serviceInstanceGroupDefinition.setProperties(groupProperties);
 423         serviceInstanceGroupDefinition.setMembers(new ArrayList<>());
 424         String heatStackGroupKey = translateTo.getTranslatedId() + "_group";
 425         DataModelUtil.addGroupDefinitionToTopologyTemplate(serviceTemplate, heatStackGroupKey, serviceInstanceGroupDefinition);
 426         return heatStackGroupKey;
 427     }
 428
 429     private void setNestedServiceTemplateGeneralDetails(TranslateTo translateTo, ServiceTemplate nestedSubstitutionServiceTemplate) {
 430         Map<String, String> nestedTemplateMetadata = new HashMap<>();
 431         String nestedTemplateName = new ContrailTranslationHelper()
 432             .getSubstitutionContrailServiceTemplateMetadata(translateTo.getHeatFileName(), translateTo.getResourceId());
 433         nestedTemplateMetadata.put(ToscaConstants.ST_METADATA_TEMPLATE_NAME, nestedTemplateName);
 434         nestedSubstitutionServiceTemplate.setMetadata(nestedTemplateMetadata);
 435         nestedSubstitutionServiceTemplate.setTosca_definitions_version(ToscaConstants.TOSCA_DEFINITIONS_VERSION);
 436         nestedSubstitutionServiceTemplate.setTopology_template(new TopologyTemplate());
 437         List<Map<String, Import>> globalTypesImportList = GlobalTypesGenerator.getGlobalTypesImportList();
 438         globalTypesImportList.addAll(HeatToToscaUtil.createImportList(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME));
 439         nestedSubstitutionServiceTemplate.setImports(globalTypesImportList);
 440     }
 441
 442     private NodeTemplate createSubstitutedNodeTemplate(TranslateTo translateTo, Resource contrailServiceTemplateResource,
 443                                                        String contrailServiceTemplateTranslatedId, int numberOfPorts) {
 444         boolean isImportAddedToServiceTemplate = DataModelUtil
 445             .isImportAddedToServiceTemplate(translateTo.getServiceTemplate().getImports(), Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME);
 446         if (!isImportAddedToServiceTemplate) {
 447             translateTo.getServiceTemplate().getImports().addAll(HeatToToscaUtil.createImportList(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME));
 448         }
 449         NodeTemplate substitutesNodeTemplate = new NodeTemplate();
 450         substitutesNodeTemplate.setType(contrailServiceTemplateTranslatedId);
 451         List<String> directiveList = new ArrayList<>();
 452         directiveList.add(ToscaConstants.NODE_TEMPLATE_DIRECTIVE_SUBSTITUTABLE);
 453         substitutesNodeTemplate.setDirectives(directiveList);
 454         substitutesNodeTemplate.setProperties(TranslatorHeatToToscaPropertyConverter
 455             .getToscaPropertiesSimpleConversion(translateTo.getServiceTemplate(), translateTo.getResourceId(),
 456                 translateTo.getResource().getProperties(), substitutesNodeTemplate.getProperties(), translateTo.getHeatFileName(),
 457                 translateTo.getHeatOrchestrationTemplate(), HeatResourcesTypes.CONTRAIL_SERVICE_INSTANCE.getHeatResource(), substitutesNodeTemplate,
 458                 translateTo.getContext()));
 459         substitutesNodeTemplate.setProperties(TranslatorHeatToToscaPropertyConverter
 460             .getToscaPropertiesSimpleConversion(translateTo.getServiceTemplate(), translateTo.getResourceId(),
 461                 contrailServiceTemplateResource.getProperties(), substitutesNodeTemplate.getProperties(), translateTo.getHeatFileName(),
 462                 translateTo.getHeatOrchestrationTemplate(), HeatResourcesTypes.CONTRAIL_SERVICE_TEMPLATE.getHeatResource(), substitutesNodeTemplate,
 463                 translateTo.getContext()));
 464         HeatToToscaUtil.mapBoolean(substitutesNodeTemplate, HeatToToscaUtil
 465             .getToscaPropertyName(translateTo.getContext(), contrailServiceTemplateResource.getType(),
 466                 HeatConstants.AVAILABILITY_ZONE_ENABLE_PROPERTY_NAME));
 467         HeatToToscaUtil.mapBoolean(substitutesNodeTemplate, HeatToToscaUtil
 468             .getToscaPropertyName(translateTo.getContext(), contrailServiceTemplateResource.getType(),
 469                 HeatConstants.ORDERED_INTERFACES_PROPERTY_NAME));
 470         Object sharedIpListPropertyValue = contrailServiceTemplateResource.getProperties().get(HeatConstants.SHARED_IP_LIST_PROPERTY_NAME);
 471         String toscaSharedIpListPropertyName = HeatToToscaUtil
 472             .getToscaPropertyName(translateTo.getContext(), contrailServiceTemplateResource.getType(), HeatConstants.SHARED_IP_LIST_PROPERTY_NAME);
 473         Optional<List<Map<String, List>>> sharedIpTranslatedSplitFun = new ContrailTranslationHelper()
 474             .translateFnSplitFunction(sharedIpListPropertyValue, numberOfPorts, true);
 475         if (sharedIpTranslatedSplitFun.isPresent()) {
 476             substitutesNodeTemplate.getProperties().put(toscaSharedIpListPropertyName, sharedIpTranslatedSplitFun.get());
 477         } else {
 478             HeatToToscaUtil.mapBooleanList(substitutesNodeTemplate, toscaSharedIpListPropertyName);
 479         }
 480         Object staticRouteListPropertyValue = contrailServiceTemplateResource.getProperties().get(HeatConstants.STATIC_ROUTES_LIST_PROPERTY_NAME);
 481         String toscaStaticRoutesListPropertyName = HeatToToscaUtil
 482             .getToscaPropertyName(translateTo.getContext(), contrailServiceTemplateResource.getType(),
 483                 HeatConstants.STATIC_ROUTES_LIST_PROPERTY_NAME);
 484         Optional<List<Map<String, List>>> staticRouteTranslatedSplitFun = new ContrailTranslationHelper()
 485             .translateFnSplitFunction(staticRouteListPropertyValue, numberOfPorts, true);
 486         if (staticRouteTranslatedSplitFun.isPresent()) {
 487             substitutesNodeTemplate.getProperties().put(toscaStaticRoutesListPropertyName, staticRouteTranslatedSplitFun.get());
 488         } else {
 489             HeatToToscaUtil.mapBooleanList(substitutesNodeTemplate, toscaStaticRoutesListPropertyName);
 490         }
 491         Object serviceInterfaceTypeListPropertyValue = contrailServiceTemplateResource.getProperties()
 492             .get(HeatConstants.SERVICE_INTERFCAE_TYPE_LIST_PROPERTY_NAME);
 493         String toscaServiceInterfaceTypeListPropertyName = HeatToToscaUtil
 494             .getToscaPropertyName(translateTo.getContext(), contrailServiceTemplateResource.getType(),
 495                 HeatConstants.SERVICE_INTERFCAE_TYPE_LIST_PROPERTY_NAME);
 496         Optional<List<Map<String, List>>> serviceInterfaceTypeTranslatedSplitFun = new ContrailTranslationHelper()
 497             .translateFnSplitFunction(serviceInterfaceTypeListPropertyValue, numberOfPorts, false);
 498         serviceInterfaceTypeTranslatedSplitFun.ifPresent(
 499             translatedSplitFun -> substitutesNodeTemplate.getProperties().put(toscaServiceInterfaceTypeListPropertyName, translatedSplitFun));
 500         String substitutedNodeTemplateId = translateTo.getTranslatedId();
 501         DataModelUtil.addNodeTemplate(translateTo.getServiceTemplate(), substitutedNodeTemplateId, substitutesNodeTemplate);
 502         return substitutesNodeTemplate;
 503     }
 504
 505     private void addNetworkLinkRequirements(NodeType nodeType, int numberOfPorts) {
 506         if (nodeType.getRequirements() == null) {
 507             List<Map<String, RequirementDefinition>> requirementList = new ArrayList<>();
 508             for (int i = 0; i < numberOfPorts; i++) {
 509                 Map<String, RequirementDefinition> requirementDefinitionMap = new HashMap<>();
 510                 requirementDefinitionMap.put(ToscaConstants.LINK_REQUIREMENT_ID + "_port_" + i, DataModelUtil
 511                     .createRequirement(ToscaCapabilityType.NATIVE_NETWORK_LINKABLE, ToscaNodeType.NATIVE_ROOT,
 512                         ToscaRelationshipType.NATIVE_NETWORK_LINK_TO, null));
 513                 requirementList.add(requirementDefinitionMap);
 514             }
 515             if (numberOfPorts > 0) {
 516                 nodeType.setRequirements(requirementList);
 517             }
 518         }
 519     }
 520
 521     private int getServiceInstanceNumberOfPorts(Resource serviceInstanceResource) {
 522         int numberOfPorts;
 523         Object interfaceTypeProperty = serviceInstanceResource.getProperties().get(HeatConstants.INTERFACE_LIST_PROPERTY_NAME);
 524         if (interfaceTypeProperty == null) {
 525             numberOfPorts = 0;
 526         } else if (interfaceTypeProperty instanceof List) {
 527             numberOfPorts = ((List) interfaceTypeProperty).size();
 528         } else if (interfaceTypeProperty instanceof Map) {
 529             numberOfPorts = 1;
 530         } else {
 531             numberOfPorts = 0;
 532         }
 533         return numberOfPorts;
 534     }
 535
 536     private AttachedResourceId getServiceTemplateAttachedId(TranslateTo translateTo, Resource serviceInstanceResource) {
 537         Object serviceTemplateProperty = serviceInstanceResource.getProperties().get("service_template");
 538         Optional<AttachedResourceId> serviceTemplateId = HeatToToscaUtil
 539             .extractAttachedResourceId(translateTo.getHeatFileName(), translateTo.getHeatOrchestrationTemplate(), translateTo.getContext(),
 540                 serviceTemplateProperty);
 541         if (serviceTemplateId.isPresent()) {
 542             return serviceTemplateId.get();
 543         } else {
 544             throw new CoreException(new MissingMandatoryPropertyErrorBuilder("service_template").build());
 545         }
 546     }
 547 }