openecomp-be/lib/openecomp-tosca-converter-lib/openecomp-tosca-converter-core/src/main/java/org/openecomp/core/impl/ToscaConverterImpl.java

   1 package org.openecomp.core.impl;
   2
   3 import org.apache.commons.collections.MapUtils;
   4 import org.openecomp.core.converter.ServiceTemplateReaderService;
   5 import org.openecomp.core.converter.ToscaConverter;
   6 import org.openecomp.core.converter.datatypes.Constants;
   7 import org.openecomp.core.converter.datatypes.CsarFileTypes;
   8 import org.openecomp.core.impl.services.ServiceTemplateReaderServiceImpl;
   9 import org.openecomp.core.utilities.file.FileContentHandler;
  10 import org.openecomp.core.utilities.json.JsonUtil;
  11 import org.openecomp.sdc.common.errors.CoreException;
  12 import org.openecomp.sdc.common.errors.ErrorCategory;
  13 import org.openecomp.sdc.common.errors.ErrorCode;
  14 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
  15 import org.openecomp.sdc.tosca.datatypes.model.*;
  16 import org.openecomp.sdc.tosca.services.DataModelUtil;
  17 import org.openecomp.sdc.tosca.services.ToscaUtil;
  18 import org.openecomp.sdc.translator.services.heattotosca.globaltypes.GlobalTypesGenerator;
  19 import org.yaml.snakeyaml.error.YAMLException;
  20
  21 import java.io.ByteArrayInputStream;
  22 import java.io.File;
  23 import java.io.IOException;
  24 import java.util.*;
  25 import java.util.jar.Manifest;
  26 import java.util.regex.Pattern;
  27
  28 import static org.openecomp.core.converter.datatypes.Constants.*;
  29 import static org.openecomp.core.impl.GlobalSubstitutionServiceTemplate.GLOBAL_SUBSTITUTION_SERVICE_FILE_NAME;
  30
  31 public class ToscaConverterImpl implements ToscaConverter {
  32
  33     public ToscaConverterImpl() {
  34
  35     }
  36
  37     @Override
  38     public ToscaServiceModel convert(FileContentHandler fileContentHandler)
  39             throws IOException {
  40         Map<String, byte[]> csarFiles = new HashMap<>(fileContentHandler.getFiles());
  41         ToscaServiceModel toscaServiceModel = new ToscaServiceModel();
  42         Map<String, ServiceTemplate> serviceTemplates = new HashMap<>();
  43         FileContentHandler artifacts = new FileContentHandler();
  44         GlobalSubstitutionServiceTemplate gsst = new GlobalSubstitutionServiceTemplate();
  45         for (Map.Entry<String, byte[]> fileEntry : csarFiles.entrySet()) {
  46             CsarFileTypes fileType = getFileType(fileEntry.getKey());
  47             switch (fileType) {
  48                 case mainServiceTemplate:
  49                     handleServiceTemplate(mainStName, fileEntry.getKey(), csarFiles, serviceTemplates);
  50                     break;
  51
  52                 case globalServiceTemplate:
  53                     handleServiceTemplate(globalStName, fileEntry.getKey(), csarFiles, serviceTemplates);
  54                     break;
  55
  56                 case externalFile:
  57                     artifacts.addFile(fileEntry.getKey(), fileEntry.getValue());
  58                     break;
  59
  60                 case definitionsFile:
  61                     handleDefintionTemplate(fileEntry.getKey(), csarFiles, gsst);
  62                     break;
  63             }
  64         }
  65         handleMetadataFile(csarFiles);
  66         updateToscaServiceModel(toscaServiceModel, serviceTemplates, artifacts, gsst, csarFiles);
  67         return toscaServiceModel;
  68     }
  69
  70     private void handleMetadataFile(Map<String, byte[]> csarFiles) {
  71         byte[] bytes = csarFiles.remove(metadataFile);
  72         if (bytes != null) {
  73             csarFiles.put(metadataFile + ".old", bytes);
  74         }
  75     }
  76
  77     private void handleDefintionTemplate(String key, Map<String, byte[]> csarFiles,
  78                                          GlobalSubstitutionServiceTemplate gsst) {
  79         try {
  80             ServiceTemplateReaderService readerService = new ServiceTemplateReaderServiceImpl(csarFiles.get(key));
  81             if (readerService == null) {
  82                 return;
  83             }
  84             Object nodeTypes = readerService.getNodeTypes();
  85             if (nodeTypes instanceof Map) {
  86                 Map<String, NodeType> nodeTypeMap = (Map<String, NodeType>) nodeTypes;
  87                 gsst.appendNodes(nodeTypeMap);
  88             }
  89         } catch (YAMLException ye) {
  90             throw new CoreException(new ErrorCode.ErrorCodeBuilder()
  91                     .withMessage("Invalid YAML content in file " + key + ". reason - "
  92                             + ye.getMessage())
  93                     .withCategory(ErrorCategory.APPLICATION).build());
  94         }
  95     }
  96
  97     private void updateToscaServiceModel(ToscaServiceModel toscaServiceModel,
  98                                          Map<String, ServiceTemplate> serviceTemplates,
  99                                          FileContentHandler externalFilesHandler,
 100                                          GlobalSubstitutionServiceTemplate globalSubstitutionServiceTemplate,
 101                                          Map<String, byte[]> csarFiles) {
 102         Collection<ServiceTemplate> globalServiceTemplates =
 103                 GlobalTypesGenerator.getGlobalTypesServiceTemplate().values();
 104         addGlobalServiceTemplates(globalServiceTemplates, serviceTemplates);
 105         serviceTemplates.put(GLOBAL_SUBSTITUTION_SERVICE_FILE_NAME, globalSubstitutionServiceTemplate);
 106         toscaServiceModel.setEntryDefinitionServiceTemplate(mainStName);
 107         toscaServiceModel.setServiceTemplates(serviceTemplates);
 108         externalFilesHandler.addFile(metadataFile + ".old", csarFiles.get(metadataFile + ".old"));
 109         toscaServiceModel.setArtifactFiles(externalFilesHandler);
 110     }
 111
 112     private void addGlobalServiceTemplates(Collection<ServiceTemplate> globalServiceTemplates,
 113                                            Map<String, ServiceTemplate> serviceTemplates) {
 114         for (ServiceTemplate serviceTemplate : globalServiceTemplates) {
 115             serviceTemplates.put(ToscaUtil.getServiceTemplateFileName(serviceTemplate), serviceTemplate);
 116         }
 117     }
 118
 119     private void handleServiceTemplate(String serviceTemplateName,
 120                                        String fileName, Map<String, byte[]> csarFiles,
 121                                        Map<String, ServiceTemplate> serviceTemplates) {
 122         Optional<ServiceTemplate> serviceTemplate =
 123                 getServiceTemplateFromCsar(fileName, csarFiles);
 124         serviceTemplate.ifPresent(
 125                 serviceTemplate1 -> addServiceTemplate(serviceTemplateName, serviceTemplate1,
 126                         serviceTemplates));
 127     }
 128
 129     private void addServiceTemplate(String serviceTemplateName,
 130                                     ServiceTemplate serviceTemplate,
 131                                     Map<String, ServiceTemplate> serviceTemplates) {
 132         serviceTemplates.put(serviceTemplateName, serviceTemplate);
 133     }
 134
 135     private Optional<byte[]> getManifestContent(Map<String, byte[]> csarFiles) {
 136         for (Map.Entry<String, byte[]> csarFileEntry : csarFiles.entrySet()) {
 137             if (csarFileEntry.getKey().contains(manifestFileName)) {
 138                 return Optional.of(csarFileEntry.getValue());
 139             }
 140         }
 141
 142         return Optional.empty();
 143     }
 144
 145     private Optional<ServiceTemplate> getServiceTemplateFromCsar(String fileName,
 146                                                                  Map<String, byte[]> csarFiles) {
 147         byte[] fileContent = csarFiles.get(fileName);
 148         ServiceTemplate serviceTemplate = convertServiceTemplate(fileName, fileContent);
 149
 150         return Optional.of(serviceTemplate);
 151     }
 152
 153     private ServiceTemplate convertServiceTemplate(String serviceTemplateName,
 154                                                    byte[] fileContent) {
 155         ServiceTemplate serviceTemplate = new ServiceTemplate();
 156         try {
 157             ServiceTemplateReaderService readerService =
 158                     new ServiceTemplateReaderServiceImpl(fileContent);
 159             convertMetadata(serviceTemplateName, serviceTemplate, readerService);
 160             convertToscaVersion(serviceTemplate, readerService);
 161             convertImports(serviceTemplate);
 162             convertNodeTypes(serviceTemplate, readerService);
 163             convertTopologyTemplate(serviceTemplate, readerService);
 164
 165         } catch (YAMLException ye) {
 166             throw new CoreException(new ErrorCode.ErrorCodeBuilder()
 167                     .withMessage("Invalid YAML content in file" + serviceTemplateName + ". reason - "
 168                             + ye.getMessage())
 169                     .withCategory(ErrorCategory.APPLICATION).build());
 170         }
 171
 172
 173         return serviceTemplate;
 174     }
 175
 176     private void convertToscaVersion(ServiceTemplate serviceTemplate,
 177                                      ServiceTemplateReaderService readerService) {
 178         Object toscaVersion = readerService.getToscaVersion();
 179         serviceTemplate.setTosca_definitions_version((String) toscaVersion);
 180     }
 181
 182     private void convertImports(ServiceTemplate serviceTemplate) {
 183         serviceTemplate.setImports(new ArrayList<>());
 184         serviceTemplate.getImports()
 185                 .add(createImportMap(openecompHeatIndex, "openecomp-heat/_index.yml"));
 186         serviceTemplate.getImports().add(createImportMap(globalSubstitution, globalStName));
 187
 188     }
 189
 190     private Map<String, Import> createImportMap(String key, String fileName) {
 191         Map<String, Import> importMap = new HashMap<>();
 192         Import anImport = new Import();
 193         anImport.setFile(fileName);
 194         importMap.put(key, anImport);
 195
 196         return importMap;
 197     }
 198
 199     private void convertMetadata(String serviceTemplateName,
 200                                  ServiceTemplate serviceTemplate,
 201                                  ServiceTemplateReaderService readerService) {
 202         Map<String, Object> metadataToConvert = (Map<String, Object>) readerService.getMetadata();
 203         Map<String, String> finalMetadata = new HashMap<>();
 204
 205         if (MapUtils.isNotEmpty(metadataToConvert)) {
 206             for (Map.Entry<String, Object> metadataEntry : metadataToConvert.entrySet()) {
 207                 if (Objects.isNull(metadataEntry.getValue()) ||
 208                         !(metadataEntry.getValue() instanceof String)) {
 209                     continue;
 210                 }
 211                 finalMetadata.put(metadataEntry.getKey(), (String) metadataEntry.getValue());
 212             }
 213         }
 214
 215         finalMetadata.put("template_name", getTemplateNameFromStName(serviceTemplateName));
 216         serviceTemplate.setMetadata(finalMetadata);
 217     }
 218
 219     private void convertNodeTypes(ServiceTemplate serviceTemplate, ServiceTemplateReaderService readerService) {
 220         Map<String, Object> nodeTypes = (Map<String, Object>) readerService.getNodeTypes();
 221         if (MapUtils.isEmpty(nodeTypes)) {
 222             return;
 223         }
 224
 225         for (Map.Entry<String, Object> nodeTypeEntry : nodeTypes.entrySet()) {
 226             DataModelUtil
 227                     .addNodeType(serviceTemplate, nodeTypeEntry.getKey(),
 228                             (NodeType) createObjectFromClass(nodeTypeEntry.getKey(), nodeTypeEntry.getValue(),
 229                                     NodeType.class));
 230         }
 231     }
 232
 233     private void convertTopologyTemplate(ServiceTemplate serviceTemplate,
 234                                          ServiceTemplateReaderService readerService) {
 235
 236         convertInputs(serviceTemplate, readerService);
 237         convertNodeTemplates(serviceTemplate, readerService);
 238         convertOutputs(serviceTemplate, readerService);
 239         convertSubstitutionMappings(serviceTemplate, readerService);
 240     }
 241
 242     private void convertInputs(ServiceTemplate serviceTemplate,
 243                                ServiceTemplateReaderService readerService) {
 244         Map<String, Object> inputs = readerService.getInputs();
 245         addInputsOrOutputsToServiceTemplate(serviceTemplate, inputs, Constants.inputs);
 246     }
 247
 248     private void convertOutputs(ServiceTemplate serviceTemplate,
 249                                 ServiceTemplateReaderService readerService) {
 250         Map<String, Object> outputs = readerService.getOutputs();
 251         addInputsOrOutputsToServiceTemplate(serviceTemplate, outputs, Constants.outputs);
 252     }
 253
 254     private void addInputsOrOutputsToServiceTemplate(ServiceTemplate serviceTemplate,
 255                                                      Map<String, Object> mapToConvert,
 256                                                      String inputsOrOutputs) {
 257         if (MapUtils.isEmpty(mapToConvert)) {
 258             return;
 259         }
 260
 261         for (Map.Entry<String, Object> entry : mapToConvert.entrySet()) {
 262             ParameterDefinition parameterDefinition =
 263                     (ParameterDefinition) createObjectFromClass(
 264                             entry.getKey(), entry.getValue(), ParameterDefinition.class);
 265             addToServiceTemplateAccordingToSection(
 266                     serviceTemplate, inputsOrOutputs, entry.getKey(), parameterDefinition);
 267         }
 268     }
 269
 270     private void addToServiceTemplateAccordingToSection(ServiceTemplate serviceTemplate,
 271                                                         String inputsOrOutputs,
 272                                                         String parameterId,
 273                                                         ParameterDefinition parameterDefinition) {
 274         switch (inputsOrOutputs) {
 275             case inputs:
 276                 DataModelUtil
 277                         .addInputParameterToTopologyTemplate(serviceTemplate, parameterId, parameterDefinition);
 278                 break;
 279             case outputs:
 280                 DataModelUtil
 281                         .addOutputParameterToTopologyTemplate(serviceTemplate, parameterId, parameterDefinition);
 282         }
 283     }
 284
 285     private void convertNodeTemplates(ServiceTemplate serviceTemplate,
 286                                       ServiceTemplateReaderService readerService) {
 287         Map<String, Object> nodeTemplates = readerService.getNodeTemplates();
 288         if (MapUtils.isEmpty(nodeTemplates)) {
 289             return;
 290         }
 291
 292         for (Map.Entry<String, Object> nodeTemplateEntry : nodeTemplates.entrySet()) {
 293             NodeTemplate nodeTemplate = convertNodeTemplate(nodeTemplateEntry.getValue());
 294             DataModelUtil.addNodeTemplate(serviceTemplate, nodeTemplateEntry.getKey(), nodeTemplate);
 295         }
 296     }
 297
 298     private void convertSubstitutionMappings(ServiceTemplate serviceTemplate,
 299                                              ServiceTemplateReaderService readerService) {
 300         Map<String, Object> substitutionMappings = readerService.getSubstitutionMappings();
 301         if (MapUtils.isEmpty(substitutionMappings)) {
 302             return;
 303         }
 304         SubstitutionMapping substitutionMapping = convertSubstitutionMappings(substitutionMappings);
 305         DataModelUtil.addSubstitutionMapping(serviceTemplate, substitutionMapping);
 306     }
 307
 308     private SubstitutionMapping convertSubstitutionMappings(Map<String, Object> substitutionMappings) {
 309         SubstitutionMapping substitutionMapping = new SubstitutionMapping();
 310
 311         substitutionMapping.setNode_type((String) substitutionMappings.get(nodeType));
 312         substitutionMapping.setCapabilities(
 313                 convertSubstitutionMappingsSections((Map<String, Object>) substitutionMappings.get(capabilities)));
 314         substitutionMapping.setRequirements(
 315                 convertSubstitutionMappingsSections((Map<String, Object>) substitutionMappings.get(requirements)));
 316
 317         return substitutionMapping;
 318     }
 319
 320     private Map<String, List<String>> convertSubstitutionMappingsSections(
 321             Map<String, Object> sectionToConvert) {
 322         Map<String, List<String>> convertedSection = new HashMap<>();
 323         if (MapUtils.isEmpty(sectionToConvert)) {
 324             return null;
 325         }
 326
 327         for (Map.Entry<String, Object> entry : sectionToConvert.entrySet()) {
 328             if (entry.getValue() instanceof List) {
 329                 convertedSection.put(entry.getKey(), (List<String>) entry.getValue());
 330             }
 331         }
 332
 333         return convertedSection;
 334     }
 335
 336     private CsarFileTypes getFileType(String fileName) {
 337         if (isMainServiceTemplate(fileName)) {
 338             return CsarFileTypes.mainServiceTemplate;
 339         } else if (isGlobalServiceTemplate(fileName)) {
 340             return CsarFileTypes.globalServiceTemplate;
 341         } else if (isDefinitions(fileName)) {
 342             return CsarFileTypes.definitionsFile;
 343         } else if (isMetadataFile(metadataFile)) {
 344             return CsarFileTypes.toscaMetadata;
 345         }
 346         return CsarFileTypes.externalFile;
 347     }
 348
 349     private Optional<Manifest> getCsarManifest(Map<String, byte[]> csarFiles) throws IOException {
 350         Optional<byte[]> manifestContent = getManifestContent(csarFiles);
 351
 352         if (manifestContent.isPresent()) {
 353             ByteArrayInputStream byteInputStream = new ByteArrayInputStream(manifestContent.get());
 354
 355             return Optional.of(new Manifest(byteInputStream));
 356         }
 357
 358         return Optional.empty();
 359     }
 360
 361     private NodeTemplate convertNodeTemplate(Object candidateNodeTemplate) {
 362         NodeTemplate nodeTemplate = new NodeTemplate();
 363
 364         Map<String, Object> nodeTemplateAsMap = (Map<String, Object>) candidateNodeTemplate;
 365         nodeTemplate.setArtifacts((Map<String, ArtifactDefinition>) nodeTemplateAsMap.get("artifacts"));
 366         nodeTemplate.setAttributes((Map<String, Object>) nodeTemplateAsMap.get("attributes"));
 367         nodeTemplate.setCopy((String) nodeTemplateAsMap.get("copy"));
 368         nodeTemplate.setDescription((String) nodeTemplateAsMap.get("description"));
 369         nodeTemplate.setDirectives((List<String>) nodeTemplateAsMap.get("directives"));
 370         nodeTemplate.setInterfaces(
 371                 (Map<String, InterfaceDefinition>) nodeTemplateAsMap.get("interfaces"));
 372         nodeTemplate.setNode_filter((NodeFilter) nodeTemplateAsMap.get("node_filter"));
 373         nodeTemplate.setProperties((Map<String, Object>) nodeTemplateAsMap.get("properties"));
 374         nodeTemplate.setRequirements(
 375                 (List<Map<String, RequirementAssignment>>) nodeTemplateAsMap.get("requirements"));
 376         nodeTemplate.setType((String) nodeTemplateAsMap.get("type"));
 377         nodeTemplate.setCapabilities(
 378                 convertCapabilities((Map<String, Object>) nodeTemplateAsMap.get("capabilities")));
 379
 380         return nodeTemplate;
 381     }
 382
 383     private List<Map<String, CapabilityAssignment>> convertCapabilities(Map<String, Object> capabilities) {
 384         List<Map<String, CapabilityAssignment>> convertedCapabilities = new ArrayList<>();
 385         if (MapUtils.isEmpty(capabilities)) {
 386             return null;
 387         }
 388         for (Map.Entry<String, Object> capabilityAssignmentEntry : capabilities.entrySet()) {
 389             Map<String, CapabilityAssignment> tempMap = new HashMap<>();
 390             tempMap.put(capabilityAssignmentEntry.getKey(),
 391                     (CapabilityAssignment) createObjectFromClass
 392                             (capabilityAssignmentEntry.getKey(), capabilityAssignmentEntry.getValue(), CapabilityAssignment.class));
 393             convertedCapabilities.add(tempMap);
 394         }
 395         return convertedCapabilities;
 396     }
 397
 398     private Object createObjectFromClass(String nodeTypeId,
 399                                          Object objectCandidate,
 400                                          Class classToCreate) {
 401         try {
 402             return JsonUtil.json2Object(objectCandidate.toString(), classToCreate);
 403         } catch (Exception e) {
 404             //todo - return error to user?
 405             throw new CoreException(new ErrorCode.ErrorCodeBuilder()
 406                     .withCategory(ErrorCategory.APPLICATION)
 407                     .withMessage("Can't create Node Type from " + nodeTypeId).build());
 408         }
 409     }
 410
 411     private boolean isMainServiceTemplate(String fileName) {
 412         return fileName.endsWith(mainStName);
 413     }
 414
 415     private boolean isMetadataFile(String fileName) {
 416         return fileName.equals(metadataFile);
 417     }
 418
 419     private boolean isGlobalServiceTemplate(String fileName) {
 420         return fileName.endsWith(globalStName);
 421     }
 422
 423     private boolean isDefinitions(String fileName) {
 424         return fileName.startsWith(definitionsDir);
 425     }
 426
 427     private String getTemplateNameFromStName(String serviceTemplateName) {
 428         String fileNameWithoutDirectories;
 429         fileNameWithoutDirectories = getFileNameWithoutDirectories(serviceTemplateName);
 430         return fileNameWithoutDirectories.split("ServiceTemplate")[0];
 431     }
 432
 433     private String getFileNameWithoutDirectories(String serviceTemplateName) {
 434         String fileNameWithoutDirectories;
 435         if (serviceTemplateName.contains("/")) {
 436             String[] split = serviceTemplateName.split("/");
 437             fileNameWithoutDirectories = split[split.length - 1];
 438         } else if (serviceTemplateName.contains(File.separator)) {
 439             String[] split = serviceTemplateName.split(Pattern.quote(File.separator));
 440             fileNameWithoutDirectories = split[split.length - 1];
 441         } else {
 442             fileNameWithoutDirectories = serviceTemplateName;
 443         }
 444         return fileNameWithoutDirectories;
 445     }
 446 }