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.ToscaExtensionYamlUtil;
51 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
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 return getComponentProperty(ToscaConstants.COMPUTE_IMAGE, computeNodeTemplates, toscaServiceModel);
330 private Map<String,List<String>> getComponentComputeFlavor(Map<String, NodeTemplate>
331 computeNodeTemplates,
332 ToscaServiceModel toscaServiceModel) {
333 return getComponentProperty(ToscaConstants.COMPUTE_FLAVOR, computeNodeTemplates, toscaServiceModel);
336 private Map<String, List<String>> getComponentProperty(String propertyName,
337 Map<String, NodeTemplate> computeNodeTemplates,
338 ToscaServiceModel toscaServiceModel) {
339 Map<String,List<String>> componentPropertyValues = new HashMap<>();
340 for (String component : computeNodeTemplates.keySet()) {
341 List<String> computes = new ArrayList<>();
342 Map<String,Object> properties = computeNodeTemplates.get(component).getProperties();
344 if(MapUtils.isEmpty(properties)){
348 List<Object> computesList = properties.entrySet()
350 .filter(map -> map.getKey().equals(propertyName))
351 .map(Map.Entry::getValue)
352 .collect(Collectors.toList());
353 for (Object obj : computesList) {
354 if (obj instanceof String) {
355 computes.add((String) obj);
357 Map<String, String> objMap = new ObjectMapper().convertValue(obj, Map.class);
358 computes.add(getInputs(toscaServiceModel, objMap.get("get_input")));
361 componentPropertyValues.put(component,computes);
363 return componentPropertyValues;
366 private String getInputs(ToscaServiceModel toscaServiceModel, String inputValue) {
367 String mainTemplate = toscaServiceModel.getEntryDefinitionServiceTemplate();
368 List<ServiceTemplate> toscaServiceTemplates = toscaServiceModel.getServiceTemplates().entrySet()
370 .filter(map -> map.getKey().equals(mainTemplate))
371 .map(map -> map.getValue())
372 .collect(Collectors.toList());
373 ServiceTemplate serviceTemplate = toscaServiceTemplates.get(0);
375 if (Objects.nonNull(serviceTemplate.getTopology_template())
376 && MapUtils.isNotEmpty(serviceTemplate.getTopology_template().getInputs())) {
377 for (Map.Entry<String, ParameterDefinition> inputEntry : serviceTemplate
378 .getTopology_template().getInputs().entrySet()) {
379 if (inputEntry.getKey().equals(inputValue)) {
382 value= (String) inputEntry.getValue().get_default();
383 } catch (Exception e) {
384 logger.debug(e.getMessage(), e);
385 value = inputEntry.getValue().get_default().toString();
394 private void extractComponent(ServiceTemplate serviceTemplate,
395 Map<String, List<String>> computeToPortsConnection,
396 Map<String, List<String>> computesGroupedByType,
397 Map<String, List<String>> imageList,
398 Map<String, List<String>> computeFlavorNodeTemplates,
399 String computeNodeType,
400 ExtractCompositionDataContext context) {
401 ComponentData component = new ComponentData();
402 component.setName(computeNodeType);
403 component.setDisplayName(getComponentDisplayName(component.getName()));
404 component.setVfcCode(component.getDisplayName());
405 Component componentModel = new Component();
406 componentModel.setData(component);
408 String computeId = computesGroupedByType.get(computeNodeType).get(0);
409 List<String> connectedPortIds = computeToPortsConnection.get(computeId);
410 List<String> images = imageList.get(computeId);
411 List<String> computeFlavors = computeFlavorNodeTemplates.get(computeId);
413 if (connectedPortIds != null) {
414 componentModel.setNics(new ArrayList<>());
415 componentModel.setImages(new ArrayList<>());
416 componentModel.setCompute(new ArrayList<>());
417 for (String portId : connectedPortIds) {
418 Nic port = extractPort(serviceTemplate, portId);
419 componentModel.getNics().add(port);
420 context.addNic(portId, port);
422 for (String image : images) {
423 Image img = new Image(image);
424 componentModel.getImages().add(img);
425 context.addImage(image, img);
427 for (String flavor : computeFlavors) {
428 ComputeData computeFlavor = new ComputeData(flavor);
429 componentModel.getCompute().add(computeFlavor);
430 context.addCompute(flavor,computeFlavor);
433 context.addComponent(componentModel);
434 context.getCreatedComponents().add(computeNodeType);
437 private Nic extractPort(ServiceTemplate serviceTemplate, String portNodeTemplateId) {
438 Optional<NodeTemplate> portNodeTemplate =
439 toscaAnalyzerService.getNodeTemplateById(serviceTemplate, portNodeTemplateId);
440 if (portNodeTemplate.isPresent()) {
441 Nic port = new Nic();
442 port.setName(portNodeTemplateId);
443 connectPortToNetwork(port, portNodeTemplate.get());
446 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
447 LoggerTragetServiceName.EXTRACT_COMPOSITION_DATA, ErrorLevel.ERROR.name(),
448 LoggerErrorCode.DATA_ERROR.getErrorCode(),
449 LoggerErrorDescription.EXTRACT_COMPOSITION_DATA);
450 throw new CoreException(
451 new ToscaInvalidEntryNotFoundErrorBuilder("Node Template", portNodeTemplateId).build());
455 private Map<String, List<String>> getNodeTemplatesGroupedByType(
456 Map<String, NodeTemplate> nodeTemplates) {
459 mdcDataDebugMessage.debugEntryMessage(null);
461 Map<String, List<String>> nodeTemplatesGrouped =
462 new HashMap<>(); //key - node type, value - list of node ids with this type
463 for (String nodeId : nodeTemplates.keySet()) {
464 String nodeType = nodeTemplates.get(nodeId).getType();
465 nodeTemplatesGrouped.putIfAbsent(nodeType, new ArrayList<>());
466 nodeTemplatesGrouped.get(nodeType).add(nodeId);
469 mdcDataDebugMessage.debugExitMessage(null);
470 return nodeTemplatesGrouped;
473 private List<Network> extractNetworks(ServiceTemplate serviceTemplate,
474 ToscaServiceModel toscaServiceModel) {
477 mdcDataDebugMessage.debugEntryMessage(null);
479 List<Network> networks = new ArrayList<>();
480 Map<String, NodeTemplate> networkNodeTemplates = toscaAnalyzerService
481 .getNodeTemplatesByType(serviceTemplate, ToscaNodeType.NATIVE_NETWORK,
483 if (MapUtils.isEmpty(networkNodeTemplates)) {
484 mdcDataDebugMessage.debugExitMessage(null);
487 for (String networkId : networkNodeTemplates.keySet()) {
488 Network network = new Network();
489 network.setName(networkId);
490 Optional<Boolean> networkDhcpValue =
491 getNetworkDhcpValue(serviceTemplate, networkNodeTemplates.get(networkId));
492 network.setDhcp(networkDhcpValue.isPresent() ? networkDhcpValue.get() : true);
493 networks.add(network);
496 mdcDataDebugMessage.debugExitMessage(null);
500 //dhcp default value is true
501 private Optional<Boolean> getNetworkDhcpValue(ServiceTemplate serviceTemplate,
502 NodeTemplate networkNodeTemplate) {
505 mdcDataDebugMessage.debugEntryMessage(null);
507 if (networkNodeTemplate == null) {
508 return Optional.empty();
510 if (networkNodeTemplate.getProperties() == null
511 || networkNodeTemplate.getProperties().get(ToscaConstants.DHCP_ENABLED_PROPERTY_NAME)
513 mdcDataDebugMessage.debugExitMessage(null);
514 return Optional.of(true);
518 networkNodeTemplate.getProperties().get(ToscaConstants.DHCP_ENABLED_PROPERTY_NAME);
519 if (dhcp instanceof String) {
520 mdcDataDebugMessage.debugExitMessage(null);
521 return Optional.of(Boolean.valueOf((String) dhcp));
522 } else if (dhcp instanceof Boolean) {
523 mdcDataDebugMessage.debugExitMessage(null);
524 return Optional.of((Boolean) dhcp);
525 } else if (dhcp instanceof Map) {
526 String inputParameterName =
527 (String) ((Map) dhcp).get(ToscaFunctions.GET_INPUT.getDisplayName());
528 if (inputParameterName != null) {
529 ParameterDefinition inputParameterDefinition =
530 serviceTemplate.getTopology_template().getInputs().get(inputParameterName);
531 if (inputParameterDefinition != null) {
532 if (inputParameterDefinition.get_default() != null) {
533 mdcDataDebugMessage.debugExitMessage(null);
534 return Optional.of(Boolean.valueOf(inputParameterDefinition.get_default().toString()));
537 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_API,
538 LoggerTragetServiceName.EXTRACT_COMPOSITION_DATA, ErrorLevel.ERROR.name(),
539 LoggerErrorCode.DATA_ERROR.getErrorCode(),
540 LoggerErrorDescription.EXTRACT_COMPOSITION_DATA);
541 throw new CoreException(
542 new ToscaInvalidEntryNotFoundErrorBuilder("Input Parameter", inputParameterName)
548 mdcDataDebugMessage.debugExitMessage(null);
549 return Optional.of(true);
553 public String getComponentDisplayName(String componentName) {
554 if (componentName == null) {
557 String delimiterChar = ".";
558 if (componentName.contains(delimiterChar)) {
559 return componentName.substring(componentName.lastIndexOf(delimiterChar) + 1);
561 return componentName;