asdc-tests/src/test/resources/CI/demoResourcesWanLan/LAN_Connector/LAN_Connector.yml


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

org.openecomp.asdc.nodes.Connector.LAN_Connector:
  #The LAN_Connector node connects Router and VNF_Container
    derived_from: org.openecomp.asdc.nodes.Connector
    properties:
      network_id: 
        #or called: vlan_id
        type: string 
        required: true
      network_type:
        #The technology types used by LAN connector
        type: string
    attributes:
      network_ip_address:
        #ip address is generated only after the node is instantiated at run-time
        type: string
    requirements:
      - connectToRouter :
          capability: tosca.capabilities.Root
          node: org.openecomp.asdc.nodes.Router
      - connectToVNF :
          capability: tosca.capabilities.Root
          node: org.openecomp.asdc.nodes.VNF_Container
      #These two explicit requirements specify the LAN_Connector has two "connectTo" to connect to the node of Router type and VNF_Container type respectively
package org.openecomp.core.impl;

import org.apache.commons.collections.MapUtils;
import org.openecomp.core.converter.ServiceTemplateReaderService;
import org.openecomp.core.converter.ToscaConverter;
import org.openecomp.core.converter.datatypes.Constants;
import org.openecomp.core.converter.datatypes.CsarFileTypes;
import org.openecomp.core.impl.services.ServiceTemplateReaderServiceImpl;
import org.openecomp.core.utilities.file.FileContentHandler;
import org.openecomp.core.utilities.json.JsonUtil;
import org.openecomp.sdc.common.errors.CoreException;
import org.openecomp.sdc.common.errors.ErrorCategory;
import org.openecomp.sdc.common.errors.ErrorCode;
import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
import org.openecomp.sdc.tosca.datatypes.model.*;
import org.openecomp.sdc.tosca.services.DataModelUtil;
import org.openecomp.sdc.tosca.services.ToscaUtil;
import org.openecomp.sdc.translator.services.heattotosca.globaltypes.GlobalTypesGenerator;
import org.yaml.snakeyaml.error.YAMLException;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.jar.Manifest;
import java.util.regex.Pattern;

import static org.openecomp.core.converter.datatypes.Constants.*;
import static org.openecomp.core.impl.GlobalSubstitutionServiceTemplate.GLOBAL_SUBSTITUTION_SERVICE_FILE_NAME;

public class ToscaConverterImpl implements ToscaConverter {

    public ToscaConverterImpl() {

    }

    @Override
    public ToscaServiceModel convert(FileContentHandler fileContentHandler)
        throws IOException {
        Map<String, byte[]> csarFiles = new HashMap<>(fileContentHandler.getFiles());
        ToscaServiceModel toscaServiceModel = new ToscaServiceModel();
        Map<String, ServiceTemplate> serviceTemplates = new HashMap<>();
        FileContentHandler artifacts = new FileContentHandler();
        GlobalSubstitutionServiceTemplate gsst = new GlobalSubstitutionServiceTemplate();
        for (Map.Entry<String, byte[]> fileEntry : csarFiles.entrySet()) {
            CsarFileTypes fileType = getFileType(fileEntry.getKey());
            switch (fileType) {
                case mainServiceTemplate:
                    handleServiceTemplate(mainStName, fileEntry.getKey(), csarFiles, serviceTemplates);
                    break;

                case globalServiceTemplate:
                    handleServiceTemplate(globalStName, fileEntry.getKey(), csarFiles, serviceTemplates);
                    break;

                case externalFile:
                    artifacts.addFile(fileEntry.getKey(), fileEntry.getValue());
                    break;

                case definitionsFile:
                    handleDefintionTemplate(fileEntry.getKey(), csarFiles, gsst);
                    break;
            }
        }
        handleMetadataFile(csarFiles);
        updateToscaServiceModel(toscaServiceModel, serviceTemplates, artifacts, gsst, csarFiles);
        return toscaServiceModel;
    }

    private void handleMetadataFile(Map<String, byte[]> csarFiles) {
        byte[] bytes = csarFiles.remove(metadataFile);
        if (bytes != null) {
            csarFiles.put(metadataFile + ".original", bytes);
        }
    }

