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