2 * Copyright © 2016-2018 European Support Limited
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 package org.openecomp.sdc.translator.services.heattotosca;
18 import java.util.ArrayList;
19 import java.util.HashMap;
20 import java.util.HashSet;
21 import java.util.List;
23 import java.util.Objects;
24 import java.util.Optional;
26 import org.apache.commons.collections4.CollectionUtils;
27 import org.apache.commons.collections4.MapUtils;
28 import org.onap.sdc.tosca.datatypes.model.GroupDefinition;
29 import org.onap.sdc.tosca.datatypes.model.ParameterDefinition;
30 import org.onap.sdc.tosca.datatypes.model.PropertyType;
31 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
32 import org.onap.sdc.tosca.datatypes.model.TopologyTemplate;
33 import org.onap.sdc.tosca.datatypes.model.heatextend.ParameterDefinitionExt;
34 import org.onap.sdc.tosca.services.YamlUtil;
35 import org.openecomp.core.translator.datatypes.TranslatorOutput;
36 import org.openecomp.core.utilities.file.FileUtils;
37 import org.openecomp.sdc.common.errors.CoreException;
38 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
39 import org.openecomp.sdc.heat.datatypes.model.Environment;
40 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
41 import org.openecomp.sdc.heat.datatypes.model.Output;
42 import org.openecomp.sdc.heat.datatypes.model.Resource;
43 import org.openecomp.sdc.logging.api.Logger;
44 import org.openecomp.sdc.logging.api.LoggerFactory;
45 import org.openecomp.sdc.tosca.csar.AsdPackageHelper;
46 import org.openecomp.sdc.tosca.csar.ManifestUtils;
47 import org.openecomp.sdc.tosca.datatypes.ToscaGroupType;
48 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
49 import org.openecomp.sdc.tosca.services.DataModelUtil;
50 import org.openecomp.sdc.tosca.services.ToscaConstants;
51 import org.openecomp.sdc.tosca.services.ToscaFileOutputService;
52 import org.openecomp.sdc.tosca.services.ToscaUtil;
53 import org.openecomp.sdc.tosca.services.impl.ToscaFileOutputServiceCsarImpl;
54 import org.openecomp.sdc.translator.datatypes.heattotosca.AttachedResourceId;
55 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
56 import org.openecomp.sdc.translator.datatypes.heattotosca.to.FileDataCollection;
57 import org.openecomp.sdc.translator.services.heattotosca.errors.ResourceNotFoundInHeatFileErrorBuilder;
58 import org.openecomp.sdc.translator.services.heattotosca.globaltypes.GlobalTypesGenerator;
59 import org.openecomp.sdc.translator.services.heattotosca.mapping.TranslatorHeatToToscaParameterConverter;
61 public class TranslationService {
63 protected static Logger logger = LoggerFactory.getLogger(TranslationService.class);
66 * Gets types to process by translator.
68 * @return the types to process by translator
70 public static Set<FileData.Type> getTypesToProcessByTranslator() {
71 Set<FileData.Type> types = new HashSet<>();
72 types.add(FileData.Type.HEAT);
73 types.add(FileData.Type.HEAT_VOL);
77 public static Set<FileData.Type> getTypesToProcessByHelmTranslator() {
78 Set<FileData.Type> types = new HashSet<>();
79 types.add(FileData.Type.HELM);
84 * Translate heat files translator output.
86 * @param translationContext the translation context
87 * @return the translator output
89 public TranslatorOutput translateHeatFiles(TranslationContext translationContext) {
90 ServiceTemplate mainServiceTemplate = createMainServiceTemplate(translationContext);
91 List<FileData> fileDataList = translationContext.getManifest().getContent().getData();
92 FileDataCollection fileDataCollection = HeatToToscaUtil
93 .getFileCollectionsByFilter(fileDataList, TranslationService.getTypesToProcessByTranslator(), translationContext);
94 FileDataCollection fileDataCollectionHelm = HeatToToscaUtil
95 .getFileCollectionsByHelmFilter(fileDataList, TranslationService.getTypesToProcessByHelmTranslator());
96 if (fileDataCollection.getBaseFile() != null) {
97 for (FileData fileData : fileDataCollection.getBaseFile()) {
98 translateHeatFile(mainServiceTemplate, fileData, translationContext);
101 if (fileDataCollection.getAddOnFiles() != null) {
102 for (FileData fileData : fileDataCollection.getAddOnFiles()) {
103 translateHeatFile(mainServiceTemplate, fileData, translationContext);
106 if (fileDataCollectionHelm.getHelmFile() != null) {
107 for (FileData fileData : fileDataCollectionHelm.getHelmFile()) {
108 translateHelmFile(mainServiceTemplate, fileData, translationContext);
111 ToscaServiceModel toscaServiceModel = HeatToToscaUtil.createToscaServiceModel(mainServiceTemplate, translationContext);
112 TranslatorOutput translatorOutput = new TranslatorOutput();
113 //Keeping a copy of tosca service model after first stage of translation for extraction of
116 translatorOutput.setNonUnifiedToscaServiceModel(ToscaServiceModel.getClonedServiceModel(toscaServiceModel));
117 translatorOutput.setToscaServiceModel(toscaServiceModel);
118 return translatorOutput;
121 private ServiceTemplate createMainServiceTemplate(TranslationContext translationContext) {
122 ServiceTemplate mainServiceTemplate = new ServiceTemplate();
123 translationContext.getTranslatedServiceTemplates().put(Constants.MAIN_TEMPLATE_NAME, mainServiceTemplate);
124 Map<String, String> templateMetadata = new HashMap<>();
125 templateMetadata.put(ToscaConstants.ST_METADATA_TEMPLATE_NAME, Constants.MAIN_TEMPLATE_NAME);
126 mainServiceTemplate.setTosca_definitions_version(ToscaConstants.TOSCA_DEFINITIONS_VERSION);
127 mainServiceTemplate.setMetadata(templateMetadata);
128 mainServiceTemplate.setTopology_template(new TopologyTemplate());
129 mainServiceTemplate.setImports(GlobalTypesGenerator.getGlobalTypesImportList());
130 return mainServiceTemplate;
134 * Translate heat file.
136 * @param serviceTemplate the service template
137 * @param heatFileData the heat file data
138 * @param context the context
140 public void translateHeatFile(ServiceTemplate serviceTemplate, FileData heatFileData, TranslationContext context) {
141 String heatFileName = heatFileData.getFile();
142 HeatOrchestrationTemplate heatOrchestrationTemplate = new YamlUtil()
143 .yamlToObject(context.getFileContentAsStream(heatFileName), HeatOrchestrationTemplate.class);
144 translateInputParameters(serviceTemplate, heatOrchestrationTemplate, heatFileData, context, heatFileName);
145 translateResources(heatFileName, serviceTemplate, heatOrchestrationTemplate, context);
146 translateOutputParameters(serviceTemplate, heatOrchestrationTemplate, heatFileData, heatFileName, context);
147 createHeatStackGroup(serviceTemplate, heatFileData, heatOrchestrationTemplate, context);
148 handleHeatPseudoParam(heatFileName, serviceTemplate, context);
149 if (Objects.nonNull(heatFileData.getData())) {
150 heatFileData.getData().stream().filter(data -> FileData.Type.canBeAssociated(data.getType()))
151 .forEach(data -> translateHeatFile(serviceTemplate, data, context));
155 public void translateHelmFile(ServiceTemplate serviceTemplate, FileData heatFileData, TranslationContext context) {
156 String heatFileName = heatFileData.getFile();
157 Map<String, ParameterDefinition> inputs = serviceTemplate.getTopology_template().getInputs();
158 if (Objects.nonNull(inputs)) {
159 inputs.entrySet().forEach(stringParameterDefinitionEntry -> {
160 List inputParamVFModuleList = getVFModulesList(inputs.get(stringParameterDefinitionEntry.getKey()));
161 if (!inputParamVFModuleList.contains(FileUtils.getFileWithoutExtention(heatFileName))) {
162 inputParamVFModuleList.add(FileUtils.getFileWithoutExtention(heatFileName));
165 inputs.putAll(inputs);
169 private void handleHeatPseudoParam(String heatFileName, ServiceTemplate serviceTemplate, TranslationContext context) {
170 Map<String, String> translatedHeatPseudoParam = context.getUsedHeatPseudoParams().get(heatFileName);
171 if (Objects.nonNull(translatedHeatPseudoParam)) {
172 for (String heatPseudoParam : translatedHeatPseudoParam.keySet()) {
173 if (!serviceTemplate.getTopology_template().getInputs().containsKey(heatPseudoParam)) {
174 ParameterDefinition parameterDefinition = new ParameterDefinition();
175 parameterDefinition.setType(PropertyType.STRING.getDisplayName());
176 parameterDefinition.setRequired(false);
177 String parameterDefinitionId = translatedHeatPseudoParam.get(heatPseudoParam);
178 DataModelUtil.addInputParameterToTopologyTemplate(serviceTemplate, parameterDefinitionId, parameterDefinition);
184 private void createHeatStackGroup(ServiceTemplate serviceTemplate, FileData heatFileData, HeatOrchestrationTemplate heatOrchestrationTemplate,
185 TranslationContext context) {
186 ToscaFileOutputService toscaFileOutputService = new ToscaFileOutputServiceCsarImpl(new AsdPackageHelper(new ManifestUtils()));
187 final String fileName = heatFileData.getFile();
188 final String heatStackGroupId = FileUtils.getFileWithoutExtention(fileName) + "_group";
189 GroupDefinition groupDefinition = new GroupDefinition();
190 groupDefinition.setType(ToscaGroupType.HEAT_STACK);
191 groupDefinition.setProperties(new HashMap<>());
192 groupDefinition.getProperties().put("heat_file", "../" + toscaFileOutputService.getArtifactsFolderName() + "/" + fileName);
193 String hotDescription = heatOrchestrationTemplate.getDescription();
194 if (hotDescription != null && !hotDescription.isEmpty()) {
195 groupDefinition.getProperties().put(Constants.DESCRIPTION_PROPERTY_NAME, hotDescription);
197 groupDefinition.setMembers(new ArrayList<>());
198 Set<String> heatStackGroupMembersIds = getHeatStackGroupMembers(fileName, serviceTemplate, context);
199 if (CollectionUtils.isEmpty(heatStackGroupMembersIds)) {
200 return; //not creating a group when no resources are present in the heat input
202 groupDefinition.getMembers().addAll(heatStackGroupMembersIds);
203 DataModelUtil.addGroupDefinitionToTopologyTemplate(serviceTemplate, heatStackGroupId, groupDefinition);
206 private Set<String> getHeatStackGroupMembers(String heatFileName, ServiceTemplate serviceTemplate, TranslationContext context) {
207 Map<String, Set<String>> heatStackGroupMembers = context.getHeatStackGroupMembers();
208 Set<String> groupMembers = MapUtils.isEmpty(heatStackGroupMembers) ? new HashSet<>() : heatStackGroupMembers.get(heatFileName);
209 if (CollectionUtils.isEmpty(groupMembers)) {
210 return new HashSet<>();
212 Set<String> updatedMembersIds = new HashSet<>();
213 groupMembers.forEach(member -> {
214 if (Objects.nonNull(DataModelUtil.getNodeTemplate(serviceTemplate, member))) {
215 updatedMembersIds.add(member);
217 updateSubstitutableGroupMemberId(heatFileName, serviceTemplate, updatedMembersIds);
220 return updatedMembersIds;
223 private void updateSubstitutableGroupMemberId(String heatFileName, ServiceTemplate serviceTemplate, Set<String> updatedMembersIds) {
224 Optional<String> substitutableGroupMemberId = ToscaUtil.getSubstitutableGroupMemberId(heatFileName, serviceTemplate);
225 substitutableGroupMemberId.ifPresent(updatedMembersIds::add);
228 private void translateInputParameters(ServiceTemplate serviceTemplate, HeatOrchestrationTemplate heatOrchestrationTemplate, FileData heatFileData,
229 TranslationContext context, String heatFileName) {
230 if (heatOrchestrationTemplate.getParameters() == null) {
233 final Environment heatEnvFile = getHeatEnvFile(heatFileData, context);
234 final Map<String, Object> parameters = heatEnvFile.getParameters();
235 Map<String, ParameterDefinition> parameterDefinitionMap = TranslatorHeatToToscaParameterConverter
236 .parameterConverter(serviceTemplate, heatOrchestrationTemplate.getParameters(), heatOrchestrationTemplate, heatFileName,
237 heatFileData.getParentFile(), context, parameters);
238 Object parameterValue;
239 if (parameters != null) {
240 for (Map.Entry<String, ParameterDefinition> entry : parameterDefinitionMap.entrySet()) {
241 String paramName = entry.getKey();
242 parameterValue = parameters.get(paramName);
243 if (parameterValue != null) {
244 entry.getValue().set_default(TranslatorHeatToToscaParameterConverter
245 .getToscaParameterDefaultValue(null, null, parameterValue, entry.getValue().getType(), heatFileName,
246 heatOrchestrationTemplate, context));
250 Map<String, ParameterDefinition> inputs = serviceTemplate.getTopology_template().getInputs();
251 if (Objects.isNull(inputs)) {
252 serviceTemplate.getTopology_template().setInputs(parameterDefinitionMap);
254 setInputs(inputs, parameterDefinitionMap);
258 private void setInputs(Map<String, ParameterDefinition> inputs, Map<String, ParameterDefinition> newParameters) {
259 updateAnnotations(inputs, newParameters);
260 inputs.putAll(newParameters);
263 private void updateAnnotations(Map<String, ParameterDefinition> inputParameters, Map<String, ParameterDefinition> newParameters) {
264 newParameters.entrySet().stream().filter(
265 stringParameterDefinitionEntry -> inputParameters.containsKey(stringParameterDefinitionEntry.getKey()) && isHasAnnotation(inputParameters,
266 stringParameterDefinitionEntry)).forEach(stringParameterDefinitionEntry -> {
267 List inputParamVFModuleList = getVFModulesList(inputParameters.get(stringParameterDefinitionEntry.getKey()));
268 List newParamVFModuleList = getVFModulesList(stringParameterDefinitionEntry.getValue());
269 if (inputParamVFModuleList.contains(newParamVFModuleList.get(0))) {
270 newParamVFModuleList.remove(0);
272 newParamVFModuleList.addAll(inputParamVFModuleList);
276 private boolean isHasAnnotation(Map<String, ParameterDefinition> inputParameters, Map.Entry<String, ParameterDefinition> newParameterSet) {
277 ParameterDefinitionExt inputParameter = (ParameterDefinitionExt) inputParameters.get(newParameterSet.getKey());
278 ParameterDefinitionExt newParameter = (ParameterDefinitionExt) newParameterSet.getValue();
279 return inputParameter.getAnnotations() != null && newParameter.getAnnotations() != null;
282 private List getVFModulesList(ParameterDefinition param) {
283 ParameterDefinitionExt parameterDefinitionExt = (ParameterDefinitionExt) param;
284 return (List) parameterDefinitionExt.getAnnotations().get(ToscaConstants.SOURCE_ANNOTATION_ID).getProperties()
285 .get(ToscaConstants.VF_MODULE_LABEL_PROPERTY_NAME);
288 private void translateOutputParameters(ServiceTemplate serviceTemplate, HeatOrchestrationTemplate heatOrchestrationTemplate,
289 FileData heatFileData, String heatFileName, TranslationContext context) {
290 if (heatOrchestrationTemplate.getOutputs() == null) {
293 Map<String, ParameterDefinition> parameterDefinitionMap = TranslatorHeatToToscaParameterConverter
294 .parameterOutputConverter(serviceTemplate, heatOrchestrationTemplate.getOutputs(), heatOrchestrationTemplate, heatFileName, context);
295 if (serviceTemplate.getTopology_template().getOutputs() != null) {
296 serviceTemplate.getTopology_template().getOutputs().putAll(parameterDefinitionMap);
298 serviceTemplate.getTopology_template().setOutputs(parameterDefinitionMap);
300 if (heatFileData.getBase() != null && heatFileData.getBase().equals(true)) {
301 updateSharedResources(serviceTemplate, heatFileName, heatOrchestrationTemplate, heatOrchestrationTemplate.getOutputs(), context);
305 private void updateSharedResources(ServiceTemplate serviceTemplate, String heatFileName, HeatOrchestrationTemplate heatOrchestrationTemplate,
306 Map<String, Output> outputs, TranslationContext context) {
307 for (Map.Entry<String, Output> parameter : outputs.entrySet()) {
308 Optional<AttachedResourceId> attachedSharedResourceId = HeatToToscaUtil
309 .extractAttachedResourceId(heatFileName, heatOrchestrationTemplate, context, parameter.getValue().getValue());
310 if (attachedSharedResourceId.isPresent() && attachedSharedResourceId.get().isGetResource()
311 && attachedSharedResourceId.get().getTranslatedId() != null) {
312 String sharedTranslatedResourceId = attachedSharedResourceId.get().getTranslatedId().toString();
313 updateSharedResource(serviceTemplate, context, parameter, sharedTranslatedResourceId,
314 heatOrchestrationTemplate.getResources().get(attachedSharedResourceId.get().getEntityId()));
316 Optional<String> contrailSharedResourceId = HeatToToscaUtil
317 .extractContrailGetResourceAttachedHeatResourceId(parameter.getValue().getValue());
318 if (contrailSharedResourceId.isPresent()
319 && context.getTranslatedIds().get(heatFileName).get(contrailSharedResourceId.get()) != null) {
320 String sharedTranslatedResourceId = context.getTranslatedIds().get(heatFileName).get(contrailSharedResourceId.get());
321 ConsolidationDataUtil
322 .removeSharedResource(serviceTemplate, heatOrchestrationTemplate, context, parameter.getKey(), contrailSharedResourceId.get(),
323 sharedTranslatedResourceId);
324 updateSharedResource(serviceTemplate, context, parameter, sharedTranslatedResourceId,
325 heatOrchestrationTemplate.getResources().get(contrailSharedResourceId.get()));
329 if (serviceTemplate.getTopology_template().getOutputs() != null && serviceTemplate.getTopology_template().getOutputs().size() == 0) {
330 serviceTemplate.getTopology_template().setOutputs(null);
334 private void updateSharedResource(ServiceTemplate serviceTemplate, TranslationContext context, Map.Entry<String, Output> paramName,
335 String sharedTranslatedResourceId, Resource resource) {
336 context.addHeatSharedResourcesByParam(paramName.getKey(), sharedTranslatedResourceId, resource);
337 serviceTemplate.getTopology_template().getOutputs().remove(paramName.getKey());
340 private void translateResources(String heatFileName, ServiceTemplate serviceTemplate, HeatOrchestrationTemplate heatOrchestrationTemplate,
341 TranslationContext context) {
342 if (MapUtils.isEmpty(heatOrchestrationTemplate.getResources())) {
345 for (String resourceId : heatOrchestrationTemplate.getResources().keySet()) {
346 Resource resource = heatOrchestrationTemplate.getResources().get(resourceId);
347 if (resource == null) {
348 throw new CoreException(new ResourceNotFoundInHeatFileErrorBuilder(resourceId, heatFileName).build());
350 ResourceTranslationFactory.getInstance(resource)
351 .translateResource(heatFileName, serviceTemplate, heatOrchestrationTemplate, resource, resourceId, context);
355 private Environment getHeatEnvFile(FileData heatFileData, TranslationContext context) {
356 List<FileData> fileRelatedDataList = heatFileData.getData();
357 if (fileRelatedDataList == null) {
358 return new Environment();
360 for (FileData fileRelatedData : fileRelatedDataList) {
361 if (fileRelatedData.getType().equals(FileData.Type.HEAT_ENV)) {
362 return new YamlUtil().yamlToObject(context.getFileContentAsStream(fileRelatedData.getFile()), Environment.class);
365 return new Environment();