openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/java/org/openecomp/sdc/translator/TestUtils.java

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