3 * * ============LICENSE_START=======================================================
4 * * Copyright (C) 2019 Nordix Foundation.
5 * * ================================================================================
6 * * Licensed under the Apache License, Version 2.0 (the "License");
7 * * you may not use this file except in compliance with the License.
8 * * You may obtain a copy of the License at
10 * * http://www.apache.org/licenses/LICENSE-2.0
12 * * Unless required by applicable law or agreed to in writing, software
13 * * distributed under the License is distributed on an "AS IS" BASIS,
14 * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * * See the License for the specific language governing permissions and
16 * * limitations under the License.
18 * * SPDX-License-Identifier: Apache-2.0
19 * * ============LICENSE_END=========================================================
23 package org.openecomp.core.impl;
25 import static org.openecomp.core.converter.datatypes.Constants.ONAP_INDEX;
26 import static org.openecomp.core.converter.datatypes.Constants.definitionsDir;
27 import static org.openecomp.core.converter.datatypes.Constants.globalStName;
28 import static org.openecomp.core.converter.datatypes.Constants.globalSubstitution;
29 import static org.openecomp.core.converter.datatypes.Constants.mainStName;
30 import static org.openecomp.core.converter.datatypes.Constants.openecompHeatIndex;
31 import static org.openecomp.core.impl.GlobalSubstitutionServiceTemplate.GLOBAL_SUBSTITUTION_SERVICE_FILE_NAME;
32 import static org.openecomp.core.impl.GlobalSubstitutionServiceTemplate.HEAT_INDEX_IMPORT_FILE;
33 import static org.openecomp.core.impl.GlobalSubstitutionServiceTemplate.ONAP_INDEX_IMPORT_FILE;
34 import static org.openecomp.sdc.tosca.csar.CSARConstants.TOSCA_META_ORIG_PATH_FILE_NAME;
35 import static org.openecomp.sdc.tosca.csar.ToscaMetadataFileInfo.TOSCA_META_PATH_FILE_NAME;
37 import java.util.ArrayList;
38 import java.util.Collection;
39 import java.util.HashMap;
40 import java.util.List;
42 import java.util.Objects;
43 import java.util.Optional;
44 import java.util.regex.Pattern;
45 import javax.validation.constraints.NotNull;
46 import org.apache.commons.collections.MapUtils;
47 import org.onap.sdc.tosca.datatypes.model.DataType;
48 import org.onap.sdc.tosca.datatypes.model.Import;
49 import org.onap.sdc.tosca.datatypes.model.NodeType;
50 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
51 import org.openecomp.core.converter.ServiceTemplateReaderService;
52 import org.openecomp.core.converter.ToscaConverter;
53 import org.openecomp.core.converter.datatypes.CsarFileTypes;
54 import org.openecomp.core.impl.services.ServiceTemplateReaderServiceImpl;
55 import org.openecomp.core.utilities.file.FileContentHandler;
56 import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
57 import org.openecomp.sdc.common.errors.CoreException;
58 import org.openecomp.sdc.common.errors.ErrorCategory;
59 import org.openecomp.sdc.common.errors.ErrorCode;
60 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
61 import org.openecomp.sdc.tosca.services.DataModelUtil;
62 import org.openecomp.sdc.tosca.services.ToscaUtil;
63 import org.openecomp.sdc.translator.services.heattotosca.globaltypes.GlobalTypesGenerator;
64 import org.slf4j.Logger;
65 import org.slf4j.LoggerFactory;
66 import org.yaml.snakeyaml.error.YAMLException;
68 public abstract class AbstractToscaConverter implements ToscaConverter {
69 private static final Logger LOGGER = LoggerFactory.getLogger(AbstractToscaConverter.class);
71 public abstract void convertTopologyTemplate(@NotNull ServiceTemplate serviceTemplate,
72 ServiceTemplateReaderService readerService);
74 protected void handleMetadataFile(Map<String, byte[]> csarFiles) {
75 byte[] bytes = csarFiles.remove(TOSCA_META_PATH_FILE_NAME);
77 csarFiles.put(TOSCA_META_ORIG_PATH_FILE_NAME, bytes);
81 protected void handleDefinitionTemplate(String key, Map<String, byte[]> csarFiles,
82 GlobalSubstitutionServiceTemplate gsst) {
84 ServiceTemplateReaderService readerService = new ServiceTemplateReaderServiceImpl(csarFiles.get(key));
85 Object nodeTypes = readerService.getNodeTypes();
86 if (nodeTypes instanceof Map) {
87 Map<String, NodeType> nodeTypeMap = (Map<String, NodeType>) nodeTypes;
88 gsst.appendNodes(nodeTypeMap);
90 gsst.appendDataTypes((Map) readerService.getDataTypes());
91 } catch (YAMLException ye) {
92 throw new CoreException(new ErrorCode.ErrorCodeBuilder()
93 .withMessage("Invalid YAML content in file " + key)
94 .withCategory(ErrorCategory.APPLICATION).build(), ye);
98 protected String getConcreteArtifactFileName(String fileName) {
99 int artifactIndex = fileName.indexOf(CsarFileTypes.Artifacts.name());
100 if (artifactIndex < 0) {
104 int artifactDirectoryIndex =
105 artifactIndex + CsarFileTypes.Artifacts.name().length() + 1;
106 return fileName.substring(artifactDirectoryIndex);
109 protected void updateToscaServiceModel(ToscaServiceModel toscaServiceModel,
110 Map<String, ServiceTemplate> serviceTemplates,
111 FileContentHandler externalFilesHandler,
112 GlobalSubstitutionServiceTemplate globalSubstitutionServiceTemplate,
113 Map<String, byte[]> csarFiles, String entryDefinitionServiceTemplateName) {
114 Collection<ServiceTemplate> globalServiceTemplates =
115 GlobalTypesGenerator.getGlobalTypesServiceTemplate(OnboardingTypesEnum.CSAR).values();
116 addGlobalServiceTemplates(globalServiceTemplates, serviceTemplates);
117 toscaServiceModel.setServiceTemplates(serviceTemplates);
118 toscaServiceModel.setEntryDefinitionServiceTemplate(entryDefinitionServiceTemplateName);
119 externalFilesHandler.addFile(TOSCA_META_ORIG_PATH_FILE_NAME,
120 csarFiles.get(TOSCA_META_ORIG_PATH_FILE_NAME));
121 toscaServiceModel.setArtifactFiles(externalFilesHandler);
123 if (MapUtils.isNotEmpty(globalSubstitutionServiceTemplate.getNode_types())) {
125 .put(GLOBAL_SUBSTITUTION_SERVICE_FILE_NAME, globalSubstitutionServiceTemplate);
129 private void addGlobalServiceTemplates(Collection<ServiceTemplate> globalServiceTemplates,
130 Map<String, ServiceTemplate> serviceTemplates) {
131 for (ServiceTemplate serviceTemplate : globalServiceTemplates) {
132 serviceTemplates.put(ToscaUtil.getServiceTemplateFileName(serviceTemplate), serviceTemplate);
136 protected void handleServiceTemplate(String serviceTemplateName,
137 String fileName, Map<String, byte[]> csarFiles,
138 Map<String, ServiceTemplate> serviceTemplates) {
139 final byte[] inputServiceTemplate = getServiceTemplateFromCsar(fileName, csarFiles);
140 Optional<ServiceTemplate> serviceTemplate = convertServiceTemplate(fileName, inputServiceTemplate);
141 serviceTemplate.ifPresent(
142 serviceTemplateValue -> addServiceTemplate(serviceTemplateName, serviceTemplateValue,
146 private void addServiceTemplate(String serviceTemplateName,
147 ServiceTemplate serviceTemplate,
148 Map<String, ServiceTemplate> serviceTemplates) {
149 serviceTemplates.put(serviceTemplateName, serviceTemplate);
152 private byte[] getServiceTemplateFromCsar(String fileName, Map<String, byte[]> csarFiles) {
153 return csarFiles.get(fileName);
156 private Optional<ServiceTemplate> convertServiceTemplate(String serviceTemplateName,
157 byte[] fileContent) {
158 ServiceTemplate serviceTemplate = new ServiceTemplate();
160 ServiceTemplateReaderService readerService =
161 new ServiceTemplateReaderServiceImpl(fileContent);
162 convertMetadata(serviceTemplateName, serviceTemplate, readerService);
163 convertToscaVersion(serviceTemplate, readerService);
164 convertImports(serviceTemplate);
165 convertNodeTypes(serviceTemplate, readerService);
166 convertDataTypes(serviceTemplate, readerService);
167 convertTopologyTemplate(serviceTemplate, readerService);
168 } catch (YAMLException ye) {
169 throw new CoreException(new ErrorCode.ErrorCodeBuilder()
170 .withMessage("Invalid YAML content in file" + serviceTemplateName)
171 .withCategory(ErrorCategory.APPLICATION).build(), ye);
175 return Optional.of(serviceTemplate);
178 private void convertToscaVersion(ServiceTemplate serviceTemplate,
179 ServiceTemplateReaderService readerService) {
180 Object toscaVersion = readerService.getToscaVersion();
181 serviceTemplate.setTosca_definitions_version((String) toscaVersion);
184 private void convertImports(ServiceTemplate serviceTemplate) {
185 List<Map<String, Import>> imports = new ArrayList<>();
186 imports.add(createImportMap(openecompHeatIndex, HEAT_INDEX_IMPORT_FILE));
187 imports.add(createImportMap(ONAP_INDEX, ONAP_INDEX_IMPORT_FILE));
188 imports.add(createImportMap(globalSubstitution, globalStName));
189 serviceTemplate.setImports(imports);
192 private Map<String, Import> createImportMap(String key, String fileName) {
193 Map<String, Import> importMap = new HashMap<>();
194 Import anImport = new Import();
195 anImport.setFile(fileName);
196 importMap.put(key, anImport);
201 private void convertMetadata(String serviceTemplateName,
202 ServiceTemplate serviceTemplate,
203 ServiceTemplateReaderService readerService) {
204 Map<String, Object> metadataToConvert = (Map<String, Object>) readerService.getMetadata();
205 Map<String, String> finalMetadata = new HashMap<>();
207 if (MapUtils.isNotEmpty(metadataToConvert)) {
208 for (Map.Entry<String, Object> metadataEntry : metadataToConvert.entrySet()) {
209 if (Objects.isNull(metadataEntry.getValue()) ||
210 !(metadataEntry.getValue() instanceof String)) {
213 finalMetadata.put(metadataEntry.getKey(), (String) metadataEntry.getValue());
217 finalMetadata.put("template_name", getTemplateNameFromStName(serviceTemplateName));
218 serviceTemplate.setMetadata(finalMetadata);
221 protected void convertNodeTypes(ServiceTemplate serviceTemplate, ServiceTemplateReaderService readerService) {
222 Map<String, Object> nodeTypes = readerService.getNodeTypes();
223 if (MapUtils.isEmpty(nodeTypes)) {
227 for (Map.Entry<String, Object> nodeTypeEntry : nodeTypes.entrySet()) {
228 Optional<NodeType> nodeType = ToscaConverterUtil
229 .createObjectFromClass(nodeTypeEntry.getKey(), nodeTypeEntry.getValue(),
232 nodeType.ifPresent(nodeTypeValue -> DataModelUtil
233 .addNodeType(serviceTemplate, nodeTypeEntry.getKey(), nodeTypeValue));
237 protected void convertDataTypes(final ServiceTemplate serviceTemplate,
238 final ServiceTemplateReaderService readerService) {
240 final Map<String, Object> dataTypes = readerService.getDataTypes();
241 for (final Map.Entry<String, Object> entry : dataTypes.entrySet()) {
242 final Optional<DataType> dataType =
243 ToscaConverterUtil.createObjectFromClass(entry.getKey(), entry.getValue(), DataType.class);
246 nodeTypeValue -> DataModelUtil.addDataType(serviceTemplate, entry.getKey(), nodeTypeValue));
248 } catch (final Exception ex) {
249 LOGGER.error("Unable to process data types: ", ex);
253 protected CsarFileTypes getFileType(String fileName) {
254 if (isMainServiceTemplate(fileName)) {
255 return CsarFileTypes.mainServiceTemplate;
256 } else if (isGlobalServiceTemplate(fileName)) {
257 return CsarFileTypes.globalServiceTemplate;
258 } else if (isDefinitions(fileName)) {
259 return CsarFileTypes.definitionsFile;
260 } else if (isMetadataFile(fileName)) {
261 return CsarFileTypes.toscaMetadata;
263 return CsarFileTypes.externalFile;
266 protected boolean isMainServiceTemplate(String fileName) {
267 return fileName.endsWith(mainStName);
270 protected boolean isMetadataFile(String fileName) {
271 return fileName.equals(TOSCA_META_PATH_FILE_NAME);
274 protected boolean isGlobalServiceTemplate(String fileName) {
275 return fileName.endsWith(globalStName);
278 protected boolean isDefinitions(String fileName) {
279 return fileName.startsWith(definitionsDir);
282 private String getTemplateNameFromStName(String serviceTemplateName) {
283 String fileNameWithoutDirectories = getFileNameWithoutDirectories(serviceTemplateName);
284 return fileNameWithoutDirectories.split("ServiceTemplate")[0];
287 private String getFileNameWithoutDirectories(String serviceTemplateName) {
288 String fileNameWithoutDirectories;
289 if (serviceTemplateName.contains("/")) {
290 String[] split = serviceTemplateName.split("/");
291 fileNameWithoutDirectories = split[split.length - 1];
292 } else if (serviceTemplateName.contains(File.separator)) {
293 String[] split = serviceTemplateName.split(Pattern.quote(File.separator));
294 fileNameWithoutDirectories = split[split.length - 1];
296 fileNameWithoutDirectories = serviceTemplateName;
298 return fileNameWithoutDirectories;