    private void handleDefintionTemplate(String key, Map<String, byte[]> csarFiles,
                                         GlobalSubstitutionServiceTemplate gsst) {
        try {
            ServiceTemplateReaderService readerService = new ServiceTemplateReaderServiceImpl(csarFiles.get(key));
            if (readerService == null) {
                return;
            }
            Object nodeTypes = readerService.getNodeTypes();
            if (nodeTypes instanceof Map) {
                Map<String, NodeType> nodeTypeMap = (Map<String, NodeType>) nodeTypes;
                gsst.appendNodes(nodeTypeMap);
            }
        } catch (YAMLException ye) {
            throw new CoreException(new ErrorCode.ErrorCodeBuilder()
                .withMessage("Invalid YAML content in file " + key + ". reason - "
                    + ye.getMessage())
                .withCategory(ErrorCategory.APPLICATION).build());
        }
    }

    private void updateToscaServiceModel(ToscaServiceModel toscaServiceModel,
                                         Map<String, ServiceTemplate> serviceTemplates,
                                         FileContentHandler externalFilesHandler,
                                         GlobalSubstitutionServiceTemplate globalSubstitutionServiceTemplate,
                                         Map<String, byte[]> csarFiles) {
        Collection<ServiceTemplate> globalServiceTemplates =
            GlobalTypesGenerator.getGlobalTypesServiceTemplate().values();
        addGlobalServiceTemplates(globalServiceTemplates, serviceTemplates);
        toscaServiceModel.setEntryDefinitionServiceTemplate(mainStName);
        toscaServiceModel.setServiceTemplates(serviceTemplates);
        externalFilesHandler.addFile(metadataFile + ".original",
            csarFiles.get(metadataFile + ".original"));
        toscaServiceModel.setArtifactFiles(externalFilesHandler);

        if(MapUtils.isNotEmpty(globalSubstitutionServiceTemplate.getNode_types())) {
            serviceTemplates
                .put(GLOBAL_SUBSTITUTION_SERVICE_FILE_NAME, globalSubstitutionServiceTemplate);
        }
    }

    private void addGlobalServiceTemplates(Collection<ServiceTemplate> globalServiceTemplates,
                                           Map<String, ServiceTemplate> serviceTemplates) {
        for (ServiceTemplate serviceTemplate : globalServiceTemplates) {
            serviceTemplates.put(ToscaUtil.getServiceTemplateFileName(serviceTemplate), serviceTemplate);
        }
    }

    private void handleServiceTemplate(String serviceTemplateName,
                                       String fileName, Map<String, byte[]> csarFiles,
                                       Map<String, ServiceTemplate> serviceTemplates) {
        Optional<ServiceTemplate> serviceTemplate =
            getServiceTemplateFromCsar(fileName, csarFiles);
        serviceTemplate.ifPresent(
            serviceTemplate1 -> addServiceTemplate(serviceTemplateName, serviceTemplate1,
                serviceTemplates));
    }

    private void addServiceTemplate(String serviceTemplateName,
                                    ServiceTemplate serviceTemplate,
                                    Map<String, ServiceTemplate> serviceTemplates) {
        serviceTemplates.put(serviceTemplateName, serviceTemplate);
    }

    private Optional<byte[]> getManifestContent(Map<String, byte[]> csarFiles) {
        for (Map.Entry<String, byte[]> csarFileEntry : csarFiles.entrySet()) {
            if (csarFileEntry.getKey().contains(manifestFileName)) {
                return Optional.of(csarFileEntry.getValue());
            }
        }

        return Optional.empty();
    }

    private Optional<ServiceTemplate> getServiceTemplateFromCsar(String fileName,
                                                                 Map<String, byte[]> csarFiles) {
        byte[] fileContent = csarFiles.get(fileName);
        ServiceTemplate serviceTemplate = convertServiceTemplate(fileName, fileContent);

        return Optional.of(serviceTemplate);
    }

