2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
21 package org.openecomp.sdc.vendorsoftwareproduct.services.impl.composition;
23 import com.fasterxml.jackson.databind.ObjectMapper;
24 import org.apache.commons.collections4.CollectionUtils;
25 import org.apache.commons.collections4.MapUtils;
26 import org.openecomp.sdc.common.errors.CoreException;
27 import org.openecomp.sdc.datatypes.error.ErrorLevel;
28 import org.openecomp.sdc.logging.api.Logger;
29 import org.openecomp.sdc.logging.api.LoggerFactory;
30 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
31 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
32 import org.openecomp.sdc.logging.types.LoggerConstants;
33 import org.openecomp.sdc.logging.types.LoggerErrorCode;
34 import org.openecomp.sdc.logging.types.LoggerErrorDescription;
35 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
36 import org.openecomp.sdc.tosca.datatypes.ToscaCapabilityType;
37 import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
38 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
39 import org.openecomp.sdc.tosca.datatypes.ToscaRelationshipType;
40 import org.openecomp.sdc.tosca.datatypes.ToscaServiceModel;
41 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
42 import org.openecomp.sdc.tosca.datatypes.model.ParameterDefinition;
43 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
44 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
45 import org.openecomp.sdc.tosca.errors.ToscaInvalidEntryNotFoundErrorBuilder;
46 import org.openecomp.sdc.tosca.errors.ToscaInvalidSubstituteNodeTemplateErrorBuilder;
47 import org.openecomp.sdc.tosca.errors.ToscaMissingSubstitutionMappingForReqCapErrorBuilder;
48 import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
49 import org.openecomp.sdc.tosca.services.ToscaConstants;
50 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
51 import org.openecomp.sdc.tosca.services.ToscaExtensionYamlUtil;
52 import org.openecomp.sdc.vendorsoftwareproduct.services.composition.CompositionDataExtractor;
53 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Component;
54 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentData;
55 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionData;
56 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComputeData;
57 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ExtractCompositionDataContext;
58 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Image;
59 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Network;
60 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
62 import java.util.ArrayList;
63 import java.util.HashMap;
64 import java.util.List;
66 import java.util.Objects;
67 import java.util.Optional;
68 import java.util.stream.Collectors;
70 public class CompositionDataExtractorImpl implements CompositionDataExtractor {
72 protected static Logger logger;
73 private static ToscaAnalyzerService toscaAnalyzerService;
74 private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
77 logger = LoggerFactory.getLogger(CompositionDataExtractorImpl.class);
78 toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
82 * Extract service composition data composition data.
84 * @param toscaServiceModel the tosca service model
85 * @return the composition data
87 public CompositionData extractServiceCompositionData(ToscaServiceModel toscaServiceModel) {
90 mdcDataDebugMessage.debugEntryMessage(null);
92 ExtractCompositionDataContext context = new ExtractCompositionDataContext();
93 String entryDefinitionServiceTemplateFileName =
94 toscaServiceModel.getEntryDefinitionServiceTemplate();
95 ServiceTemplate entryDefinitionServiceTemplate =
96 toscaServiceModel.getServiceTemplates().get(entryDefinitionServiceTemplateFileName);
97 extractServiceCompositionData(entryDefinitionServiceTemplateFileName,
98 entryDefinitionServiceTemplate, toscaServiceModel, context);
100 CompositionData compositionData = new CompositionData();
101 compositionData.setNetworks(context.getNetworks());
102 compositionData.setComponents(context.getComponents());
104 mdcDataDebugMessage.debugExitMessage(null);
105 return compositionData;
108 private void extractServiceCompositionData(String serviceTemplateFileName,
109 ServiceTemplate serviceTemplate,
110 ToscaServiceModel toscaServiceModel,
111 ExtractCompositionDataContext context) {
112 if (context.getHandledServiceTemplates().contains(serviceTemplateFileName)) {
115 context.addNetworks(extractNetworks(serviceTemplate, toscaServiceModel));
116 extractComponents(serviceTemplate, toscaServiceModel, context);
117 handleSubstitution(serviceTemplate, toscaServiceModel, context);
118 context.addHandledServiceTemplates(serviceTemplateFileName);
121 private void handleSubstitution(ServiceTemplate serviceTemplate,
122 ToscaServiceModel toscaServiceModel,
123 ExtractCompositionDataContext context) {
126 mdcDataDebugMessage.debugEntryMessage(null);
128 Map<String, NodeTemplate> substitutableNodeTemplates =
129 toscaAnalyzerService.getSubstitutableNodeTemplates(serviceTemplate);
131 if (substitutableNodeTemplates != null) {
132 for (String substitutableNodeTemplateId : substitutableNodeTemplates.keySet()) {
133 handleSubstitutableNodeTemplate(serviceTemplate, toscaServiceModel,
134 substitutableNodeTemplateId,
135 substitutableNodeTemplates.get(substitutableNodeTemplateId), context);
139 mdcDataDebugMessage.debugExitMessage(null);
142 private void handleSubstitutableNodeTemplate(ServiceTemplate serviceTemplate,
143 ToscaServiceModel toscaServiceModel,
144 String substitutableNodeTemplateId,
145 NodeTemplate substitutableNodeTemplate,
146 ExtractCompositionDataContext context) {
149 mdcDataDebugMessage.debugEntryMessage(null);
151 ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
152 Optional<String> substituteServiceTemplateFileName = toscaAnalyzerService
153 .getSubstituteServiceTemplateName(substitutableNodeTemplateId, substitutableNodeTemplate);
154 if (!substituteServiceTemplateFileName.isPresent()) {
155 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
156 LoggerTragetServiceName.EXTRACT_COMPOSITION_DATA, ErrorLevel.ERROR.name(),
157 LoggerErrorCode.DATA_ERROR.getErrorCode(),
158 LoggerErrorDescription.EXTRACT_COMPOSITION_DATA);
159 throw new CoreException(
160 new ToscaInvalidSubstituteNodeTemplateErrorBuilder(substitutableNodeTemplateId).build());
162 if (context.getHandledServiceTemplates().contains(substituteServiceTemplateFileName.get())) {
163 //each substitution is should be handled once, and will get the connection to the upper
164 // service level according to the first one which was processed
165 mdcDataDebugMessage.debugExitMessage(null);
169 ServiceTemplate substituteServiceTemplate =
170 toscaServiceModel.getServiceTemplates().get(substituteServiceTemplateFileName.get());
171 extractServiceCompositionData(substituteServiceTemplateFileName.get(),
172 substituteServiceTemplate, toscaServiceModel, context);
174 List<Map<String, RequirementAssignment>> substitutableRequirements =
175 substitutableNodeTemplate.getRequirements();
177 if (CollectionUtils.isEmpty(substitutableRequirements)) {
178 mdcDataDebugMessage.debugExitMessage(null);
182 for (Map<String, RequirementAssignment> substitutableReq : substitutableRequirements) {
183 substitutableReq.keySet().stream().filter(reqId -> {
184 RequirementAssignment reqAssignment = toscaExtensionYamlUtil
185 .yamlToObject(toscaExtensionYamlUtil.objectToYaml(substitutableReq.get(reqId)),
186 RequirementAssignment.class);
188 mdcDataDebugMessage.debugExitMessage(null);
189 return isLinkToNetworkRequirementAssignment(reqAssignment);
190 }).forEach(reqId -> {
191 RequirementAssignment linkToNetworkRequirement = toscaExtensionYamlUtil
192 .yamlToObject(toscaExtensionYamlUtil.objectToYaml(substitutableReq.get(reqId)),
193 RequirementAssignment.class);
194 String connectedNodeId = linkToNetworkRequirement.getNode();
195 Optional<NodeTemplate> connectedNodeTemplate =
196 toscaAnalyzerService.getNodeTemplateById(serviceTemplate, connectedNodeId);
198 if (connectedNodeTemplate.isPresent() && toscaAnalyzerService
199 .isTypeOf(connectedNodeTemplate.get(), ToscaNodeType.NATIVE_NETWORK,
200 serviceTemplate, toscaServiceModel)) {
201 Optional<Map.Entry<String, NodeTemplate>> mappedNodeTemplate = toscaAnalyzerService
202 .getSubstitutionMappedNodeTemplateByExposedReq(
203 substituteServiceTemplateFileName.get(), substituteServiceTemplate, reqId);
204 if (!mappedNodeTemplate.isPresent()) {
205 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
206 LoggerTragetServiceName.EXTRACT_COMPOSITION_DATA, ErrorLevel.ERROR.name(),
207 LoggerErrorCode.DATA_ERROR.getErrorCode(),
208 LoggerErrorDescription.EXTRACT_COMPOSITION_DATA);
209 throw new CoreException(new ToscaMissingSubstitutionMappingForReqCapErrorBuilder(
210 ToscaMissingSubstitutionMappingForReqCapErrorBuilder.MappingExposedEntry
211 .REQUIREMENT, connectedNodeId).build());
214 if (toscaAnalyzerService.isTypeOf(mappedNodeTemplate.get().getValue(),
215 ToscaNodeType.NATIVE_NETWORK_PORT, serviceTemplate,
216 toscaServiceModel)) {
217 Nic port = context.getNics().get(mappedNodeTemplate.get().getKey());
219 port.setNetworkName(connectedNodeId);
222 "Different ports define for the same component which is used in different "
223 + "substitution service templates.");
226 } else if (!connectedNodeTemplate.isPresent()) {
227 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
228 LoggerTragetServiceName.EXTRACT_COMPOSITION_DATA, ErrorLevel.ERROR.name(),
229 LoggerErrorCode.DATA_ERROR.getErrorCode(),
230 LoggerErrorDescription.EXTRACT_COMPOSITION_DATA);
231 throw new CoreException(
232 new ToscaInvalidEntryNotFoundErrorBuilder("Node Template", connectedNodeId).build());
238 private boolean isLinkToNetworkRequirementAssignment(RequirementAssignment requirement) {
239 return toscaAnalyzerService.isDesiredRequirementAssignment(requirement,
240 ToscaCapabilityType.NATIVE_NETWORK_LINKABLE, null,
241 ToscaRelationshipType.NATIVE_NETWORK_LINK_TO);
245 private void connectPortToNetwork(Nic port, NodeTemplate portNodeTemplate) {
248 mdcDataDebugMessage.debugEntryMessage(null);
250 List<RequirementAssignment> linkRequirementsToNetwork =
251 toscaAnalyzerService.getRequirements(portNodeTemplate, ToscaConstants.LINK_REQUIREMENT_ID);
253 //port is connected to one network
254 for (RequirementAssignment linkRequirementToNetwork : linkRequirementsToNetwork) {
255 port.setNetworkName(linkRequirementToNetwork.getNode());
258 mdcDataDebugMessage.debugExitMessage(null);
262 return Map with key - compute node template id, value - list of connected port node template id
264 private Map<String, List<String>> getComputeToPortsConnection(
265 Map<String, NodeTemplate> portNodeTemplates) {
268 mdcDataDebugMessage.debugEntryMessage(null);
270 Map<String, List<String>> computeToPortConnection = new HashMap<>();
271 if (MapUtils.isEmpty(portNodeTemplates)) {
272 return computeToPortConnection;
274 for (String portId : portNodeTemplates.keySet()) {
275 List<RequirementAssignment> bindingRequirementsToCompute = toscaAnalyzerService
276 .getRequirements(portNodeTemplates.get(portId), ToscaConstants.BINDING_REQUIREMENT_ID);
277 for (RequirementAssignment bindingRequirementToCompute : bindingRequirementsToCompute) {
278 computeToPortConnection
279 .putIfAbsent(bindingRequirementToCompute.getNode(), new ArrayList<>());
280 computeToPortConnection.get(bindingRequirementToCompute.getNode()).add(portId);
284 mdcDataDebugMessage.debugExitMessage(null);
285 return computeToPortConnection;
288 private void extractComponents(ServiceTemplate serviceTemplate,
289 ToscaServiceModel toscaServiceModel,
290 ExtractCompositionDataContext context) {
293 mdcDataDebugMessage.debugEntryMessage(null);
295 Map<String, NodeTemplate> computeNodeTemplates = toscaAnalyzerService
296 .getNodeTemplatesByType(serviceTemplate, ToscaNodeType.NATIVE_COMPUTE,
298 if (MapUtils.isEmpty(computeNodeTemplates)) {
301 Map<String, List<String>> imageNodeTemplates = getComponentImages(computeNodeTemplates,
303 Map<String, List<String>> computeFlavorNodeTemplates =
304 getComponentComputeFlavor(computeNodeTemplates, toscaServiceModel);
305 Map<String, NodeTemplate> portNodeTemplates = toscaAnalyzerService
306 .getNodeTemplatesByType(serviceTemplate, ToscaNodeType.NATIVE_NETWORK_PORT,
308 Map<String, List<String>> computeToPortsConnection =
309 getComputeToPortsConnection(portNodeTemplates);
310 Map<String, List<String>> computesGroupedByType =
311 getNodeTemplatesGroupedByType(computeNodeTemplates);
313 computesGroupedByType.keySet()
316 !context.getCreatedComponents().contains(nodeType))
317 .forEach(nodeType -> extractComponent(serviceTemplate, computeToPortsConnection,
318 computesGroupedByType, imageNodeTemplates, computeFlavorNodeTemplates, nodeType,
321 mdcDataDebugMessage.debugExitMessage(null);
324 private Map<String,List<String>> getComponentImages(Map<String, NodeTemplate>
325 computeNodeTemplates,
326 ToscaServiceModel toscaServiceModel) {
327 Map<String,List<String>> computeImages = new HashMap<>();
328 for (String component : computeNodeTemplates.keySet()) {
329 List<String> images = new ArrayList<>();
330 Map<String,Object> properties = computeNodeTemplates.get(component).getProperties();
332 List<Object> imagesList = properties.entrySet()
334 .filter(map -> map.getKey().equals("image"))
335 .map(map -> map.getValue())
336 .collect(Collectors.toList());
337 for (Object obj : imagesList) {
338 if (obj instanceof String) {
339 images.add((String) obj);
341 HashMap<String,String> objMap = new ObjectMapper().convertValue(obj,HashMap.class);
342 images.add(getInputs(toscaServiceModel,objMap.get("get_input")));
345 computeImages.put(component,images);
347 return computeImages;
350 private Map<String,List<String>> getComponentComputeFlavor(Map<String, NodeTemplate>
351 computeNodeTemplates,
352 ToscaServiceModel toscaServiceModel) {
353 Map<String,List<String>> componentComputeFlavor = new HashMap<>();
354 for (String component : computeNodeTemplates.keySet()) {
355 List<String> computes = new ArrayList<>();
356 Map<String,Object> properties = computeNodeTemplates.get(component).getProperties();
358 List<Object> computessList = properties.entrySet()
360 .filter(map -> map.getKey().equals("flavor"))
361 .map(map -> map.getValue())
362 .collect(Collectors.toList());
363 for (Object obj : computessList) {
364 if (obj instanceof String) {
365 computes.add((String) obj);
367 HashMap<String, String> objMap = new ObjectMapper().convertValue(obj, HashMap.class);
368 computes.add(getInputs(toscaServiceModel, objMap.get("get_input")));
371 componentComputeFlavor.put(component,computes);
373 return componentComputeFlavor;
376 private String getInputs(ToscaServiceModel toscaServiceModel, String inputValue) {
377 String mainTemplate = toscaServiceModel.getEntryDefinitionServiceTemplate();
378 List<ServiceTemplate> toscaServiceTemplates = toscaServiceModel.getServiceTemplates().entrySet()
380 .filter(map -> map.getKey().equals(mainTemplate))
381 .map(map -> map.getValue())
382 .collect(Collectors.toList());
383 ServiceTemplate serviceTemplate = toscaServiceTemplates.get(0);
385 if (Objects.nonNull(serviceTemplate.getTopology_template())
386 && MapUtils.isNotEmpty(serviceTemplate.getTopology_template().getInputs())) {
387 for (Map.Entry<String, ParameterDefinition> inputEntry : serviceTemplate
388 .getTopology_template().getInputs().entrySet()) {
389 if (inputEntry.getKey().equals(inputValue)) {
390 return (String)inputEntry.getValue().get_default();
397 private void extractComponent(ServiceTemplate serviceTemplate,
398 Map<String, List<String>> computeToPortsConnection,
399 Map<String, List<String>> computesGroupedByType,
400 Map<String, List<String>> imageList,
401 Map<String, List<String>> computeFlavorNodeTemplates,
402 String computeNodeType,
403 ExtractCompositionDataContext context) {
404 ComponentData component = new ComponentData();
405 component.setName(computeNodeType);
406 component.setDisplayName(getComponentDisplayName(component.getName()));
407 component.setVfcCode(component.getDisplayName());
408 Component componentModel = new Component();
409 componentModel.setData(component);
411 String computeId = computesGroupedByType.get(computeNodeType).get(0);
412 List<String> connectedPortIds = computeToPortsConnection.get(computeId);
413 List<String> images = imageList.get(computeId);
414 List<String> computeFlavors = computeFlavorNodeTemplates.get(computeId);
416 if (connectedPortIds != null) {
417 componentModel.setNics(new ArrayList<>());
418 componentModel.setImages(new ArrayList<>());
419 componentModel.setCompute(new ArrayList<>());
420 for (String portId : connectedPortIds) {
421 Nic port = extractPort(serviceTemplate, portId);
422 componentModel.getNics().add(port);
423 context.addNic(portId, port);
425 for (String image : images) {
426 Image img = new Image(image);
427 componentModel.getImages().add(img);
428 context.addImage(image, img);
430 for (String flavor : computeFlavors) {
431 ComputeData computeFlavor = new ComputeData(flavor);
432 componentModel.getCompute().add(computeFlavor);
433 context.addCompute(flavor,computeFlavor);
436 context.addComponent(componentModel);
437 context.getCreatedComponents().add(computeNodeType);
440 private Nic extractPort(ServiceTemplate serviceTemplate, String portNodeTemplateId) {
441 Optional<NodeTemplate> portNodeTemplate =
442 toscaAnalyzerService.getNodeTemplateById(serviceTemplate, portNodeTemplateId);
443 if (portNodeTemplate.isPresent()) {
444 Nic port = new Nic();
445 port.setName(portNodeTemplateId);
446 connectPortToNetwork(port, portNodeTemplate.get());
449 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
450 LoggerTragetServiceName.EXTRACT_COMPOSITION_DATA, ErrorLevel.ERROR.name(),
451 LoggerErrorCode.DATA_ERROR.getErrorCode(),
452 LoggerErrorDescription.EXTRACT_COMPOSITION_DATA);
453 throw new CoreException(
454 new ToscaInvalidEntryNotFoundErrorBuilder("Node Template", portNodeTemplateId).build());
458 private Map<String, List<String>> getNodeTemplatesGroupedByType(
459 Map<String, NodeTemplate> nodeTemplates) {
462 mdcDataDebugMessage.debugEntryMessage(null);
464 Map<String, List<String>> nodeTemplatesGrouped =
465 new HashMap<>(); //key - node type, value - list of node ids with this type
466 for (String nodeId : nodeTemplates.keySet()) {
467 String nodeType = nodeTemplates.get(nodeId).getType();
468 nodeTemplatesGrouped.putIfAbsent(nodeType, new ArrayList<>());
469 nodeTemplatesGrouped.get(nodeType).add(nodeId);
472 mdcDataDebugMessage.debugExitMessage(null);
473 return nodeTemplatesGrouped;
476 private List<Network> extractNetworks(ServiceTemplate serviceTemplate,
477 ToscaServiceModel toscaServiceModel) {
480 mdcDataDebugMessage.debugEntryMessage(null);
482 List<Network> networks = new ArrayList<>();
483 Map<String, NodeTemplate> networkNodeTemplates = toscaAnalyzerService
484 .getNodeTemplatesByType(serviceTemplate, ToscaNodeType.NATIVE_NETWORK,
486 if (MapUtils.isEmpty(networkNodeTemplates)) {
487 mdcDataDebugMessage.debugExitMessage(null);
490 for (String networkId : networkNodeTemplates.keySet()) {
491 Network network = new Network();
492 network.setName(networkId);
493 Optional<Boolean> networkDhcpValue =
494 getNetworkDhcpValue(serviceTemplate, networkNodeTemplates.get(networkId));
495 network.setDhcp(networkDhcpValue.isPresent() ? networkDhcpValue.get() : true);
496 networks.add(network);
499 mdcDataDebugMessage.debugExitMessage(null);
503 //dhcp default value is true
504 private Optional<Boolean> getNetworkDhcpValue(ServiceTemplate serviceTemplate,
505 NodeTemplate networkNodeTemplate) {
508 mdcDataDebugMessage.debugEntryMessage(null);
510 if (networkNodeTemplate == null) {
511 return Optional.empty();
513 if (networkNodeTemplate.getProperties() == null
514 || networkNodeTemplate.getProperties().get(ToscaConstants.DHCP_ENABLED_PROPERTY_NAME)
516 mdcDataDebugMessage.debugExitMessage(null);
517 return Optional.of(true);
521 networkNodeTemplate.getProperties().get(ToscaConstants.DHCP_ENABLED_PROPERTY_NAME);
522 if (dhcp instanceof String) {
523 mdcDataDebugMessage.debugExitMessage(null);
524 return Optional.of(Boolean.valueOf((String) dhcp));
525 } else if (dhcp instanceof Boolean) {
526 mdcDataDebugMessage.debugExitMessage(null);
527 return Optional.of((Boolean) dhcp);
528 } else if (dhcp instanceof Map) {
529 String inputParameterName =
530 (String) ((Map) dhcp).get(ToscaFunctions.GET_INPUT.getDisplayName());
531 if (inputParameterName != null) {
532 ParameterDefinition inputParameterDefinition =
533 serviceTemplate.getTopology_template().getInputs().get(inputParameterName);
534 if (inputParameterDefinition != null) {
535 if (inputParameterDefinition.get_default() != null) {
536 mdcDataDebugMessage.debugExitMessage(null);
537 return Optional.of(Boolean.valueOf(inputParameterDefinition.get_default().toString()));
540 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
541 LoggerTragetServiceName.EXTRACT_COMPOSITION_DATA, ErrorLevel.ERROR.name(),
542 LoggerErrorCode.DATA_ERROR.getErrorCode(),
543 LoggerErrorDescription.EXTRACT_COMPOSITION_DATA);
544 throw new CoreException(
545 new ToscaInvalidEntryNotFoundErrorBuilder("Input Parameter", inputParameterName)
551 mdcDataDebugMessage.debugExitMessage(null);
552 return Optional.of(true);
556 public String getComponentDisplayName(String componentName) {
557 if (componentName == null) {
560 String delimiterChar = ".";
561 if (componentName.contains(delimiterChar)) {
562 return componentName.substring(componentName.lastIndexOf(delimiterChar) + 1);
564 return componentName;