gerrit.onap Code Review - sdc.git/blob

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