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