    private ServiceTemplate convertServiceTemplate(String serviceTemplateName,
                                                   byte[] fileContent) {
        ServiceTemplate serviceTemplate = new ServiceTemplate();
        try {
            ServiceTemplateReaderService readerService =
                new ServiceTemplateReaderServiceImpl(fileContent);
            convertMetadata(serviceTemplateName, serviceTemplate, readerService);
            convertToscaVersion(serviceTemplate, readerService);
            convertImports(serviceTemplate);
            convertNodeTypes(serviceTemplate, readerService);
            convertTopologyTemplate(serviceTemplate, readerService);

        } catch (YAMLException ye) {
            throw new CoreException(new ErrorCode.ErrorCodeBuilder()
                .withMessage("Invalid YAML content in file" + serviceTemplateName + ". reason - "
                    + ye.getMessage())
                .withCategory(ErrorCategory.APPLICATION).build());
        }


        return serviceTemplate;
    }

    private void convertToscaVersion(ServiceTemplate serviceTemplate,
                                     ServiceTemplateReaderService readerService) {
        Object toscaVersion = readerService.getToscaVersion();
        serviceTemplate.setTosca_definitions_version((String) toscaVersion);
    }

    private void convertImports(ServiceTemplate serviceTemplate) {
        serviceTemplate.setImports(new ArrayList<>());
        serviceTemplate.getImports()
            .add(createImportMap(openecompHeatIndex, "openecomp-heat/_index.yml"));
        serviceTemplate.getImports().add(createImportMap(globalSubstitution, globalStName));

    }

    private Map<String, Import> createImportMap(String key, String fileName) {
        Map<String, Import> importMap = new HashMap<>();
        Import anImport = new Import();
        anImport.setFile(fileName);
        importMap.put(key, anImport);

        return importMap;
    }

    private void convertMetadata(String serviceTemplateName,
                                 ServiceTemplate serviceTemplate,
                                 ServiceTemplateReaderService readerService) {
        Map<String, Object> metadataToConvert = (Map<String, Object>) readerService.getMetadata();
        Map<String, String> finalMetadata = new HashMap<>();

        if (MapUtils.isNotEmpty(metadataToConvert)) {
            for (Map.Entry<String, Object> metadataEntry : metadataToConvert.entrySet()) {
                if (Objects.isNull(metadataEntry.getValue()) ||
                    !(metadataEntry.getValue() instanceof String)) {
                    continue;
                }
                finalMetadata.put(metadataEntry.getKey(), (String) metadataEntry.getValue());
            }
        }

        finalMetadata.put("template_name", getTemplateNameFromStName(serviceTemplateName));
        serviceTemplate.setMetadata(finalMetadata);
    }

    private void convertNodeTypes(ServiceTemplate serviceTemplate, ServiceTemplateReaderService readerService) {
        Map<String, Object> nodeTypes = (Map<String, Object>) readerService.getNodeTypes();
        if (MapUtils.isEmpty(nodeTypes)) {
            return;
        }

        for (Map.Entry<String, Object> nodeTypeEntry : nodeTypes.entrySet()) {
            DataModelUtil
                .addNodeType(serviceTemplate, nodeTypeEntry.getKey(),
                    (NodeType) createObjectFromClass(nodeTypeEntry.getKey(), nodeTypeEntry.getValue(),
                        NodeType.class));
        }
    }

    private void convertTopologyTemplate(ServiceTemplate serviceTemplate,
                                         ServiceTemplateReaderService readerService) {

        convertInputs(serviceTemplate, readerService);
        convertNodeTemplates(serviceTemplate, readerService);
        convertOutputs(serviceTemplate, readerService);
        convertSubstitutionMappings(serviceTemplate, readerService);
    }

    private void convertInputs(ServiceTemplate serviceTemplate,
                               ServiceTemplateReaderService readerService) {
        Map<String, Object> inputs = readerService.getInputs();
        addInputsOrOutputsToServiceTemplate(serviceTemplate, inputs, Constants.inputs);
    }

    private void convertOutputs(ServiceTemplate serviceTemplate,
                                ServiceTemplateReaderService readerService) {
        Map<String, Object> outputs = readerService.getOutputs();
        addInputsOrOutputsToServiceTemplate(serviceTemplate, outputs, Constants.outputs);
    }

