aboutsummaryrefslogtreecommitdiffstats
path: root/src/test/java/org/onap/dcae/commonFunction/EventProcessorTest.java
blob: a3a477206ec2aa59dbb6b3a2284c74bc4bfb000e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
/*-
 * ============LICENSE_START=======================================================
 * org.onap.dcaegen2.collectors.ves
 * ================================================================================
 * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
 * Copyright (C) 2018 Nokia. All rights reserved.
 * ================================================================================
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ============LICENSE_END=========================================================
 */
package org.onap.dcae.commonFunction;

import com.att.nsa.cambria.client.CambriaBatchingPublisher;
import com.google.gson.Gson;
import org.json.JSONObject;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;

import java.io.FileNotFoundException;
import java.util.List;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.onap.dcae.commonFunction.EventProcessor.EVENT_LIST_TYPE;

public class EventProcessorTest {

    private final String ev = "{\"event\": {\"commonEventHeader\": {	\"reportingEntityName\": \"VM name will be provided by ECOMP\",	\"startEpochMicrosec\": 1477012779802988,\"lastEpochMicrosec\": 1477012789802988,\"eventId\": \"83\",\"sourceName\": \"Dummy VM name - No Metadata available\",\"sequence\": 83,\"priority\": \"Normal\",\"functionalRole\": \"vFirewall\",\"domain\": \"measurementsForVfScaling\",\"reportingEntityId\": \"VM UUID will be provided by ECOMP\",\"sourceId\": \"Dummy VM UUID - No Metadata available\",\"version\": 1.1},\"measurementsForVfScalingFields\": {\"measurementInterval\": 10,\"measurementsForVfScalingVersion\": 1.1,\"vNicUsageArray\": [{\"multicastPacketsIn\": 0,\"bytesIn\": 3896,\"unicastPacketsIn\": 0,	\"multicastPacketsOut\": 0,\"broadcastPacketsOut\": 0,		\"packetsOut\": 28,\"bytesOut\": 12178,\"broadcastPacketsIn\": 0,\"packetsIn\": 58,\"unicastPacketsOut\": 0,\"vNicIdentifier\": \"eth0\"}]}}}";
    private String testinput = "src/test/resources/testDmaapConfig_ip.json";

    @Before
    public void setUp() throws Exception {
        CommonStartup.streamid = "fault=sec_fault|syslog=sec_syslog|heartbeat=sec_heartbeat|measurementsForVfScaling=sec_measurement|mobileFlow=sec_mobileflow|other=sec_other|stateChange=sec_statechange|thresholdCrossingAlert=sec_thresholdCrossingAlert|voiceQuality=ves_voicequality|sipSignaling=ves_sipsignaling";
        CommonStartup.eventTransformFlag = 1;
    }

    @Test
    public void testLoad() {
        //given
        EventProcessor ec = new EventProcessor();
        ec.event = new org.json.JSONObject(ev);
        //when
        ec.overrideEvent();

        //then
        Boolean hasSourceNameNode = ec.event.getJSONObject("event").getJSONObject("commonEventHeader").has("sourceName");
        assertTrue(hasSourceNameNode);
    }

    @Test
    public void shouldParseJsonEvents() throws FileNotFoundException, ReflectiveOperationException {
        //given
        EventProcessor eventProcessor = new EventProcessor();
        String event_json = "[{ \"filter\": {\"event.commonEventHeader.domain\":\"heartbeat\",\"VESversion\":\"v4\"},\"processors\":[" +
                "{\"functionName\": \"concatenateValue\",\"args\":{\"field\":\"event.commonEventHeader.eventName\",\"concatenate\": [\"$event.commonEventHeader.domain\",\"$event.commonEventHeader.eventType\",\"$event.faultFields.alarmCondition\"], \"delimiter\":\"_\"}}" +
                ",{\"functionName\": \"addAttribute\",\"args\":{\"field\": \"event.heartbeatFields.heartbeatFieldsVersion\",\"value\": \"1.0\",\"fieldType\": \"number\"}}" +
                ",{\"functionName\": \"map\",\"args\":{\"field\": \"event.commonEventHeader.nfNamingCode\",\"oldField\": \"event.commonEventHeader.functionalRole\"}}]}]";
        List<Event> events = new Gson().fromJson(event_json, EVENT_LIST_TYPE);
        EventProcessor.ConfigProcessorAdapter configProcessorAdapter = mock(EventProcessor.ConfigProcessorAdapter.class);

        when(configProcessorAdapter.isFilterMet(any(JSONObject.class))).thenReturn(true);
        ArgumentCaptor<String> stringArgumentCaptor = ArgumentCaptor.forClass(String.class);
        ArgumentCaptor<JSONObject> jsonObjectArgumentCaptor = ArgumentCaptor.forClass(JSONObject.class);
        //when
        eventProcessor.parseEventsJson(events, configProcessorAdapter);

        //then
        verify(configProcessorAdapter, times(3)).runConfigProcessorFunctionByName(stringArgumentCaptor.capture(), jsonObjectArgumentCaptor.capture());
        assertThat(stringArgumentCaptor.getAllValues()).contains("concatenateValue", "addAttribute", "map");
    }

    @Test
    public void shouldCreateDmaapPublisher() {

        //given
        EventPublisherHash eph = EventPublisherHash.getInstance();
        EventProcessor ec = new EventProcessor();
        ec.event = new org.json.JSONObject(ev);
        CommonStartup.cambriaConfigFile = "src/test/resources/testDmaapConfig_ip.json";

        //when
        CambriaBatchingPublisher pub = eph.getDmaapPublisher("sec_fault_ueb");

        //then
        assertNotNull(pub);
    }

