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