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.translator;
  22
  23 import org.apache.commons.collections4.CollectionUtils;
  24 import org.apache.commons.lang3.tuple.Pair;
  25 import org.junit.Assert;
  26 import org.openecomp.core.translator.api.HeatToToscaTranslator;
  27 import org.openecomp.core.utilities.file.FileUtils;
  28 import org.openecomp.sdc.common.utils.SdcCommon;
  29 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
  30 import org.openecomp.sdc.tosca.datatypes.model.GroupDefinition;
  31 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
  32 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
  33 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
  34 import org.openecomp.sdc.tosca.services.DataModelUtil;
  35 import org.openecomp.sdc.tosca.services.yamlutil.ToscaExtensionYamlUtil;
  36 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.*;
  37
  38 import java.io.File;
  39 import java.io.FileInputStream;
  40 import java.io.FileNotFoundException;
  41 import java.io.IOException;
  42 import java.io.InputStream;
  43 import java.net.URL;
  44 import java.nio.file.NotDirectoryException;
  45 import java.util.*;
  46
  47 public class TestUtils {
  48   private static final String MANIFEST_NAME = SdcCommon.MANIFEST_NAME;
  49   private static String zipFilename = "VSP.zip";
  50   private static String validationFilename = "validationOutput.json";
  51
  52   private TestUtils() {
  53   }
  54
  55
  56   public static void addFilesToTranslator(HeatToToscaTranslator heatToToscaTranslator, String path)
  57       throws IOException {
  58     File manifestFile = new File(path);
  59     File[] files = manifestFile.listFiles();
  60     byte[] fileContent;
  61
  62     Assert.assertNotNull("manifest files is empty", files);
  63
  64     for (File file : files) {
  65
  66       try (FileInputStream fis = new FileInputStream(file)) {
  67
  68         fileContent = FileUtils.toByteArray(fis);
  69
  70         if (file.getName().equals(MANIFEST_NAME)) {
  71           heatToToscaTranslator.addManifest(MANIFEST_NAME, fileContent);
  72         } else {
  73           if (!file.getName().equals(zipFilename) && (!file.getName().equals(validationFilename))) {
  74             heatToToscaTranslator.addFile(file.getName(), fileContent);
  75           }
  76         }
  77       }
  78     }
  79   }
  80
  81   /**
  82    * Get tosca service template models for the files in a directory
  83    * @param baseDirPath base directory for the tosca file
  84    * @return Map of <ServiceTemplateFilename, ServiceTemplate> for the files in this directory
  85    */
  86   public static Map<String, ServiceTemplate> getServiceTemplates(String baseDirPath){
  87     Map<String, ServiceTemplate> serviceTemplateMap = new HashMap<>();
  88     ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
  89     baseDirPath = "."+baseDirPath+"/";
  90     try {
  91       String[] fileList = {};
  92       URL filesDirUrl = TestUtils.class.getClassLoader().getResource(baseDirPath);
  93       if (filesDirUrl != null && filesDirUrl.getProtocol().equals("file")) {
  94         fileList = new File(filesDirUrl.toURI()).list();
  95       } else {
  96         Assert.fail("Invalid expected output files directory");
  97       }
  98       for (int i = 0; i < fileList.length; i++) {
  99         InputStream serviceTemplateInputStream = FileUtils.getFileInputStream(TestUtils.class
 100             .getClassLoader().getResource(baseDirPath + fileList[i]));
 101         ServiceTemplate serviceTemplate = toscaExtensionYamlUtil.yamlToObject
 102             (serviceTemplateInputStream, ServiceTemplate.class);
 103         serviceTemplateMap.put(fileList[i], serviceTemplate);
 104       }
 105     } catch (Exception e) {
 106       Assert.fail(e.getMessage());
 107     }
 108     return serviceTemplateMap;
 109   }
 110
 111   /**
 112    * Get tosca service template models
 113    * @param expectedResultMap Map of filename and payload of the expected result files
 114    * @return Map of <ServiceTemplateFilename, ServiceTemplate> for the files in this directory
 115    */
 116   public static Map<String, ServiceTemplate> getServiceTemplates(Map<String, byte[]>
 117                                                                      expectedResultMap){
 118     Map<String, ServiceTemplate> serviceTemplateMap = new HashMap<>();
 119     ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 120     for(String fileName : expectedResultMap.keySet()){
 121       ServiceTemplate serviceTemplate = toscaExtensionYamlUtil.yamlToObject
 122           (new String(expectedResultMap.get(fileName)), ServiceTemplate.class);
 123       serviceTemplateMap.put(fileName, serviceTemplate);
 124     }
 125     return serviceTemplateMap;
 126   }
 127
 128
 129   public static ToscaServiceModel loadToscaServiceModel(String serviceTemplatesPath,
 130                                                         String globalServiceTemplatesPath,
 131                                                         String entryDefinitionServiceTemplate)
 132       throws IOException {
 133     ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 134     Map<String, ServiceTemplate> serviceTemplates = new HashMap<>();
 135     if (entryDefinitionServiceTemplate == null) {
 136       entryDefinitionServiceTemplate = "MainServiceTemplate.yaml";
 137     }
 138
 139     serviceTemplates = getServiceTemplates(serviceTemplatesPath);
 140     if (globalServiceTemplatesPath != null) {
 141       serviceTemplates = getServiceTemplates(globalServiceTemplatesPath);
 142     }
 143
 144     return new ToscaServiceModel(null, serviceTemplates, entryDefinitionServiceTemplate);
 145   }
 146
 147   public static ServiceTemplate loadServiceTemplate(String serviceTemplatePath)
 148       throws IOException {
 149     ServiceTemplate serviceTemplateFromYaml = new ServiceTemplate();
 150     ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 151     URL urlFile = TestUtils.class.getResource(serviceTemplatePath);
 152     if (urlFile != null) {
 153       File pathFile = new File(urlFile.getFile());
 154       File[] files = pathFile.listFiles();
 155       for (File file : files) {
 156         try (InputStream yamlFile = new FileInputStream(file)) {
 157           serviceTemplateFromYaml =
 158               toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 159           createConcreteRequirementObjectsInServiceTemplate(serviceTemplateFromYaml, toscaExtensionYamlUtil);
 160           try {
 161             yamlFile.close();
 162           } catch (IOException ignore) {
 163           }
 164         } catch (FileNotFoundException e) {
 165           throw e;
 166         } catch (IOException e) {
 167           throw e;
 168         }
 169       }
 170     } else {
 171       throw new NotDirectoryException(serviceTemplatePath);
 172     }
 173     return serviceTemplateFromYaml;
 174   }
 175
 176
 177   public static void loadServiceTemplates(String serviceTemplatesPath,
 178                                           ToscaExtensionYamlUtil toscaExtensionYamlUtil,
 179                                           Map<String, ServiceTemplate> serviceTemplates)
 180       throws IOException {
 181     URL urlFile = TestUtils.class.getResource(serviceTemplatesPath);
 182     if (urlFile != null) {
 183       File pathFile = new File(urlFile.getFile());
 184       File[] files = pathFile.listFiles();
 185       if (files != null) {
 186         addServiceTemplateFiles(serviceTemplates, files, toscaExtensionYamlUtil);
 187       } else {
 188         throw new NotDirectoryException(serviceTemplatesPath);
 189       }
 190     } else {
 191       throw new NotDirectoryException(serviceTemplatesPath);
 192     }
 193   }
 194
 195   private static void addServiceTemplateFiles(Map<String, ServiceTemplate> serviceTemplates,
 196                                               File[] files,
 197                                               ToscaExtensionYamlUtil toscaExtensionYamlUtil)
 198       throws IOException {
 199     for (File file : files) {
 200       try (InputStream yamlFile = new FileInputStream(file)) {
 201         ServiceTemplate serviceTemplateFromYaml =
 202             toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 203         createConcreteRequirementObjectsInServiceTemplate(serviceTemplateFromYaml, toscaExtensionYamlUtil);
 204         serviceTemplates.put(file.getName(), serviceTemplateFromYaml);
 205         try {
 206           yamlFile.close();
 207         } catch (IOException ignore) {
 208         }
 209       } catch (FileNotFoundException e) {
 210         throw e;
 211       } catch (IOException e) {
 212         throw e;
 213       }
 214     }
 215   }
 216
 217   private static void createConcreteRequirementObjectsInServiceTemplate(ServiceTemplate
 218                                                                           serviceTemplateFromYaml,
 219                                                                       ToscaExtensionYamlUtil
 220                                                                           toscaExtensionYamlUtil) {
 221
 222     if (serviceTemplateFromYaml == null
 223         || serviceTemplateFromYaml.getTopology_template() == null
 224         || serviceTemplateFromYaml.getTopology_template().getNode_templates() == null) {
 225       return;
 226     }
 227
 228     //Creating concrete objects
 229     Map<String, NodeTemplate> nodeTemplates =
 230         serviceTemplateFromYaml.getTopology_template().getNode_templates();
 231     for (Map.Entry<String, NodeTemplate> entry : nodeTemplates.entrySet()) {
 232       NodeTemplate nodeTemplate = entry.getValue();
 233       List<Map<String, RequirementAssignment>> requirements = nodeTemplate.getRequirements();
 234       List<Map<String, RequirementAssignment>> concreteRequirementList = new ArrayList<>();
 235       if (requirements != null) {
 236         ListIterator<Map<String, RequirementAssignment>> reqListIterator = requirements
 237             .listIterator();
 238         while (reqListIterator.hasNext()){
 239           Map<String, RequirementAssignment> requirement = reqListIterator.next();
 240           Map<String, RequirementAssignment> concreteRequirement = new HashMap<>();
 241           for (Map.Entry<String, RequirementAssignment> reqEntry : requirement.entrySet()) {
 242             RequirementAssignment requirementAssignment = (toscaExtensionYamlUtil
 243                 .yamlToObject(toscaExtensionYamlUtil.objectToYaml(reqEntry.getValue()),
 244                     RequirementAssignment.class));
 245             concreteRequirement.put(reqEntry.getKey(), requirementAssignment);
 246             concreteRequirementList.add(concreteRequirement);
 247             reqListIterator.remove();
 248           }
 249         }
 250         requirements.clear();
 251         requirements.addAll(concreteRequirementList);
 252         nodeTemplate.setRequirements(requirements);
 253       }
 254       System.out.println();
 255       //toscaExtensionYamlUtil.yamlToObject(nodeTemplate, NodeTemplate.class);
 256     }
 257   }
 258
 259   public static void updateMultiplePortConsolidationDatas(String serviceTemplateName,
 260                                                           List<String> portNodeTemplateIds,
 261                                                           List<List<String>> nodesConnectedInIds,
 262                                                           List<List<String>> nodesConnectedOutIds,
 263                                                           List<List<String>> groupIds,
 264                                                           List<List<String>> getAttrInIds,
 265                                                           List<List<Pair<String, GetAttrFuncData>>> getAttrOutFuncDataList,
 266                                                           ConsolidationData consolidationData){
 267     for(int i = 0; i < portNodeTemplateIds.size(); i++){
 268       updatePortConsolidationData(serviceTemplateName, portNodeTemplateIds.get(i),
 269           nodesConnectedInIds.get(i), nodesConnectedOutIds.get(i),
 270           groupIds.get(i), getAttrInIds.get(i),getAttrOutFuncDataList.get(i), consolidationData);
 271     }
 272   }
 273
 274   public static void updatePortConsolidationData(String serviceTemplateFileName,
 275                                                  String portNodeTemplateId,
 276                                                  List<String> nodesConnectedInIds,
 277                                                  List<String> nodesConnectedOutIds,
 278                                                  List<String> groupIds, List<String> getAttrInIds,
 279                                                  List<Pair<String, GetAttrFuncData>> getAttrOutFuncDataList,
 280                                                  ConsolidationData consolidationData) {
 281
 282     PortTemplateConsolidationData portTemplateConsolidationData =
 283         createPortTemplateConsolidationData(portNodeTemplateId);
 284
 285     updateRelationsForEntityConsolidationData(portNodeTemplateId, nodesConnectedInIds,
 286         nodesConnectedOutIds, groupIds, getAttrInIds, getAttrOutFuncDataList, portTemplateConsolidationData);
 287
 288     consolidationData.getPortConsolidationData()
 289         .getFilePortConsolidationData(serviceTemplateFileName)
 290         .setPortTemplateConsolidationData(portNodeTemplateId, portTemplateConsolidationData);
 291   }
 292
 293   public static PortTemplateConsolidationData createPortTemplateConsolidationData(
 294       String portNodeTemplateId) {
 295     PortTemplateConsolidationData portTemplateConsolidationData =
 296         new PortTemplateConsolidationData();
 297     portTemplateConsolidationData.setNodeTemplateId(portNodeTemplateId);
 298     return portTemplateConsolidationData;
 299   }
 300
 301   public static void initPortConsolidationData(String serviceTemplateFileName,
 302                                                ConsolidationData consolidationData) {
 303
 304     consolidationData.getPortConsolidationData()
 305         .setFilePortConsolidationData(serviceTemplateFileName, new FilePortConsolidationData());
 306   }
 307
 308   public static void updateComputeTemplateConsolidationData(String serviceTemplateFileName,
 309                                                             String computeNodeTypeName,
 310                                                             String computeNodeTemplateId,
 311                                                             List<String> nodeIdsConnectedIn,
 312                                                             List<String> nodeIdsConnectedOut,
 313                                                             List<String> volumeIds,
 314                                                             List<String> groupIds,
 315                                                             List<String> getAttrInIds,
 316                                                             List<Pair<String, GetAttrFuncData>> getAttrOutIds,
 317                                                             List<Pair<String, String>> portTypeToIdList,
 318                                                             ConsolidationData consolidationData) {
 319
 320     initComputeNodeTemplateIdInConsolidationData(serviceTemplateFileName, computeNodeTypeName,
 321         computeNodeTemplateId, consolidationData);
 322
 323     Map<String, List<RequirementAssignmentData>> volumes =
 324         consolidationData.getComputeConsolidationData().getFileComputeConsolidationData
 325             (serviceTemplateFileName).getTypeComputeConsolidationData(computeNodeTypeName)
 326             .getComputeTemplateConsolidationData(computeNodeTemplateId).getVolumes();
 327
 328     ComputeTemplateConsolidationData computeTemplateConsolidationData =
 329         createComputeTemplateConsolidationData(computeNodeTemplateId, portTypeToIdList, volumes);
 330
 331     updateRelationsForEntityConsolidationData(computeNodeTemplateId, nodeIdsConnectedIn,
 332         nodeIdsConnectedOut, groupIds, getAttrInIds, getAttrOutIds, computeTemplateConsolidationData);
 333
 334     updateVolumes(computeTemplateConsolidationData, volumeIds);
 335
 336     consolidationData.getComputeConsolidationData()
 337         .getFileComputeConsolidationData(serviceTemplateFileName)
 338         .getTypeComputeConsolidationData(computeNodeTypeName)
 339         .setComputeTemplateConsolidationData(computeNodeTemplateId,
 340             computeTemplateConsolidationData);
 341   }
 342
 343   private static void updateRelationsForEntityConsolidationData(String entityNodeTemplateId,
 344                                                                 List<String> nodeIdsConnectedIn,
 345                                                                 List<String> nodeIdsConnectedOut,
 346                                                                 List<String> groupIds,
 347                                                                 List<String> getAttrInIds,
 348                                                                 List<Pair<String, GetAttrFuncData>> getAttrOutFuncDataList,
 349                                                                 EntityConsolidationData entity) {
 350     updateRelationsIn(entity, nodeIdsConnectedIn);
 351     updateRelationsOut(entity, entityNodeTemplateId, nodeIdsConnectedOut);
 352     updateGetAttrIn(entity, getAttrInIds);
 353     updateGetAttrOut(entity, getAttrOutFuncDataList);
 354     entity.setGroupIds(groupIds);
 355   }
 356
 357   public static void initComputeNodeTemplateIdInConsolidationData(String serviceTemplateFileName,
 358                                                                    String computeNodeTypeName,
 359                                                                    String computeNodeTemplateId,
 360                                                                    ConsolidationData consolidationData) {
 361
 362     if(Objects.isNull(consolidationData.getComputeConsolidationData().getFileComputeConsolidationData
 363         (serviceTemplateFileName))) {
 364       consolidationData.getComputeConsolidationData().setFileComputeConsolidationData
 365           (serviceTemplateFileName, new FileComputeConsolidationData());
 366     }
 367     TypeComputeConsolidationData typeComputeConsolidationData =
 368         consolidationData.getComputeConsolidationData().getFileComputeConsolidationData
 369             (serviceTemplateFileName).getTypeComputeConsolidationData(computeNodeTypeName);
 370
 371     if(
 372         typeComputeConsolidationData.getComputeTemplateConsolidationData(computeNodeTemplateId) == null) {
 373
 374       consolidationData.getComputeConsolidationData()
 375           .getFileComputeConsolidationData(serviceTemplateFileName)
 376           .getTypeComputeConsolidationData(computeNodeTypeName)
 377           .setComputeTemplateConsolidationData(computeNodeTemplateId, new ComputeTemplateConsolidationData());
 378
 379     }
 380   }
 381
 382   public static void updateNestedConsolidationData(String serviceTemplateName,
 383                                                    List<String> substitutionNodeTemplateIds,
 384                                                    ConsolidationData consolidationData){
 385     if(Objects.isNull(consolidationData.getNestedConsolidationData())){
 386       consolidationData.setNestedConsolidationData(new NestedConsolidationData());
 387     }
 388
 389     FileNestedConsolidationData fileNestedConsolidationData = new FileNestedConsolidationData();
 390     for(String substitutionNodeTemplateId : substitutionNodeTemplateIds) {
 391       NestedTemplateConsolidationData nestedTemplateConsolidationData = new NestedTemplateConsolidationData();
 392       nestedTemplateConsolidationData.setNodeTemplateId(substitutionNodeTemplateId);
 393       fileNestedConsolidationData.setNestedTemplateConsolidationData(substitutionNodeTemplateId, nestedTemplateConsolidationData);
 394     }
 395     consolidationData.getNestedConsolidationData().setFileNestedConsolidationData(serviceTemplateName, fileNestedConsolidationData);
 396   }
 397
 398   public static ComputeTemplateConsolidationData createComputeTemplateConsolidationData(String computeNodeTemplateId,
 399                                                                                         List<Pair<String, String>> portTypeToIdList,
 400                                                                                         Map<String,List<RequirementAssignmentData>> volumes) {
 401     ComputeTemplateConsolidationData compute = new ComputeTemplateConsolidationData();
 402     compute.setNodeTemplateId(computeNodeTemplateId);
 403     if (portTypeToIdList != null) {
 404       for (Pair<String, String> port : portTypeToIdList) {
 405         compute.addPort(port.getLeft(), port.getRight());
 406       }
 407     }
 408     compute.setVolumes(volumes);
 409     return compute;
 410   }
 411
 412   public static void updateRelationsIn(EntityConsolidationData entity,
 413                                        List<String> idsPontingTome){
 414     if(CollectionUtils.isEmpty(idsPontingTome)){
 415       return;
 416     }
 417
 418     for(String pointingId : idsPontingTome){
 419       entity.addNodesConnectedIn(pointingId, entity.getNodeTemplateId(), new RequirementAssignment());
 420     }
 421   }
 422
 423   public static void updateRelationsOut(EntityConsolidationData entity,
 424                                         String nodeTemplateId,
 425                                         List<String> idsToUpdate){
 426     if(CollectionUtils.isEmpty(idsToUpdate)){
 427       return;
 428     }
 429
 430     for(String id : idsToUpdate){
 431       entity.addNodesConnectedOut(id, id, new RequirementAssignment());
 432     }
 433   }
 434
 435   public static void updateGetAttrIn(EntityConsolidationData entity,
 436                                      List<String> idsToUpdate){
 437     if(CollectionUtils.isEmpty(idsToUpdate)){
 438       return;
 439     }
 440
 441     for(String id : idsToUpdate){
 442       entity.addNodesGetAttrIn(id, new GetAttrFuncData());
 443     }
 444   }
 445
 446   public static void updateGetAttrOut(EntityConsolidationData entity,
 447                                       List<Pair<String, GetAttrFuncData>> getAttrOutIds){
 448     if(CollectionUtils.isEmpty(getAttrOutIds)){
 449       return;
 450     }
 451
 452     for(Pair<String, GetAttrFuncData> getAttrOutFunc : getAttrOutIds){
 453       entity.addNodesGetAttrOut(getAttrOutFunc.getLeft(), getAttrOutFunc.getRight());
 454     }
 455   }
 456
 457   public static void updateVolumes(ComputeTemplateConsolidationData compute,
 458                                    List<String> volumeIds){
 459     if(CollectionUtils.isEmpty(volumeIds)){
 460       return;
 461     }
 462
 463     for(String id : volumeIds){
 464       RequirementAssignment requirementAssignment = new RequirementAssignment();
 465       requirementAssignment.setNode(id);
 466       compute.addVolume(id, requirementAssignment);
 467     }
 468   }
 469
 470   public static void initComputeNodeTypeInConsolidationData(String serviceTemplateFileName,
 471                                                             String computeNodeTypeName,
 472                                                             ConsolidationData consolidationData) {
 473     ComputeConsolidationData computeConsolidationData =
 474         consolidationData.getComputeConsolidationData();
 475     if (!computeConsolidationData.getAllServiceTemplateFileNames()
 476         .contains(serviceTemplateFileName)) {
 477       computeConsolidationData
 478           .setFileComputeConsolidationData(serviceTemplateFileName,
 479               new FileComputeConsolidationData());
 480     }
 481     computeConsolidationData
 482         .getFileComputeConsolidationData(serviceTemplateFileName).setTypeComputeConsolidationData(
 483         computeNodeTypeName, new TypeComputeConsolidationData());
 484   }
 485
 486   public static Map<String, List<RequirementAssignmentData>> getNodeConnectedOutList(
 487       NodeTemplate nodeTemplate, String requirementKey) {
 488     Map<String, List<RequirementAssignmentData>> requirementAssignmentDataMap = new HashMap<>();
 489     Optional<List<RequirementAssignmentData>> requirementAssignmentDataList =
 490         TestUtils.createRequirementAssignmentDataList(nodeTemplate, requirementKey);
 491     if (requirementAssignmentDataList.isPresent()) {
 492       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList
 493           .get()) {
 494         String connectedNodeTemplateId = requirementAssignmentData.getRequirementAssignment()
 495             .getNode();
 496         requirementAssignmentDataMap
 497             .computeIfAbsent(connectedNodeTemplateId, k -> new ArrayList<>());
 498         requirementAssignmentDataMap.get(connectedNodeTemplateId).add(requirementAssignmentData);
 499       }
 500     }
 501     return requirementAssignmentDataMap;
 502   }
 503
 504   public static void updatePortsInComputeTemplateConsolidationData(
 505       List<Pair<String, String>> portIdToTypeList, ComputeTemplateConsolidationData
 506       compute){
 507     compute.setPorts(new HashMap<>());
 508     for(Pair<String, String> portIdToType : portIdToTypeList){
 509       compute.getPorts().putIfAbsent(portIdToType.getLeft(), new ArrayList<>());
 510       compute.getPorts().get(portIdToType.getLeft()).add(portIdToType.getRight());
 511     }
 512   }
 513
 514   public static Map<String, List<RequirementAssignmentData>> getNodeConnectedInList(
 515       String sourceNodeTemplateId,
 516       ServiceTemplate serviceTemplate, String requirementKey) {
 517     Optional<List<RequirementAssignmentData>> requirementAssignmentDataList = Optional.empty();
 518     List<RequirementAssignmentData> assignmentDataList = new ArrayList<>();
 519     Map<String, List<RequirementAssignmentData>> requirementAssignmentDataMap = new HashMap<>();
 520     Map<String, NodeTemplate> nodeTemplates = serviceTemplate.getTopology_template()
 521         .getNode_templates();
 522     for (Map.Entry<String, NodeTemplate> entry : nodeTemplates.entrySet()) {
 523       String nodeTemplateId = entry.getKey();
 524       List<Map<String, RequirementAssignment>> requirements = entry.getValue().getRequirements();
 525       if (requirements != null) {
 526         for (Map<String, RequirementAssignment> requirement : requirements) {
 527           if (requirement.get(requirementKey) != null) {
 528             RequirementAssignment requirementAssignment = requirement.get(requirementKey);
 529             if (requirementAssignment != null) {
 530               if (requirementAssignment.getNode().equals(sourceNodeTemplateId)) {
 531                 RequirementAssignmentData data = new RequirementAssignmentData(requirementKey,
 532                     requirementAssignment);
 533                 assignmentDataList.add(data);
 534               }
 535             }
 536           }
 537         }
 538         requirementAssignmentDataList = Optional.ofNullable(assignmentDataList);
 539         if (requirementAssignmentDataList.isPresent()) {
 540           for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList
 541               .get()) {
 542             requirementAssignmentDataMap.computeIfAbsent(nodeTemplateId, k -> new ArrayList<>());
 543             requirementAssignmentDataMap.get(nodeTemplateId).add(requirementAssignmentData);
 544           }
 545         }
 546         requirementAssignmentDataList = Optional.empty();
 547       }
 548     }
 549     return requirementAssignmentDataMap;
 550   }
 551
 552   public static List<String> getGroupsForNode(ServiceTemplate serviceTemplate, String
 553       nodeTemplateId) {
 554     List<String> entityGroups = new ArrayList<>();
 555     Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template().getGroups();
 556     Map<String, NodeTemplate> nodeTemplates =
 557         serviceTemplate.getTopology_template().getNode_templates();
 558     for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
 559       String groupId = entry.getKey();
 560       GroupDefinition groupDefinition = entry.getValue();
 561       if (groupDefinition.getType().contains("HeatStack"))
 562         continue;
 563       List<String> groupMembers = groupDefinition.getMembers();
 564       for (String member : groupMembers) {
 565         if (groups.containsKey(member))
 566           continue;
 567         if (member.equals(nodeTemplateId)) {
 568           entityGroups.add(groupId);
 569         }
 570       }
 571     }
 572     return entityGroups;
 573   }
 574
 575   private static Optional<List<RequirementAssignmentData>> createRequirementAssignmentDataList(
 576       NodeTemplate nodeTemplate, String requirementKey) {
 577
 578     Optional<List<RequirementAssignment>> requirementAssignmentLink =
 579         DataModelUtil.getRequirementAssignment(nodeTemplate.getRequirements(), requirementKey);
 580     if (!requirementAssignmentLink.isPresent()) {
 581       return Optional.empty();
 582     }
 583
 584     List<RequirementAssignmentData> requirementAssignmentDataList = new ArrayList<>();
 585     for (RequirementAssignment requirementAssignment : requirementAssignmentLink.get()) {
 586       RequirementAssignmentData requirementAssignmentData = new RequirementAssignmentData
 587           (requirementKey, requirementAssignment);
 588       requirementAssignmentDataList.add(requirementAssignmentData);
 589     }
 590     return Optional.ofNullable(requirementAssignmentDataList);
 591   }
 592
 593   public static Optional<List<RequirementAssignmentData>> getRequirementAssignmentDataList(
 594       NodeTemplate nodeTemplate, String requirementKey) {
 595     List<RequirementAssignmentData> returnedReqAssignmentDataList = new ArrayList<>();
 596     Optional<List<RequirementAssignmentData>> requirementAssignmentDataList =
 597         TestUtils.createRequirementAssignmentDataList(nodeTemplate, requirementKey);
 598
 599     if (requirementAssignmentDataList.isPresent()) {
 600       for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList
 601           .get()) {
 602         returnedReqAssignmentDataList.add(requirementAssignmentData);
 603       }
 604       return Optional.of(returnedReqAssignmentDataList);
 605     }
 606     return Optional.empty();
 607   }
 608
 609
 610
 611 }