    @Test
    public void shouldSendEventWithNoError() {

        EventPublisherHash eph = EventPublisherHash.getInstance();
        EventProcessor eventProcessor = new EventProcessor();
        eventProcessor.event = new org.json.JSONObject(ev);
        CommonStartup.cambriaConfigFile = "src/test/resources/testDmaapConfig_ip.json";

        //when
        eph.sendEvent(eventProcessor.event, "sec_fault_ueb");
    }
}
metadataFile; import static org.openecomp.core.converter.datatypes.Constants.nodeType; import static org.openecomp.core.converter.datatypes.Constants.openecompHeatIndex; import static org.openecomp.core.converter.datatypes.Constants.outputs; import static org.openecomp.core.converter.datatypes.Constants.requirements; import static org.openecomp.core.impl.GlobalSubstitutionServiceTemplate.GLOBAL_SUBSTITUTION_SERVICE_FILE_NAME; import static org.openecomp.core.impl.GlobalSubstitutionServiceTemplate.HEAT_INDEX_IMPORT_FILE; import static org.openecomp.core.impl.GlobalSubstitutionServiceTemplate.ONAP_INDEX_IMPORT_FILE; 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.converter.errors.SubstitutionMappingsConverterErrorBuilder; import org.openecomp.core.impl.services.ServiceTemplateReaderServiceImpl; import org.openecomp.core.utilities.file.FileContentHandler; import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum; 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.ArtifactDefinition; import org.openecomp.sdc.tosca.datatypes.model.CapabilityAssignment; import org.openecomp.sdc.tosca.datatypes.model.Import; import org.openecomp.sdc.tosca.datatypes.model.InterfaceDefinition; import org.openecomp.sdc.tosca.datatypes.model.NodeFilter; import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate; import org.openecomp.sdc.tosca.datatypes.model.NodeType; import org.openecomp.sdc.tosca.datatypes.model.ParameterDefinition; import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment; import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate; import org.openecomp.sdc.tosca.datatypes.model.SubstitutionMapping; 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.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.Optional; import java.util.jar.Manifest; import java.util.regex.Pattern; 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( getConcreteArtifactFileName(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) .withCategory(ErrorCategory.APPLICATION).build(), ye); } } private String getConcreteArtifactFileName(String fileName){ int artifactIndex = fileName.indexOf(CsarFileTypes.Artifacts.name()); if(artifactIndex < 0){ return fileName; } int artifactDirectoryIndex = artifactIndex + CsarFileTypes.Artifacts.name().length() + 1; return fileName.substring(artifactDirectoryIndex); } private void updateToscaServiceModel(ToscaServiceModel toscaServiceModel, Map<String, ServiceTemplate> serviceTemplates, FileContentHandler externalFilesHandler, GlobalSubstitutionServiceTemplate globalSubstitutionServiceTemplate, Map<String, byte[]> csarFiles) { Collection<ServiceTemplate> globalServiceTemplates = GlobalTypesGenerator.getGlobalTypesServiceTemplate(OnboardingTypesEnum.CSAR).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( serviceTemplateValue -> addServiceTemplate(serviceTemplateName, serviceTemplateValue, 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) .withCategory(ErrorCategory.APPLICATION).build(), ye); } 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, HEAT_INDEX_IMPORT_FILE)); serviceTemplate.getImports().add(createImportMap(ONAP_INDEX, ONAP_INDEX_IMPORT_FILE)); 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()) { Optional<NodeType> nodeType = ToscaConverterUtil .createObjectFromClass(nodeTypeEntry.getKey(), nodeTypeEntry.getValue(), NodeType.class); nodeType.ifPresent(nodeTypeValue -> DataModelUtil .addNodeType(serviceTemplate, nodeTypeEntry.getKey(), nodeTypeValue)); } } 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()) { Optional<ParameterDefinition> parameterDefinition = ToscaConverterUtil.createObjectFromClass( entry.getKey(), entry.getValue(), ParameterDefinition.class); parameterDefinition.ifPresent(parameterDefinitionValue -> { Optional<Object> defaultValue = ToscaConverterUtil.getDefaultValue(entry.getValue(), parameterDefinition.get()); defaultValue.ifPresent(parameterDefinitionValue::set_default); addToServiceTemplateAccordingToSection( serviceTemplate, inputsOrOutputs, entry.getKey(), parameterDefinition.get()); } ); } } 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(capabilities, substitutionMappings.get(capabilities))); substitutionMapping.setRequirements( convertSubstitutionMappingsSections(requirements, substitutionMappings.get(requirements))); return substitutionMapping; } private Map<String, List<String>> convertSubstitutionMappingsSections(String sectionName, Object sectionToConvert) { if(Objects.isNull(sectionToConvert)){ return null; } if(!(sectionToConvert instanceof Map)) { throw new CoreException( new SubstitutionMappingsConverterErrorBuilder( sectionName, sectionToConvert.getClass().getSimpleName()).build()); } return convertSection(sectionToConvert); } private Map<String, List<String>> convertSection(Object sectionToConvert) { Map<String, Object> sectionAsMap = (Map<String, Object>)sectionToConvert; Map<String, List<String>> convertedSection = new HashMap<>(); if (MapUtils.isEmpty(sectionAsMap)) { return null; } for (Map.Entry<String, Object> entry : sectionAsMap.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<>(); Optional<CapabilityAssignment> capabilityAssignment = ToscaConverterUtil.createObjectFromClass (capabilityAssignmentEntry.getKey(), capabilityAssignmentEntry.getValue(), CapabilityAssignment.class); capabilityAssignment.ifPresent(capabilityAssignmentValue -> { tempMap.put(capabilityAssignmentEntry.getKey(), capabilityAssignmentValue); convertedCapabilities.add(tempMap); } ); } return convertedCapabilities; } 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; } }