gerrit.onap Code Review - sdc.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   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
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  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=========================================================
  19  */
  20
  21 package org.openecomp.sdc.vendorsoftwareproduct.services.impl.composition;
  22
  23 import com.fasterxml.jackson.databind.ObjectMapper;
  24 import org.apache.commons.collections4.CollectionUtils;
  25 import org.apache.commons.collections4.MapUtils;
  26 import org.openecomp.sdc.common.errors.CoreException;
  27 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  28 import org.openecomp.sdc.logging.api.Logger;
  29 import org.openecomp.sdc.logging.api.LoggerFactory;
  30 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
  31 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
  32 import org.openecomp.sdc.logging.types.LoggerConstants;
  33 import org.openecomp.sdc.logging.types.LoggerErrorCode;
  34 import org.openecomp.sdc.logging.types.LoggerErrorDescription;
  35 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
  36 import org.openecomp.sdc.tosca.datatypes.ToscaCapabilityType;
  37 import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
  38 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
  39 import org.openecomp.sdc.tosca.datatypes.ToscaRelationshipType;
  40 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
  41 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
  42 import org.openecomp.sdc.tosca.datatypes.model.ParameterDefinition;
  43 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
  44 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
  45 import org.openecomp.sdc.tosca.errors.ToscaInvalidEntryNotFoundErrorBuilder;
  46 import org.openecomp.sdc.tosca.errors.ToscaInvalidSubstituteNodeTemplateErrorBuilder;
  47 import org.openecomp.sdc.tosca.errors.ToscaMissingSubstitutionMappingForReqCapErrorBuilder;
  48 import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
  49 import org.openecomp.sdc.tosca.services.ToscaConstants;
  50 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
  51 import org.openecomp.sdc.tosca.services.ToscaExtensionYamlUtil;
  52 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionDataExtractor;
  53 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Component;
  54 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentData;
  55 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionData;
  56 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComputeData;
  57 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ExtractCompositionDataContext;
  58 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Image;
  59 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Network;
  60 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
  61
  62 import java.util.ArrayList;
  63 import java.util.HashMap;
  64 import java.util.List;
  65 import java.util.Map;
  66 import java.util.Objects;
  67 import java.util.Optional;
  68 import java.util.stream.Collectors;
  69
  70 public class CompositionDataExtractorImpl implements CompositionDataExtractor {
  71
  72   protected static Logger logger;
  73   private static ToscaAnalyzerService toscaAnalyzerService;
  74   private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
  75
  76   static {
  77     logger = LoggerFactory.getLogger(CompositionDataExtractorImpl.class);
  78     toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
  79   }
  80
  81   /**
  82    * Extract service composition data composition data.
  83    *
  84    * @param toscaServiceModel the tosca service model
  85    * @return the composition data
  86    */
  87   public CompositionData extractServiceCompositionData(ToscaServiceModel toscaServiceModel) {
  88
  89
  90     mdcDataDebugMessage.debugEntryMessage(null);
  91
  92     ExtractCompositionDataContext context = new ExtractCompositionDataContext();
  93     String entryDefinitionServiceTemplateFileName =
  94         toscaServiceModel.getEntryDefinitionServiceTemplate();
  95     ServiceTemplate entryDefinitionServiceTemplate =
  96         toscaServiceModel.getServiceTemplates().get(entryDefinitionServiceTemplateFileName);
  97     extractServiceCompositionData(entryDefinitionServiceTemplateFileName,
  98         entryDefinitionServiceTemplate, toscaServiceModel, context);
  99
 100     CompositionData compositionData = new CompositionData();
 101     compositionData.setNetworks(context.getNetworks());
 102     compositionData.setComponents(context.getComponents());
 103
 104     mdcDataDebugMessage.debugExitMessage(null);
 105     return compositionData;
 106   }
 107
 108   private void extractServiceCompositionData(String serviceTemplateFileName,
 109                                                     ServiceTemplate serviceTemplate,
 110                                                     ToscaServiceModel toscaServiceModel,
 111                                                     ExtractCompositionDataContext context) {
 112     if (context.getHandledServiceTemplates().contains(serviceTemplateFileName)) {
 113       return;
 114     }
 115     context.addNetworks(extractNetworks(serviceTemplate, toscaServiceModel));
 116     extractComponents(serviceTemplate, toscaServiceModel, context);
 117     handleSubstitution(serviceTemplate, toscaServiceModel, context);
 118     context.addHandledServiceTemplates(serviceTemplateFileName);
 119   }
 120
 121   private void handleSubstitution(ServiceTemplate serviceTemplate,
 122                                          ToscaServiceModel toscaServiceModel,
 123                                          ExtractCompositionDataContext context) {
 124
 125
 126     mdcDataDebugMessage.debugEntryMessage(null);
 127
 128     Map<String, NodeTemplate> substitutableNodeTemplates =
 129         toscaAnalyzerService.getSubstitutableNodeTemplates(serviceTemplate);
 130
 131     if (substitutableNodeTemplates != null) {
 132       for (String substitutableNodeTemplateId : substitutableNodeTemplates.keySet()) {
 133         handleSubstitutableNodeTemplate(serviceTemplate, toscaServiceModel,
 134             substitutableNodeTemplateId,
 135             substitutableNodeTemplates.get(substitutableNodeTemplateId), context);
 136       }
 137     }
 138
 139     mdcDataDebugMessage.debugExitMessage(null);
 140   }
 141
 142   private void handleSubstitutableNodeTemplate(ServiceTemplate serviceTemplate,
 143                                                       ToscaServiceModel toscaServiceModel,
 144                                                       String substitutableNodeTemplateId,
 145                                                       NodeTemplate substitutableNodeTemplate,
 146                                                       ExtractCompositionDataContext context) {
 147
 148
 149     mdcDataDebugMessage.debugEntryMessage(null);
 150
 151     ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 152     Optional<String> substituteServiceTemplateFileName = toscaAnalyzerService
 153         .getSubstituteServiceTemplateName(substitutableNodeTemplateId, substitutableNodeTemplate);
 154     if (!substituteServiceTemplateFileName.isPresent()) {
 155       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
 156           LoggerTragetServiceName.EXTRACT_COMPOSITION_DATA, ErrorLevel.ERROR.name(),
 157           LoggerErrorCode.DATA_ERROR.getErrorCode(),
 158           LoggerErrorDescription.EXTRACT_COMPOSITION_DATA);
 159       throw new CoreException(
 160           new ToscaInvalidSubstituteNodeTemplateErrorBuilder(substitutableNodeTemplateId).build());
 161     }
 162     if (context.getHandledServiceTemplates().contains(substituteServiceTemplateFileName.get())) {
 163       //each substitution is should be handled once, and will get the connection to the upper
 164       // service level according to the first one which was processed
 165       mdcDataDebugMessage.debugExitMessage(null);
 166       return;
 167     }
 168
 169     ServiceTemplate substituteServiceTemplate =
 170         toscaServiceModel.getServiceTemplates().get(substituteServiceTemplateFileName.get());
 171     extractServiceCompositionData(substituteServiceTemplateFileName.get(),
 172         substituteServiceTemplate, toscaServiceModel, context);
 173
 174     List<Map<String, RequirementAssignment>> substitutableRequirements =
 175         substitutableNodeTemplate.getRequirements();
 176
 177     if (CollectionUtils.isEmpty(substitutableRequirements)) {
 178       mdcDataDebugMessage.debugExitMessage(null);
 179       return;
 180     }
 181
 182     for (Map<String, RequirementAssignment> substitutableReq : substitutableRequirements) {
 183       substitutableReq.keySet().stream().filter(reqId -> {
 184         RequirementAssignment reqAssignment = toscaExtensionYamlUtil
 185             .yamlToObject(toscaExtensionYamlUtil.objectToYaml(substitutableReq.get(reqId)),
 186                 RequirementAssignment.class);
 187
 188         mdcDataDebugMessage.debugExitMessage(null);
 189         return isLinkToNetworkRequirementAssignment(reqAssignment);
 190       }).forEach(reqId -> {
 191         RequirementAssignment linkToNetworkRequirement = toscaExtensionYamlUtil
 192             .yamlToObject(toscaExtensionYamlUtil.objectToYaml(substitutableReq.get(reqId)),
 193                 RequirementAssignment.class);
 194         String connectedNodeId = linkToNetworkRequirement.getNode();
 195         Optional<NodeTemplate> connectedNodeTemplate =
 196             toscaAnalyzerService.getNodeTemplateById(serviceTemplate, connectedNodeId);
 197
 198         if (connectedNodeTemplate.isPresent() && toscaAnalyzerService
 199             .isTypeOf(connectedNodeTemplate.get(), ToscaNodeType.NATIVE_NETWORK,
 200                 serviceTemplate, toscaServiceModel)) {
 201           Optional<Map.Entry<String, NodeTemplate>> mappedNodeTemplate = toscaAnalyzerService
 202               .getSubstitutionMappedNodeTemplateByExposedReq(
 203                   substituteServiceTemplateFileName.get(), substituteServiceTemplate, reqId);
 204           if (!mappedNodeTemplate.isPresent()) {
 205             MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
 206                 LoggerTragetServiceName.EXTRACT_COMPOSITION_DATA, ErrorLevel.ERROR.name(),
 207                 LoggerErrorCode.DATA_ERROR.getErrorCode(),
 208                 LoggerErrorDescription.EXTRACT_COMPOSITION_DATA);
 209             throw new CoreException(new ToscaMissingSubstitutionMappingForReqCapErrorBuilder(
 210                 ToscaMissingSubstitutionMappingForReqCapErrorBuilder.MappingExposedEntry
 211                     .REQUIREMENT, connectedNodeId).build());
 212           }
 213
 214           if (toscaAnalyzerService.isTypeOf(mappedNodeTemplate.get().getValue(),
 215               ToscaNodeType.NATIVE_NETWORK_PORT, serviceTemplate,
 216               toscaServiceModel)) {
 217             Nic port = context.getNics().get(mappedNodeTemplate.get().getKey());
 218             if (port != null) {
 219               port.setNetworkName(connectedNodeId);
 220             } else {
 221               logger.warn(
 222                   "Different ports define for the same component which is used in different "
 223                       + "substitution service templates.");
 224             }
 225           }
 226         } else if (!connectedNodeTemplate.isPresent()) {
 227           MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
 228               LoggerTragetServiceName.EXTRACT_COMPOSITION_DATA, ErrorLevel.ERROR.name(),
 229               LoggerErrorCode.DATA_ERROR.getErrorCode(),
 230               LoggerErrorDescription.EXTRACT_COMPOSITION_DATA);
 231           throw new CoreException(
 232               new ToscaInvalidEntryNotFoundErrorBuilder("Node Template", connectedNodeId).build());
 233         }
 234       });
 235     }
 236   }
 237
 238   private boolean isLinkToNetworkRequirementAssignment(RequirementAssignment requirement) {
 239     return toscaAnalyzerService.isDesiredRequirementAssignment(requirement,
 240         ToscaCapabilityType.NATIVE_NETWORK_LINKABLE, null,
 241         ToscaRelationshipType.NATIVE_NETWORK_LINK_TO);
 242   }
 243
 244
 245   private void connectPortToNetwork(Nic port, NodeTemplate portNodeTemplate) {
 246
 247
 248     mdcDataDebugMessage.debugEntryMessage(null);
 249
 250     List<RequirementAssignment> linkRequirementsToNetwork =
 251         toscaAnalyzerService.getRequirements(portNodeTemplate, ToscaConstants.LINK_REQUIREMENT_ID);
 252
 253     //port is connected to one network
 254     for (RequirementAssignment linkRequirementToNetwork : linkRequirementsToNetwork) {
 255       port.setNetworkName(linkRequirementToNetwork.getNode());
 256     }
 257
 258     mdcDataDebugMessage.debugExitMessage(null);
 259   }
 260
 261   /*
 262   return Map with key - compute node template id, value - list of connected port node template id
 263    */
 264   private Map<String, List<String>> getComputeToPortsConnection(
 265       Map<String, NodeTemplate> portNodeTemplates) {
 266
 267
 268     mdcDataDebugMessage.debugEntryMessage(null);
 269
 270     Map<String, List<String>> computeToPortConnection = new HashMap<>();
 271     if (MapUtils.isEmpty(portNodeTemplates)) {
 272       return computeToPortConnection;
 273     }
 274     for (String portId : portNodeTemplates.keySet()) {
 275       List<RequirementAssignment> bindingRequirementsToCompute = toscaAnalyzerService
 276           .getRequirements(portNodeTemplates.get(portId), ToscaConstants.BINDING_REQUIREMENT_ID);
 277       for (RequirementAssignment bindingRequirementToCompute : bindingRequirementsToCompute) {
 278         computeToPortConnection
 279             .putIfAbsent(bindingRequirementToCompute.getNode(), new ArrayList<>());
 280         computeToPortConnection.get(bindingRequirementToCompute.getNode()).add(portId);
 281       }
 282     }
 283
 284     mdcDataDebugMessage.debugExitMessage(null);
 285     return computeToPortConnection;
 286   }
 287
 288   private void extractComponents(ServiceTemplate serviceTemplate,
 289                                         ToscaServiceModel toscaServiceModel,
 290                                         ExtractCompositionDataContext context) {
 291
 292
 293     mdcDataDebugMessage.debugEntryMessage(null);
 294
 295     Map<String, NodeTemplate> computeNodeTemplates = toscaAnalyzerService
 296         .getNodeTemplatesByType(serviceTemplate, ToscaNodeType.NATIVE_COMPUTE,
 297             toscaServiceModel);
 298     if (MapUtils.isEmpty(computeNodeTemplates)) {
 299       return;
 300     }
 301     Map<String, List<String>> imageNodeTemplates = getComponentImages(computeNodeTemplates,
 302         toscaServiceModel);
 303     Map<String, List<String>> computeFlavorNodeTemplates =
 304         getComponentComputeFlavor(computeNodeTemplates, toscaServiceModel);
 305     Map<String, NodeTemplate> portNodeTemplates = toscaAnalyzerService
 306         .getNodeTemplatesByType(serviceTemplate, ToscaNodeType.NATIVE_NETWORK_PORT,
 307             toscaServiceModel);
 308     Map<String, List<String>> computeToPortsConnection =
 309         getComputeToPortsConnection(portNodeTemplates);
 310     Map<String, List<String>> computesGroupedByType =
 311         getNodeTemplatesGroupedByType(computeNodeTemplates);
 312
 313     computesGroupedByType.keySet()
 314         .stream()
 315         .filter(nodeType ->
 316             !context.getCreatedComponents().contains(nodeType))
 317         .forEach(nodeType -> extractComponent(serviceTemplate, computeToPortsConnection,
 318             computesGroupedByType, imageNodeTemplates, computeFlavorNodeTemplates, nodeType,
 319             context));
 320
 321     mdcDataDebugMessage.debugExitMessage(null);
 322   }
 323
 324   private Map<String,List<String>> getComponentImages(Map<String, NodeTemplate>
 325                                                           computeNodeTemplates,
 326                                                       ToscaServiceModel toscaServiceModel) {
 327     Map<String,List<String>> computeImages = new HashMap<>();
 328     for (String component : computeNodeTemplates.keySet()) {
 329       List<String> images = new ArrayList<>();
 330       Map<String,Object> properties =  computeNodeTemplates.get(component).getProperties();
 331
 332       List<Object> imagesList = properties.entrySet()
 333           .stream()
 334           .filter(map -> map.getKey().equals("image"))
 335           .map(map -> map.getValue())
 336           .collect(Collectors.toList());
 337       for (Object obj : imagesList) {
 338         if (obj instanceof String) {
 339           images.add((String) obj);
 340         } else {
 341           Map<String,String> objMap = new ObjectMapper().convertValue(obj,Map.class);
 342           images.add(getInputs(toscaServiceModel,objMap.get("get_input")));
 343         }
 344       }
 345       computeImages.put(component,images);
 346     }
 347     return computeImages;
 348   }
 349
 350   private Map<String,List<String>> getComponentComputeFlavor(Map<String, NodeTemplate>
 351                                                                  computeNodeTemplates,
 352                                                              ToscaServiceModel toscaServiceModel) {
 353     Map<String,List<String>> componentComputeFlavor = new HashMap<>();
 354     for (String component : computeNodeTemplates.keySet()) {
 355       List<String> computes = new ArrayList<>();
 356       Map<String,Object> properties =  computeNodeTemplates.get(component).getProperties();
 357
 358       List<Object> computessList = properties.entrySet()
 359           .stream()
 360           .filter(map -> map.getKey().equals("flavor"))
 361           .map(map -> map.getValue())
 362           .collect(Collectors.toList());
 363       for (Object obj : computessList) {
 364         if (obj instanceof String) {
 365           computes.add((String) obj);
 366         } else {
 367           Map<String, String> objMap = new ObjectMapper().convertValue(obj, Map.class);
 368           computes.add(getInputs(toscaServiceModel, objMap.get("get_input")));
 369         }
 370       }
 371       componentComputeFlavor.put(component,computes);
 372     }
 373     return componentComputeFlavor;
 374   }
 375
 376   private String  getInputs(ToscaServiceModel toscaServiceModel, String inputValue) {
 377     String mainTemplate = toscaServiceModel.getEntryDefinitionServiceTemplate();
 378     List<ServiceTemplate> toscaServiceTemplates = toscaServiceModel.getServiceTemplates().entrySet()
 379         .stream()
 380         .filter(map -> map.getKey().equals(mainTemplate))
 381         .map(map -> map.getValue())
 382         .collect(Collectors.toList());
 383     ServiceTemplate serviceTemplate = toscaServiceTemplates.get(0);
 384
 385     if (Objects.nonNull(serviceTemplate.getTopology_template())
 386         && MapUtils.isNotEmpty(serviceTemplate.getTopology_template().getInputs())) {
 387       for (Map.Entry<String, ParameterDefinition> inputEntry : serviceTemplate
 388           .getTopology_template().getInputs().entrySet()) {
 389         if (inputEntry.getKey().equals(inputValue)) {
 390           String value;
 391           try {
 392             value= (String) inputEntry.getValue().get_default();
 393           } catch (Exception e) {
 394             logger.debug(e.getMessage(), e);
 395             value = inputEntry.getValue().get_default().toString();
 396           }
 397         return value;
 398         }
 399       }
 400     }
 401     return inputValue;
 402   }
 403
 404   private void extractComponent(ServiceTemplate serviceTemplate,
 405                                        Map<String, List<String>> computeToPortsConnection,
 406                                        Map<String, List<String>> computesGroupedByType,
 407                                        Map<String, List<String>> imageList,
 408                                        Map<String, List<String>> computeFlavorNodeTemplates,
 409                                        String computeNodeType,
 410                                        ExtractCompositionDataContext context) {
 411     ComponentData component = new ComponentData();
 412     component.setName(computeNodeType);
 413     component.setDisplayName(getComponentDisplayName(component.getName()));
 414     component.setVfcCode(component.getDisplayName());
 415     Component componentModel = new Component();
 416     componentModel.setData(component);
 417
 418     String computeId = computesGroupedByType.get(computeNodeType).get(0);
 419     List<String> connectedPortIds = computeToPortsConnection.get(computeId);
 420     List<String> images = imageList.get(computeId);
 421     List<String> computeFlavors = computeFlavorNodeTemplates.get(computeId);
 422
 423     if (connectedPortIds != null) {
 424       componentModel.setNics(new ArrayList<>());
 425       componentModel.setImages(new ArrayList<>());
 426       componentModel.setCompute(new ArrayList<>());
 427       for (String portId : connectedPortIds) {
 428         Nic port = extractPort(serviceTemplate, portId);
 429         componentModel.getNics().add(port);
 430         context.addNic(portId, port);
 431       }
 432       for (String image : images) {
 433         Image img = new Image(image);
 434         componentModel.getImages().add(img);
 435         context.addImage(image, img);
 436       }
 437       for (String flavor : computeFlavors) {
 438         ComputeData computeFlavor = new ComputeData(flavor);
 439         componentModel.getCompute().add(computeFlavor);
 440         context.addCompute(flavor,computeFlavor);
 441       }
 442     }
 443     context.addComponent(componentModel);
 444     context.getCreatedComponents().add(computeNodeType);
 445   }
 446
 447   private Nic extractPort(ServiceTemplate serviceTemplate, String portNodeTemplateId) {
 448     Optional<NodeTemplate> portNodeTemplate =
 449         toscaAnalyzerService.getNodeTemplateById(serviceTemplate, portNodeTemplateId);
 450     if (portNodeTemplate.isPresent()) {
 451       Nic port = new Nic();
 452       port.setName(portNodeTemplateId);
 453       connectPortToNetwork(port, portNodeTemplate.get());
 454       return port;
 455     } else {
 456       MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
 457           LoggerTragetServiceName.EXTRACT_COMPOSITION_DATA, ErrorLevel.ERROR.name(),
 458           LoggerErrorCode.DATA_ERROR.getErrorCode(),
 459           LoggerErrorDescription.EXTRACT_COMPOSITION_DATA);
 460       throw new CoreException(
 461           new ToscaInvalidEntryNotFoundErrorBuilder("Node Template", portNodeTemplateId).build());
 462     }
 463   }
 464
 465   private Map<String, List<String>> getNodeTemplatesGroupedByType(
 466       Map<String, NodeTemplate> nodeTemplates) {
 467
 468
 469     mdcDataDebugMessage.debugEntryMessage(null);
 470
 471     Map<String, List<String>> nodeTemplatesGrouped =
 472         new HashMap<>();   //key - node type, value - list of node ids with this type
 473     for (String nodeId : nodeTemplates.keySet()) {
 474       String nodeType = nodeTemplates.get(nodeId).getType();
 475       nodeTemplatesGrouped.putIfAbsent(nodeType, new ArrayList<>());
 476       nodeTemplatesGrouped.get(nodeType).add(nodeId);
 477     }
 478
 479     mdcDataDebugMessage.debugExitMessage(null);
 480     return nodeTemplatesGrouped;
 481   }
 482
 483   private List<Network> extractNetworks(ServiceTemplate serviceTemplate,
 484                                                ToscaServiceModel toscaServiceModel) {
 485
 486
 487     mdcDataDebugMessage.debugEntryMessage(null);
 488
 489     List<Network> networks = new ArrayList<>();
 490     Map<String, NodeTemplate> networkNodeTemplates = toscaAnalyzerService
 491         .getNodeTemplatesByType(serviceTemplate, ToscaNodeType.NATIVE_NETWORK,
 492             toscaServiceModel);
 493     if (MapUtils.isEmpty(networkNodeTemplates)) {
 494       mdcDataDebugMessage.debugExitMessage(null);
 495       return networks;
 496     }
 497     for (String networkId : networkNodeTemplates.keySet()) {
 498       Network network = new Network();
 499       network.setName(networkId);
 500       Optional<Boolean> networkDhcpValue =
 501           getNetworkDhcpValue(serviceTemplate, networkNodeTemplates.get(networkId));
 502       network.setDhcp(networkDhcpValue.isPresent() ? networkDhcpValue.get() : true);
 503       networks.add(network);
 504     }
 505
 506     mdcDataDebugMessage.debugExitMessage(null);
 507     return networks;
 508   }
 509
 510   //dhcp default value is true
 511   private Optional<Boolean> getNetworkDhcpValue(ServiceTemplate serviceTemplate,
 512                                                        NodeTemplate networkNodeTemplate) {
 513
 514
 515     mdcDataDebugMessage.debugEntryMessage(null);
 516
 517     if (networkNodeTemplate == null) {
 518       return Optional.empty();
 519     }
 520     if (networkNodeTemplate.getProperties() == null
 521         || networkNodeTemplate.getProperties().get(ToscaConstants.DHCP_ENABLED_PROPERTY_NAME)
 522         == null) {
 523       mdcDataDebugMessage.debugExitMessage(null);
 524       return Optional.of(true);
 525     }
 526
 527     Object dhcp =
 528         networkNodeTemplate.getProperties().get(ToscaConstants.DHCP_ENABLED_PROPERTY_NAME);
 529     if (dhcp instanceof String) {
 530       mdcDataDebugMessage.debugExitMessage(null);
 531       return Optional.of(Boolean.valueOf((String) dhcp));
 532     } else if (dhcp instanceof Boolean) {
 533       mdcDataDebugMessage.debugExitMessage(null);
 534       return Optional.of((Boolean) dhcp);
 535     } else if (dhcp instanceof Map) {
 536       String inputParameterName =
 537           (String) ((Map) dhcp).get(ToscaFunctions.GET_INPUT.getDisplayName());
 538       if (inputParameterName != null) {
 539         ParameterDefinition inputParameterDefinition =
 540             serviceTemplate.getTopology_template().getInputs().get(inputParameterName);
 541         if (inputParameterDefinition != null) {
 542           if (inputParameterDefinition.get_default() != null) {
 543             mdcDataDebugMessage.debugExitMessage(null);
 544             return Optional.of(Boolean.valueOf(inputParameterDefinition.get_default().toString()));
 545           }
 546         } else {
 547           MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
 548               LoggerTragetServiceName.EXTRACT_COMPOSITION_DATA, ErrorLevel.ERROR.name(),
 549               LoggerErrorCode.DATA_ERROR.getErrorCode(),
 550               LoggerErrorDescription.EXTRACT_COMPOSITION_DATA);
 551           throw new CoreException(
 552               new ToscaInvalidEntryNotFoundErrorBuilder("Input Parameter", inputParameterName)
 553                   .build());
 554         }
 555       }
 556     }
 557
 558     mdcDataDebugMessage.debugExitMessage(null);
 559     return Optional.of(true);
 560   }
 561
 562   @Override
 563   public String getComponentDisplayName(String componentName) {
 564     if (componentName == null) {
 565       return null;
 566     }
 567     String delimiterChar = ".";
 568     if (componentName.contains(delimiterChar)) {
 569       return componentName.substring(componentName.lastIndexOf(delimiterChar) + 1);
 570     }
 571     return componentName;
 572
 573   }
 574
 575 }