    private void addInputsOrOutputsToServiceTemplate(ServiceTemplate serviceTemplate,
                                                     Map<String, Object> mapToConvert,
                                                     String inputsOrOutputs) {
        if (MapUtils.isEmpty(mapToConvert)) {
            return;
        }

        for (Map.Entry<String, Object> entry : mapToConvert.entrySet()) {
            ParameterDefinition parameterDefinition =
                (ParameterDefinition) createObjectFromClass(
                    entry.getKey(), entry.getValue(), ParameterDefinition.class);
            addToServiceTemplateAccordingToSection(
                serviceTemplate, inputsOrOutputs, entry.getKey(), parameterDefinition);
        }
    }

    private void addToServiceTemplateAccordingToSection(ServiceTemplate serviceTemplate,
                                                        String inputsOrOutputs,
                                                        String parameterId,
                                                        ParameterDefinition parameterDefinition) {
        switch (inputsOrOutputs) {
            case inputs:
                DataModelUtil
                    .addInputParameterToTopologyTemplate(serviceTemplate, parameterId, parameterDefinition);
                break;
            case outputs:
                DataModelUtil
                    .addOutputParameterToTopologyTemplate(serviceTemplate, parameterId, parameterDefinition);
        }
    }

    private void convertNodeTemplates(ServiceTemplate serviceTemplate,
                                      ServiceTemplateReaderService readerService) {
        Map<String, Object> nodeTemplates = readerService.getNodeTemplates();
        if (MapUtils.isEmpty(nodeTemplates)) {
            return;
        }

        for (Map.Entry<String, Object> nodeTemplateEntry : nodeTemplates.entrySet()) {
            NodeTemplate nodeTemplate = convertNodeTemplate(nodeTemplateEntry.getValue());
            DataModelUtil.addNodeTemplate(serviceTemplate, nodeTemplateEntry.getKey(), nodeTemplate);
        }
    }

    private void convertSubstitutionMappings(ServiceTemplate serviceTemplate,
                                             ServiceTemplateReaderService readerService) {
        Map<String, Object> substitutionMappings = readerService.getSubstitutionMappings();
        if (MapUtils.isEmpty(substitutionMappings)) {
            return;
        }
        SubstitutionMapping substitutionMapping = convertSubstitutionMappings(substitutionMappings);
        DataModelUtil.addSubstitutionMapping(serviceTemplate, substitutionMapping);
    }

    private SubstitutionMapping convertSubstitutionMappings(Map<String, Object> substitutionMappings) {
        SubstitutionMapping substitutionMapping = new SubstitutionMapping();

        substitutionMapping.setNode_type((String) substitutionMappings.get(nodeType));
        substitutionMapping.setCapabilities(
            convertSubstitutionMappingsSections((Map<String, Object>) substitutionMappings.get(capabilities)));
        substitutionMapping.setRequirements(
            convertSubstitutionMappingsSections((Map<String, Object>) substitutionMappings.get(requirements)));

        return substitutionMapping;
    }

    private Map<String, List<String>> convertSubstitutionMappingsSections(
        Map<String, Object> sectionToConvert) {
        Map<String, List<String>> convertedSection = new HashMap<>();
        if (MapUtils.isEmpty(sectionToConvert)) {
            return null;
        }

        for (Map.Entry<String, Object> entry : sectionToConvert.entrySet()) {
            if (entry.getValue() instanceof List) {
                convertedSection.put(entry.getKey(), (List<String>) entry.getValue());
            }
        }

        return convertedSection;
    }

    private CsarFileTypes getFileType(String fileName) {
        if (isMainServiceTemplate(fileName)) {
            return CsarFileTypes.mainServiceTemplate;
        } else if (isGlobalServiceTemplate(fileName)) {
            return CsarFileTypes.globalServiceTemplate;
        } else if (isDefinitions(fileName)) {
            return CsarFileTypes.definitionsFile;
        } else if (isMetadataFile(fileName)) {
            return CsarFileTypes.toscaMetadata;
        }
        return CsarFileTypes.externalFile;
    }

    private Optional<Manifest> getCsarManifest(Map<String, byte[]> csarFiles) throws IOException {
        Optional<byte[]> manifestContent = getManifestContent(csarFiles);

        if (manifestContent.isPresent()) {
            ByteArrayInputStream byteInputStream = new ByteArrayInputStream(manifestContent.get());

            return Optional.of(new Manifest(byteInputStream));
        }

        return Optional.empty();
    }

