+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
package org.openecomp.sdc.translator;
-import org.openecomp.sdc.common.utils.AsdcCommon;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.tuple.Pair;
+import org.junit.Assert;
import org.openecomp.core.translator.api.HeatToToscaTranslator;
import org.openecomp.core.utilities.file.FileUtils;
-import org.junit.Assert;
+import org.openecomp.sdc.common.utils.SdcCommon;
+import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
+import org.openecomp.sdc.tosca.datatypes.model.GroupDefinition;
+import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
+import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
+import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
+import org.openecomp.sdc.tosca.services.DataModelUtil;
+import org.openecomp.sdc.tosca.services.yamlutil.ToscaExtensionYamlUtil;
+import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.*;
-import java.io.*;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.file.NotDirectoryException;
+import java.util.*;
public class TestUtils {
- private static final String MANIFEST_NAME = AsdcCommon.MANIFEST_NAME;
+ private static final String MANIFEST_NAME = SdcCommon.MANIFEST_NAME;
private static String zipFilename = "VSP.zip";
private static String validationFilename = "validationOutput.json";
}
}
}
+
+ /**
+ * Get tosca service template models for the files in a directory
+ * @param baseDirPath base directory for the tosca file
+ * @return Map of <ServiceTemplateFilename, ServiceTemplate> for the files in this directory
+ */
+ public static Map<String, ServiceTemplate> getServiceTemplates(String baseDirPath){
+ Map<String, ServiceTemplate> serviceTemplateMap = new HashMap<>();
+ ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
+ baseDirPath = "."+baseDirPath+"/";
+ try {
+ String[] fileList = {};
+ URL filesDirUrl = TestUtils.class.getClassLoader().getResource(baseDirPath);
+ if (filesDirUrl != null && filesDirUrl.getProtocol().equals("file")) {
+ fileList = new File(filesDirUrl.toURI()).list();
+ } else {
+ Assert.fail("Invalid expected output files directory");
+ }
+ for (int i = 0; i < fileList.length; i++) {
+ InputStream serviceTemplateInputStream = FileUtils.getFileInputStream(TestUtils.class
+ .getClassLoader().getResource(baseDirPath + fileList[i]));
+ ServiceTemplate serviceTemplate = toscaExtensionYamlUtil.yamlToObject
+ (serviceTemplateInputStream, ServiceTemplate.class);
+ serviceTemplateMap.put(fileList[i], serviceTemplate);
+ }
+ } catch (Exception e) {
+ Assert.fail(e.getMessage());
+ }
+ return serviceTemplateMap;
+ }
+
+ /**
+ * Get tosca service template models
+ * @param expectedResultMap Map of filename and payload of the expected result files
+ * @return Map of <ServiceTemplateFilename, ServiceTemplate> for the files in this directory
+ */
+ public static Map<String, ServiceTemplate> getServiceTemplates(Map<String, byte[]>
+ expectedResultMap){
+ Map<String, ServiceTemplate> serviceTemplateMap = new HashMap<>();
+ ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
+ for(String fileName : expectedResultMap.keySet()){
+ ServiceTemplate serviceTemplate = toscaExtensionYamlUtil.yamlToObject
+ (new String(expectedResultMap.get(fileName)), ServiceTemplate.class);
+ serviceTemplateMap.put(fileName, serviceTemplate);
+ }
+ return serviceTemplateMap;
+ }
+
+
+ public static ToscaServiceModel loadToscaServiceModel(String serviceTemplatesPath,
+ String globalServiceTemplatesPath,
+ String entryDefinitionServiceTemplate)
+ throws IOException {
+ ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
+ Map<String, ServiceTemplate> serviceTemplates = new HashMap<>();
+ if (entryDefinitionServiceTemplate == null) {
+ entryDefinitionServiceTemplate = "MainServiceTemplate.yaml";
+ }
+
+ serviceTemplates = getServiceTemplates(serviceTemplatesPath);
+ if (globalServiceTemplatesPath != null) {
+ serviceTemplates = getServiceTemplates(globalServiceTemplatesPath);
+ }
+
+ return new ToscaServiceModel(null, serviceTemplates, entryDefinitionServiceTemplate);
+ }
+
+ public static ServiceTemplate loadServiceTemplate(String serviceTemplatePath)
+ throws IOException {
+ ServiceTemplate serviceTemplateFromYaml = new ServiceTemplate();
+ ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
+ URL urlFile = TestUtils.class.getResource(serviceTemplatePath);
+ if (urlFile != null) {
+ File pathFile = new File(urlFile.getFile());
+ File[] files = pathFile.listFiles();
+ for (File file : files) {
+ try (InputStream yamlFile = new FileInputStream(file)) {
+ serviceTemplateFromYaml =
+ toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
+ createConcreteRequirementObjectsInServiceTemplate(serviceTemplateFromYaml, toscaExtensionYamlUtil);
+ try {
+ yamlFile.close();
+ } catch (IOException ignore) {
+ }
+ } catch (FileNotFoundException e) {
+ throw e;
+ } catch (IOException e) {
+ throw e;
+ }
+ }
+ } else {
+ throw new NotDirectoryException(serviceTemplatePath);
+ }
+ return serviceTemplateFromYaml;
+ }
+
+
+ public static void loadServiceTemplates(String serviceTemplatesPath,
+ ToscaExtensionYamlUtil toscaExtensionYamlUtil,
+ Map<String, ServiceTemplate> serviceTemplates)
+ throws IOException {
+ URL urlFile = TestUtils.class.getResource(serviceTemplatesPath);
+ if (urlFile != null) {
+ File pathFile = new File(urlFile.getFile());
+ File[] files = pathFile.listFiles();
+ if (files != null) {
+ addServiceTemplateFiles(serviceTemplates, files, toscaExtensionYamlUtil);
+ } else {
+ throw new NotDirectoryException(serviceTemplatesPath);
+ }
+ } else {
+ throw new NotDirectoryException(serviceTemplatesPath);
+ }
+ }
+
+ private static void addServiceTemplateFiles(Map<String, ServiceTemplate> serviceTemplates,
+ File[] files,
+ ToscaExtensionYamlUtil toscaExtensionYamlUtil)
+ throws IOException {
+ for (File file : files) {
+ try (InputStream yamlFile = new FileInputStream(file)) {
+ ServiceTemplate serviceTemplateFromYaml =
+ toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
+ createConcreteRequirementObjectsInServiceTemplate(serviceTemplateFromYaml, toscaExtensionYamlUtil);
+ serviceTemplates.put(file.getName(), serviceTemplateFromYaml);
+ try {
+ yamlFile.close();
+ } catch (IOException ignore) {
+ }
+ } catch (FileNotFoundException e) {
+ throw e;
+ } catch (IOException e) {
+ throw e;
+ }
+ }
+ }
+
+ private static void createConcreteRequirementObjectsInServiceTemplate(ServiceTemplate
+ serviceTemplateFromYaml,
+ ToscaExtensionYamlUtil
+ toscaExtensionYamlUtil) {
+
+ if (serviceTemplateFromYaml == null
+ || serviceTemplateFromYaml.getTopology_template() == null
+ || serviceTemplateFromYaml.getTopology_template().getNode_templates() == null) {
+ return;
+ }
+
+ //Creating concrete objects
+ Map<String, NodeTemplate> nodeTemplates =
+ serviceTemplateFromYaml.getTopology_template().getNode_templates();
+ for (Map.Entry<String, NodeTemplate> entry : nodeTemplates.entrySet()) {
+ NodeTemplate nodeTemplate = entry.getValue();
+ List<Map<String, RequirementAssignment>> requirements = nodeTemplate.getRequirements();
+ List<Map<String, RequirementAssignment>> concreteRequirementList = new ArrayList<>();
+ if (requirements != null) {
+ ListIterator<Map<String, RequirementAssignment>> reqListIterator = requirements
+ .listIterator();
+ while (reqListIterator.hasNext()){
+ Map<String, RequirementAssignment> requirement = reqListIterator.next();
+ Map<String, RequirementAssignment> concreteRequirement = new HashMap<>();
+ for (Map.Entry<String, RequirementAssignment> reqEntry : requirement.entrySet()) {
+ RequirementAssignment requirementAssignment = (toscaExtensionYamlUtil
+ .yamlToObject(toscaExtensionYamlUtil.objectToYaml(reqEntry.getValue()),
+ RequirementAssignment.class));
+ concreteRequirement.put(reqEntry.getKey(), requirementAssignment);
+ concreteRequirementList.add(concreteRequirement);
+ reqListIterator.remove();
+ }
+ }
+ requirements.clear();
+ requirements.addAll(concreteRequirementList);
+ nodeTemplate.setRequirements(requirements);
+ }
+ System.out.println();
+ //toscaExtensionYamlUtil.yamlToObject(nodeTemplate, NodeTemplate.class);
+ }
+ }
+
+ public static void updateMultiplePortConsolidationDatas(String serviceTemplateName,
+ List<String> portNodeTemplateIds,
+ List<List<String>> nodesConnectedInIds,
+ List<List<String>> nodesConnectedOutIds,
+ List<List<String>> groupIds,
+ List<List<String>> getAttrInIds,
+ List<List<Pair<String, GetAttrFuncData>>> getAttrOutFuncDataList,
+ ConsolidationData consolidationData){
+ for(int i = 0; i < portNodeTemplateIds.size(); i++){
+ updatePortConsolidationData(serviceTemplateName, portNodeTemplateIds.get(i),
+ nodesConnectedInIds.get(i), nodesConnectedOutIds.get(i),
+ groupIds.get(i), getAttrInIds.get(i),getAttrOutFuncDataList.get(i), consolidationData);
+ }
+ }
+
+ public static void updatePortConsolidationData(String serviceTemplateFileName,
+ String portNodeTemplateId,
+ List<String> nodesConnectedInIds,
+ List<String> nodesConnectedOutIds,
+ List<String> groupIds, List<String> getAttrInIds,
+ List<Pair<String, GetAttrFuncData>> getAttrOutFuncDataList,
+ ConsolidationData consolidationData) {
+
+ PortTemplateConsolidationData portTemplateConsolidationData =
+ createPortTemplateConsolidationData(portNodeTemplateId);
+
+ updateRelationsForEntityConsolidationData(portNodeTemplateId, nodesConnectedInIds,
+ nodesConnectedOutIds, groupIds, getAttrInIds, getAttrOutFuncDataList, portTemplateConsolidationData);
+
+ consolidationData.getPortConsolidationData()
+ .getFilePortConsolidationData(serviceTemplateFileName)
+ .setPortTemplateConsolidationData(portNodeTemplateId, portTemplateConsolidationData);
+ }
+
+ public static PortTemplateConsolidationData createPortTemplateConsolidationData(
+ String portNodeTemplateId) {
+ PortTemplateConsolidationData portTemplateConsolidationData =
+ new PortTemplateConsolidationData();
+ portTemplateConsolidationData.setNodeTemplateId(portNodeTemplateId);
+ return portTemplateConsolidationData;
+ }
+
+ public static void initPortConsolidationData(String serviceTemplateFileName,
+ ConsolidationData consolidationData) {
+
+ consolidationData.getPortConsolidationData()
+ .setFilePortConsolidationData(serviceTemplateFileName, new FilePortConsolidationData());
+ }
+
+ public static void updateComputeTemplateConsolidationData(String serviceTemplateFileName,
+ String computeNodeTypeName,
+ String computeNodeTemplateId,
+ List<String> nodeIdsConnectedIn,
+ List<String> nodeIdsConnectedOut,
+ List<String> volumeIds,
+ List<String> groupIds,
+ List<String> getAttrInIds,
+ List<Pair<String, GetAttrFuncData>> getAttrOutIds,
+ List<Pair<String, String>> portTypeToIdList,
+ ConsolidationData consolidationData) {
+
+ initComputeNodeTemplateIdInConsolidationData(serviceTemplateFileName, computeNodeTypeName,
+ computeNodeTemplateId, consolidationData);
+
+ Map<String, List<RequirementAssignmentData>> volumes =
+ consolidationData.getComputeConsolidationData().getFileComputeConsolidationData
+ (serviceTemplateFileName).getTypeComputeConsolidationData(computeNodeTypeName)
+ .getComputeTemplateConsolidationData(computeNodeTemplateId).getVolumes();
+
+ ComputeTemplateConsolidationData computeTemplateConsolidationData =
+ createComputeTemplateConsolidationData(computeNodeTemplateId, portTypeToIdList, volumes);
+
+ updateRelationsForEntityConsolidationData(computeNodeTemplateId, nodeIdsConnectedIn,
+ nodeIdsConnectedOut, groupIds, getAttrInIds, getAttrOutIds, computeTemplateConsolidationData);
+
+ updateVolumes(computeTemplateConsolidationData, volumeIds);
+
+ consolidationData.getComputeConsolidationData()
+ .getFileComputeConsolidationData(serviceTemplateFileName)
+ .getTypeComputeConsolidationData(computeNodeTypeName)
+ .setComputeTemplateConsolidationData(computeNodeTemplateId,
+ computeTemplateConsolidationData);
+ }
+
+ private static void updateRelationsForEntityConsolidationData(String entityNodeTemplateId,
+ List<String> nodeIdsConnectedIn,
+ List<String> nodeIdsConnectedOut,
+ List<String> groupIds,
+ List<String> getAttrInIds,
+ List<Pair<String, GetAttrFuncData>> getAttrOutFuncDataList,
+ EntityConsolidationData entity) {
+ updateRelationsIn(entity, nodeIdsConnectedIn);
+ updateRelationsOut(entity, entityNodeTemplateId, nodeIdsConnectedOut);
+ updateGetAttrIn(entity, getAttrInIds);
+ updateGetAttrOut(entity, getAttrOutFuncDataList);
+ entity.setGroupIds(groupIds);
+ }
+
+ public static void initComputeNodeTemplateIdInConsolidationData(String serviceTemplateFileName,
+ String computeNodeTypeName,
+ String computeNodeTemplateId,
+ ConsolidationData consolidationData) {
+
+ if(Objects.isNull(consolidationData.getComputeConsolidationData().getFileComputeConsolidationData
+ (serviceTemplateFileName))) {
+ consolidationData.getComputeConsolidationData().setFileComputeConsolidationData
+ (serviceTemplateFileName, new FileComputeConsolidationData());
+ }
+ TypeComputeConsolidationData typeComputeConsolidationData =
+ consolidationData.getComputeConsolidationData().getFileComputeConsolidationData
+ (serviceTemplateFileName).getTypeComputeConsolidationData(computeNodeTypeName);
+
+ if(
+ typeComputeConsolidationData.getComputeTemplateConsolidationData(computeNodeTemplateId) == null) {
+
+ consolidationData.getComputeConsolidationData()
+ .getFileComputeConsolidationData(serviceTemplateFileName)
+ .getTypeComputeConsolidationData(computeNodeTypeName)
+ .setComputeTemplateConsolidationData(computeNodeTemplateId, new ComputeTemplateConsolidationData());
+
+ }
+ }
+
+ public static void updateNestedConsolidationData(String serviceTemplateName,
+ List<String> substitutionNodeTemplateIds,
+ ConsolidationData consolidationData){
+ if(Objects.isNull(consolidationData.getNestedConsolidationData())){
+ consolidationData.setNestedConsolidationData(new NestedConsolidationData());
+ }
+
+ FileNestedConsolidationData fileNestedConsolidationData = new FileNestedConsolidationData();
+ for(String substitutionNodeTemplateId : substitutionNodeTemplateIds) {
+ NestedTemplateConsolidationData nestedTemplateConsolidationData = new NestedTemplateConsolidationData();
+ nestedTemplateConsolidationData.setNodeTemplateId(substitutionNodeTemplateId);
+ fileNestedConsolidationData.setNestedTemplateConsolidationData(substitutionNodeTemplateId, nestedTemplateConsolidationData);
+ }
+ consolidationData.getNestedConsolidationData().setFileNestedConsolidationData(serviceTemplateName, fileNestedConsolidationData);
+ }
+
+ public static ComputeTemplateConsolidationData createComputeTemplateConsolidationData(String computeNodeTemplateId,
+ List<Pair<String, String>> portTypeToIdList,
+ Map<String,List<RequirementAssignmentData>> volumes) {
+ ComputeTemplateConsolidationData compute = new ComputeTemplateConsolidationData();
+ compute.setNodeTemplateId(computeNodeTemplateId);
+ if (portTypeToIdList != null) {
+ for (Pair<String, String> port : portTypeToIdList) {
+ compute.addPort(port.getLeft(), port.getRight());
+ }
+ }
+ compute.setVolumes(volumes);
+ return compute;
+ }
+
+ public static void updateRelationsIn(EntityConsolidationData entity,
+ List<String> idsPontingTome){
+ if(CollectionUtils.isEmpty(idsPontingTome)){
+ return;
+ }
+
+ for(String pointingId : idsPontingTome){
+ entity.addNodesConnectedIn(pointingId, entity.getNodeTemplateId(), new RequirementAssignment());
+ }
+ }
+
+ public static void updateRelationsOut(EntityConsolidationData entity,
+ String nodeTemplateId,
+ List<String> idsToUpdate){
+ if(CollectionUtils.isEmpty(idsToUpdate)){
+ return;
+ }
+
+ for(String id : idsToUpdate){
+ entity.addNodesConnectedOut(id, id, new RequirementAssignment());
+ }
+ }
+
+ public static void updateGetAttrIn(EntityConsolidationData entity,
+ List<String> idsToUpdate){
+ if(CollectionUtils.isEmpty(idsToUpdate)){
+ return;
+ }
+
+ for(String id : idsToUpdate){
+ entity.addNodesGetAttrIn(id, new GetAttrFuncData());
+ }
+ }
+
+ public static void updateGetAttrOut(EntityConsolidationData entity,
+ List<Pair<String, GetAttrFuncData>> getAttrOutIds){
+ if(CollectionUtils.isEmpty(getAttrOutIds)){
+ return;
+ }
+
+ for(Pair<String, GetAttrFuncData> getAttrOutFunc : getAttrOutIds){
+ entity.addNodesGetAttrOut(getAttrOutFunc.getLeft(), getAttrOutFunc.getRight());
+ }
+ }
+
+ public static void updateVolumes(ComputeTemplateConsolidationData compute,
+ List<String> volumeIds){
+ if(CollectionUtils.isEmpty(volumeIds)){
+ return;
+ }
+
+ for(String id : volumeIds){
+ RequirementAssignment requirementAssignment = new RequirementAssignment();
+ requirementAssignment.setNode(id);
+ compute.addVolume(id, requirementAssignment);
+ }
+ }
+
+ public static void initComputeNodeTypeInConsolidationData(String serviceTemplateFileName,
+ String computeNodeTypeName,
+ ConsolidationData consolidationData) {
+ ComputeConsolidationData computeConsolidationData =
+ consolidationData.getComputeConsolidationData();
+ if (!computeConsolidationData.getAllServiceTemplateFileNames()
+ .contains(serviceTemplateFileName)) {
+ computeConsolidationData
+ .setFileComputeConsolidationData(serviceTemplateFileName,
+ new FileComputeConsolidationData());
+ }
+ computeConsolidationData
+ .getFileComputeConsolidationData(serviceTemplateFileName).setTypeComputeConsolidationData(
+ computeNodeTypeName, new TypeComputeConsolidationData());
+ }
+
+ public static Map<String, List<RequirementAssignmentData>> getNodeConnectedOutList(
+ NodeTemplate nodeTemplate, String requirementKey) {
+ Map<String, List<RequirementAssignmentData>> requirementAssignmentDataMap = new HashMap<>();
+ Optional<List<RequirementAssignmentData>> requirementAssignmentDataList =
+ TestUtils.createRequirementAssignmentDataList(nodeTemplate, requirementKey);
+ if (requirementAssignmentDataList.isPresent()) {
+ for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList
+ .get()) {
+ String connectedNodeTemplateId = requirementAssignmentData.getRequirementAssignment()
+ .getNode();
+ requirementAssignmentDataMap
+ .computeIfAbsent(connectedNodeTemplateId, k -> new ArrayList<>());
+ requirementAssignmentDataMap.get(connectedNodeTemplateId).add(requirementAssignmentData);
+ }
+ }
+ return requirementAssignmentDataMap;
+ }
+
+ public static void updatePortsInComputeTemplateConsolidationData(
+ List<Pair<String, String>> portIdToTypeList, ComputeTemplateConsolidationData
+ compute){
+ compute.setPorts(new HashMap<>());
+ for(Pair<String, String> portIdToType : portIdToTypeList){
+ compute.getPorts().putIfAbsent(portIdToType.getLeft(), new ArrayList<>());
+ compute.getPorts().get(portIdToType.getLeft()).add(portIdToType.getRight());
+ }
+ }
+
+ public static Map<String, List<RequirementAssignmentData>> getNodeConnectedInList(
+ String sourceNodeTemplateId,
+ ServiceTemplate serviceTemplate, String requirementKey) {
+ Optional<List<RequirementAssignmentData>> requirementAssignmentDataList = Optional.empty();
+ List<RequirementAssignmentData> assignmentDataList = new ArrayList<>();
+ Map<String, List<RequirementAssignmentData>> requirementAssignmentDataMap = new HashMap<>();
+ Map<String, NodeTemplate> nodeTemplates = serviceTemplate.getTopology_template()
+ .getNode_templates();
+ for (Map.Entry<String, NodeTemplate> entry : nodeTemplates.entrySet()) {
+ String nodeTemplateId = entry.getKey();
+ List<Map<String, RequirementAssignment>> requirements = entry.getValue().getRequirements();
+ if (requirements != null) {
+ for (Map<String, RequirementAssignment> requirement : requirements) {
+ if (requirement.get(requirementKey) != null) {
+ RequirementAssignment requirementAssignment = requirement.get(requirementKey);
+ if (requirementAssignment != null) {
+ if (requirementAssignment.getNode().equals(sourceNodeTemplateId)) {
+ RequirementAssignmentData data = new RequirementAssignmentData(requirementKey,
+ requirementAssignment);
+ assignmentDataList.add(data);
+ }
+ }
+ }
+ }
+ requirementAssignmentDataList = Optional.ofNullable(assignmentDataList);
+ if (requirementAssignmentDataList.isPresent()) {
+ for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList
+ .get()) {
+ requirementAssignmentDataMap.computeIfAbsent(nodeTemplateId, k -> new ArrayList<>());
+ requirementAssignmentDataMap.get(nodeTemplateId).add(requirementAssignmentData);
+ }
+ }
+ requirementAssignmentDataList = Optional.empty();
+ }
+ }
+ return requirementAssignmentDataMap;
+ }
+
+ public static List<String> getGroupsForNode(ServiceTemplate serviceTemplate, String
+ nodeTemplateId) {
+ List<String> entityGroups = new ArrayList<>();
+ Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template().getGroups();
+ Map<String, NodeTemplate> nodeTemplates =
+ serviceTemplate.getTopology_template().getNode_templates();
+ for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
+ String groupId = entry.getKey();
+ GroupDefinition groupDefinition = entry.getValue();
+ if (groupDefinition.getType().contains("HeatStack"))
+ continue;
+ List<String> groupMembers = groupDefinition.getMembers();
+ for (String member : groupMembers) {
+ if (groups.containsKey(member))
+ continue;
+ if (member.equals(nodeTemplateId)) {
+ entityGroups.add(groupId);
+ }
+ }
+ }
+ return entityGroups;
+ }
+
+ private static Optional<List<RequirementAssignmentData>> createRequirementAssignmentDataList(
+ NodeTemplate nodeTemplate, String requirementKey) {
+
+ Optional<List<RequirementAssignment>> requirementAssignmentLink =
+ DataModelUtil.getRequirementAssignment(nodeTemplate.getRequirements(), requirementKey);
+ if (!requirementAssignmentLink.isPresent()) {
+ return Optional.empty();
+ }
+
+ List<RequirementAssignmentData> requirementAssignmentDataList = new ArrayList<>();
+ for (RequirementAssignment requirementAssignment : requirementAssignmentLink.get()) {
+ RequirementAssignmentData requirementAssignmentData = new RequirementAssignmentData
+ (requirementKey, requirementAssignment);
+ requirementAssignmentDataList.add(requirementAssignmentData);
+ }
+ return Optional.ofNullable(requirementAssignmentDataList);
+ }
+
+ public static Optional<List<RequirementAssignmentData>> getRequirementAssignmentDataList(
+ NodeTemplate nodeTemplate, String requirementKey) {
+ List<RequirementAssignmentData> returnedReqAssignmentDataList = new ArrayList<>();
+ Optional<List<RequirementAssignmentData>> requirementAssignmentDataList =
+ TestUtils.createRequirementAssignmentDataList(nodeTemplate, requirementKey);
+
+ if (requirementAssignmentDataList.isPresent()) {
+ for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList
+ .get()) {
+ returnedReqAssignmentDataList.add(requirementAssignmentData);
+ }
+ return Optional.of(returnedReqAssignmentDataList);
+ }
+ return Optional.empty();
+ }
+
+
+
}
Code Review / sdc.git / blobdiff