    private NodeTemplate convertNodeTemplate(Object candidateNodeTemplate) {
        NodeTemplate nodeTemplate = new NodeTemplate();

        Map<String, Object> nodeTemplateAsMap = (Map<String, Object>) candidateNodeTemplate;
        nodeTemplate.setArtifacts((Map<String, ArtifactDefinition>) nodeTemplateAsMap.get("artifacts"));
        nodeTemplate.setAttributes((Map<String, Object>) nodeTemplateAsMap.get("attributes"));
        nodeTemplate.setCopy((String) nodeTemplateAsMap.get("copy"));
        nodeTemplate.setDescription((String) nodeTemplateAsMap.get("description"));
        nodeTemplate.setDirectives((List<String>) nodeTemplateAsMap.get("directives"));
        nodeTemplate.setInterfaces(
            (Map<String, InterfaceDefinition>) nodeTemplateAsMap.get("interfaces"));
        nodeTemplate.setNode_filter((NodeFilter) nodeTemplateAsMap.get("node_filter"));
        nodeTemplate.setProperties((Map<String, Object>) nodeTemplateAsMap.get("properties"));
        nodeTemplate.setRequirements(
            (List<Map<String, RequirementAssignment>>) nodeTemplateAsMap.get("requirements"));
        nodeTemplate.setType((String) nodeTemplateAsMap.get("type"));
        nodeTemplate.setCapabilities(
            convertCapabilities((Map<String, Object>) nodeTemplateAsMap.get("capabilities")));

        return nodeTemplate;
    }

    private List<Map<String, CapabilityAssignment>> convertCapabilities(Map<String, Object> capabilities) {
        List<Map<String, CapabilityAssignment>> convertedCapabilities = new ArrayList<>();
        if (MapUtils.isEmpty(capabilities)) {
            return null;
        }
        for (Map.Entry<String, Object> capabilityAssignmentEntry : capabilities.entrySet()) {
            Map<String, CapabilityAssignment> tempMap = new HashMap<>();
            tempMap.put(capabilityAssignmentEntry.getKey(),
                (CapabilityAssignment) createObjectFromClass
                    (capabilityAssignmentEntry.getKey(), capabilityAssignmentEntry.getValue(), CapabilityAssignment.class));
            convertedCapabilities.add(tempMap);
        }
        return convertedCapabilities;
    }

    private Object createObjectFromClass(String nodeTypeId,
                                         Object objectCandidate,
                                         Class classToCreate) {
        try {
            return JsonUtil.json2Object(objectCandidate.toString(), classToCreate);
        } catch (Exception e) {
            //todo - return error to user?
            throw new CoreException(new ErrorCode.ErrorCodeBuilder()
                .withCategory(ErrorCategory.APPLICATION)
                .withMessage("Can't create " + classToCreate.getSimpleName() + " from " +
                    nodeTypeId).build());
        }
    }

    private boolean isMainServiceTemplate(String fileName) {
        return fileName.endsWith(mainStName);
    }

    private boolean isMetadataFile(String fileName) {
        return fileName.equals(metadataFile);
    }

    private boolean isGlobalServiceTemplate(String fileName) {
        return fileName.endsWith(globalStName);
    }

    private boolean isDefinitions(String fileName) {
        return fileName.startsWith(definitionsDir);
    }

    private String getTemplateNameFromStName(String serviceTemplateName) {
        String fileNameWithoutDirectories;
        fileNameWithoutDirectories = getFileNameWithoutDirectories(serviceTemplateName);
        return fileNameWithoutDirectories.split("ServiceTemplate")[0];
    }

    private String getFileNameWithoutDirectories(String serviceTemplateName) {
        String fileNameWithoutDirectories;
        if (serviceTemplateName.contains("/")) {
            String[] split = serviceTemplateName.split("/");
            fileNameWithoutDirectories = split[split.length - 1];
        } else if (serviceTemplateName.contains(File.separator)) {
            String[] split = serviceTemplateName.split(Pattern.quote(File.separator));
            fileNameWithoutDirectories = split[split.length - 1];
        } else {
            fileNameWithoutDirectories = serviceTemplateName;
        }
        return fileNameWithoutDirectories;
    }
}