2 * Copyright (C) 2020 CMCC, Inc. and others. All rights reserved.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
16 package org.openecomp.sdc.be.components.impl;
18 import static java.util.stream.Collectors.joining;
19 import static java.util.stream.Collectors.toList;
20 import static java.util.stream.Collectors.toMap;
21 import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
22 import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaMapElement;
23 import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaStringElement;
24 import static org.openecomp.sdc.be.components.impl.ImportUtils.getPropertyJsonStringValue;
25 import static org.openecomp.sdc.be.tosca.CsarUtils.VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN;
27 import com.google.gson.Gson;
28 import fj.data.Either;
29 import java.util.ArrayList;
30 import java.util.Collection;
31 import java.util.Collections;
32 import java.util.EnumMap;
33 import java.util.HashMap;
34 import java.util.HashSet;
35 import java.util.Iterator;
36 import java.util.List;
38 import java.util.Map.Entry;
39 import java.util.Optional;
41 import java.util.concurrent.atomic.AtomicReference;
42 import java.util.regex.Pattern;
45 import org.apache.commons.collections.CollectionUtils;
46 import org.apache.commons.collections.MapUtils;
47 import org.apache.commons.lang3.StringUtils;
48 import org.apache.commons.lang3.tuple.ImmutablePair;
49 import org.json.simple.JSONObject;
50 import org.openecomp.sdc.be.components.csar.CsarArtifactsAndGroupsBusinessLogic;
51 import org.openecomp.sdc.be.components.csar.CsarBusinessLogic;
52 import org.openecomp.sdc.be.components.csar.CsarInfo;
53 import org.openecomp.sdc.be.components.csar.ServiceCsarInfo;
54 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
55 import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
56 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
57 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
58 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
59 import org.openecomp.sdc.be.components.impl.utils.CINodeFilterUtils;
60 import org.openecomp.sdc.be.components.impl.utils.CreateServiceFromYamlParameter;
61 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
62 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
63 import org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic;
64 import org.openecomp.sdc.be.config.BeEcompErrorManager;
65 import org.openecomp.sdc.be.config.ConfigurationManager;
66 import org.openecomp.sdc.be.dao.api.ActionStatus;
67 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
68 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
69 import org.openecomp.sdc.be.datamodel.utils.ArtifactUtils;
70 import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
71 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
72 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
73 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
74 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
75 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
76 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
77 import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition;
78 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
79 import org.openecomp.sdc.be.datatypes.elements.RequirementSubstitutionFilterPropertyDataDefinition;
80 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
81 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
82 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
83 import org.openecomp.sdc.be.datatypes.tosca.ToscaGetFunctionType;
84 import org.openecomp.sdc.be.impl.ComponentsUtils;
85 import org.openecomp.sdc.be.info.NodeTypeInfoToUpdateArtifacts;
86 import org.openecomp.sdc.be.model.ArtifactDefinition;
87 import org.openecomp.sdc.be.model.AttributeDefinition;
88 import org.openecomp.sdc.be.model.CapabilityDefinition;
89 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
90 import org.openecomp.sdc.be.model.Component;
91 import org.openecomp.sdc.be.model.ComponentInstance;
92 import org.openecomp.sdc.be.model.ComponentInstanceInput;
93 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
94 import org.openecomp.sdc.be.model.ComponentParametersView;
95 import org.openecomp.sdc.be.model.DataTypeDefinition;
96 import org.openecomp.sdc.be.model.DistributionStatusEnum;
97 import org.openecomp.sdc.be.model.GroupDefinition;
98 import org.openecomp.sdc.be.model.InputDefinition;
99 import org.openecomp.sdc.be.model.InterfaceDefinition;
100 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
101 import org.openecomp.sdc.be.model.LifecycleStateEnum;
102 import org.openecomp.sdc.be.model.NodeTypeDefinition;
103 import org.openecomp.sdc.be.model.NodeTypeInfo;
104 import org.openecomp.sdc.be.model.NodeTypeMetadata;
105 import org.openecomp.sdc.be.model.NodeTypesMetadataList;
106 import org.openecomp.sdc.be.model.Operation;
107 import org.openecomp.sdc.be.model.OutputDefinition;
108 import org.openecomp.sdc.be.model.ParsedToscaYamlInfo;
109 import org.openecomp.sdc.be.model.PolicyDefinition;
110 import org.openecomp.sdc.be.model.PropertyDefinition;
111 import org.openecomp.sdc.be.model.RelationshipImpl;
112 import org.openecomp.sdc.be.model.RelationshipInfo;
113 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
114 import org.openecomp.sdc.be.model.RequirementDefinition;
115 import org.openecomp.sdc.be.model.Resource;
116 import org.openecomp.sdc.be.model.Service;
117 import org.openecomp.sdc.be.model.UploadAttributeInfo;
118 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
119 import org.openecomp.sdc.be.model.UploadInterfaceInfo;
120 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
121 import org.openecomp.sdc.be.model.UploadPropInfo;
122 import org.openecomp.sdc.be.model.UploadReqInfo;
123 import org.openecomp.sdc.be.model.UploadResourceInfo;
124 import org.openecomp.sdc.be.model.User;
125 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
126 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
127 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
128 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
129 import org.openecomp.sdc.be.model.operations.StorageException;
130 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
131 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
132 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
133 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
134 import org.openecomp.sdc.be.tosca.CsarUtils;
135 import org.openecomp.sdc.be.tosca.ToscaExportHandler;
136 import org.openecomp.sdc.be.ui.model.OperationUi;
137 import org.openecomp.sdc.be.utils.TypeUtils;
138 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
139 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
140 import org.openecomp.sdc.common.api.Constants;
141 import org.openecomp.sdc.common.datastructure.Wrapper;
142 import org.openecomp.sdc.common.kpi.api.ASDCKpiApi;
143 import org.openecomp.sdc.common.log.wrappers.Logger;
144 import org.openecomp.sdc.common.util.ValidationUtils;
145 import org.openecomp.sdc.exception.ResponseFormat;
146 import org.springframework.beans.factory.annotation.Autowired;
147 import org.yaml.snakeyaml.Yaml;
151 @org.springframework.stereotype.Component("serviceImportBusinessLogic")
152 public class ServiceImportBusinessLogic {
154 protected static final String CREATE_RESOURCE = "Create Resource";
155 private static final String INITIAL_VERSION = "0.1";
156 private static final String IN_RESOURCE = " in resource {} ";
157 private static final String COMPONENT_INSTANCE_WITH_NAME = "component instance with name ";
158 private static final String COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE = "component instance with name {} in resource {} ";
159 private static final String CERTIFICATION_ON_IMPORT = "certification on import";
160 private static final String VALIDATE_DERIVED_BEFORE_UPDATE = "validate derived before update";
161 private static final String PLACE_HOLDER_RESOURCE_TYPES = "validForResourceTypes";
162 private static final String CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES = "Create Resource - validateCapabilityTypesCreate";
163 private static final String CATEGORY_IS_EMPTY = "Resource category is empty";
164 private static final Logger log = Logger.getLogger(ServiceImportBusinessLogic.class);
166 private final ComponentsUtils componentsUtils;
167 private final ToscaOperationFacade toscaOperationFacade;
168 private final ServiceBusinessLogic serviceBusinessLogic;
169 private final CsarBusinessLogic csarBusinessLogic;
170 private final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic;
171 private final LifecycleBusinessLogic lifecycleBusinessLogic;
172 private final CompositionBusinessLogic compositionBusinessLogic;
173 private final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic;
174 private final ServiceImportParseLogic serviceImportParseLogic;
175 private final GroupBusinessLogic groupBusinessLogic;
176 private final PolicyBusinessLogic policyBusinessLogic;
177 private final ResourceImportManager resourceImportManager;
178 private final JanusGraphDao janusGraphDao;
179 private final ArtifactsBusinessLogic artifactsBusinessLogic;
180 private final IGraphLockOperation graphLockOperation;
181 private final ToscaFunctionService toscaFunctionService;
182 private final DataTypeBusinessLogic dataTypeBusinessLogic;
183 private ApplicationDataTypeCache applicationDataTypeCache;
185 public ServiceImportBusinessLogic(final GroupBusinessLogic groupBusinessLogic, final ArtifactsBusinessLogic artifactsBusinessLogic,
186 final ComponentsUtils componentsUtils, final ToscaOperationFacade toscaOperationFacade,
187 final ServiceBusinessLogic serviceBusinessLogic, final CsarBusinessLogic csarBusinessLogic,
188 final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic,
189 final LifecycleBusinessLogic lifecycleBusinessLogic, final CompositionBusinessLogic compositionBusinessLogic,
190 final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic,
191 final ServiceImportParseLogic serviceImportParseLogic, final PolicyBusinessLogic policyBusinessLogic,
192 final ResourceImportManager resourceImportManager, final JanusGraphDao janusGraphDao,
193 final IGraphLockOperation graphLockOperation, final ToscaFunctionService toscaFunctionService,
194 final DataTypeBusinessLogic dataTypeBusinessLogic) {
195 this.componentsUtils = componentsUtils;
196 this.toscaOperationFacade = toscaOperationFacade;
197 this.serviceBusinessLogic = serviceBusinessLogic;
198 this.csarBusinessLogic = csarBusinessLogic;
199 this.csarArtifactsAndGroupsBusinessLogic = csarArtifactsAndGroupsBusinessLogic;
200 this.lifecycleBusinessLogic = lifecycleBusinessLogic;
201 this.compositionBusinessLogic = compositionBusinessLogic;
202 this.resourceDataMergeBusinessLogic = resourceDataMergeBusinessLogic;
203 this.serviceImportParseLogic = serviceImportParseLogic;
204 this.groupBusinessLogic = groupBusinessLogic;
205 this.policyBusinessLogic = policyBusinessLogic;
206 this.resourceImportManager = resourceImportManager;
207 this.janusGraphDao = janusGraphDao;
208 this.artifactsBusinessLogic = artifactsBusinessLogic;
209 this.graphLockOperation = graphLockOperation;
210 this.toscaFunctionService = toscaFunctionService;
211 this.dataTypeBusinessLogic = dataTypeBusinessLogic;
215 public void setApplicationDataTypeCache(ApplicationDataTypeCache applicationDataTypeCache) {
216 this.applicationDataTypeCache = applicationDataTypeCache;
219 public Service createService(Service service, AuditingActionEnum auditingAction, User user, Map<String, byte[]> csarUIPayload,
220 String payloadName) {
221 log.debug("enter createService");
222 service.setCreatorUserId(user.getUserId());
223 service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
224 service.setVersion(INITIAL_VERSION);
225 service.setConformanceLevel(ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel());
226 service.setDistributionStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
228 final var serviceBeforeCreate = serviceBusinessLogic.validateServiceBeforeCreate(service, user, auditingAction);
229 if (serviceBeforeCreate.isRight()) {
230 throw new ComponentException(ActionStatus.GENERAL_ERROR);
232 log.debug("enter createService,validateServiceBeforeCreate success");
233 String csarUUID = payloadName == null ? service.getCsarUUID() : payloadName;
234 log.debug("enter createService,get csarUUID:{}", csarUUID);
235 csarBusinessLogic.validateCsarBeforeCreate(service, csarUUID);
236 log.debug("CsarUUID is {} - going to create resource from CSAR", csarUUID);
237 return createServiceFromCsar(service, user, csarUIPayload, csarUUID);
238 } catch (final ComponentException e) {
239 log.debug("Exception occurred when createService: {}", e.getMessage(), e);
241 } catch (final Exception e) {
242 log.debug("Exception occurred when createService: {}", e.getMessage(), e);
243 throw new ComponentException(ActionStatus.GENERAL_ERROR);
247 protected Service createServiceFromCsar(Service service, User user, Map<String, byte[]> csarUIPayload, String csarUUID) {
248 log.trace("************* created successfully from YAML, resource TOSCA ");
250 ServiceCsarInfo csarInfo = csarBusinessLogic.getCsarInfo(service, null, user, csarUIPayload, csarUUID);
252 final Map<String, Object> dataTypesToCreate = getDatatypesToCreate(service.getModel(), csarInfo);
253 if (MapUtils.isNotEmpty(dataTypesToCreate)) {
254 dataTypeBusinessLogic.createDataTypeFromYaml(new Yaml().dump(dataTypesToCreate), service.getModel(), true);
255 dataTypesToCreate.entrySet().stream().forEach(createdOrUpdatedDataType -> {
256 applicationDataTypeCache.reload(service.getModel(), UniqueIdBuilder.buildDataTypeUid(service.getModel(), createdOrUpdatedDataType.getKey()));
259 final List<NodeTypeDefinition> nodeTypesToCreate = getNodeTypesToCreate(service.getModel(), csarInfo);
260 if (CollectionUtils.isNotEmpty(nodeTypesToCreate)) {
261 createNodeTypes(nodeTypesToCreate, service.getModel(), csarInfo.getModifier());
263 Map<String, NodeTypeInfo> nodeTypesInfo = csarInfo.extractTypesInfo();
264 Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandleRes = serviceImportParseLogic
265 .findNodeTypesArtifactsToHandle(nodeTypesInfo, csarInfo, service);
266 if (findNodeTypesArtifactsToHandleRes.isRight()) {
267 log.debug("failed to find node types for update with artifacts during import csar {}. ", csarInfo.getCsarUUID());
268 throw new ComponentException(findNodeTypesArtifactsToHandleRes.right().value());
270 return createServiceFromYaml(service, csarInfo.getMainTemplateContent(), csarInfo.getMainTemplateName(), nodeTypesInfo, csarInfo,
271 findNodeTypesArtifactsToHandleRes.left().value(), true, false, null, user.getUserId());
272 } catch (final ComponentException e) {
273 log.debug("Exception occurred when createServiceFromCsar,error is:{}", e.getMessage(), e);
275 } catch (final Exception e) {
276 log.debug("Exception occurred when createServiceFromCsar,error is:{}", e.getMessage(), e);
277 throw new ComponentException(ActionStatus.GENERAL_ERROR);
281 private Map<String, Object> getDatatypesToCreate(final String model, final CsarInfo csarInfo) {
282 final Map<String, Object> dataTypesToCreate = new HashMap<>();
284 for (final Entry<String, Object> dataTypeEntry : csarInfo.getDataTypes().entrySet()) {
285 final Either<DataTypeDefinition, JanusGraphOperationStatus> result = applicationDataTypeCache.get(model,
286 UniqueIdBuilder.buildDataTypeUid(model, dataTypeEntry.getKey()));
287 if (result.isRight() && result.right().value().equals(JanusGraphOperationStatus.NOT_FOUND)) {
288 dataTypesToCreate.put(dataTypeEntry.getKey(), dataTypeEntry.getValue());
289 log.info("Deploying unknown type " + dataTypeEntry.getKey() + " to model " + model + " from package " + csarInfo.getCsarUUID());
291 if (hasNewProperties(result, (Map<String, Map<String, Object>>) dataTypeEntry.getValue())) {
292 dataTypesToCreate.put(dataTypeEntry.getKey(), dataTypeEntry.getValue());
293 log.info("Deploying new version of type " + dataTypeEntry.getKey() + " to model " + model + " from package " + csarInfo.getCsarUUID());
296 return dataTypesToCreate;
299 private boolean hasNewProperties(final Either<DataTypeDefinition, JanusGraphOperationStatus> result, final Map<String, Map<String, Object>> dataType) {
300 return result.isLeft() && dataType.containsKey("properties") && result.left().value().getProperties() != null
301 && result.left().value().getProperties().size() != dataType.get("properties").size();
304 private void createNodeTypes(List<NodeTypeDefinition> nodeTypesToCreate, String model, User user) {
305 NodeTypesMetadataList nodeTypesMetadataList = new NodeTypesMetadataList();
306 List<NodeTypeMetadata> nodeTypeMetadataList = new ArrayList<>();
307 final Map<String, Object> allTypesToCreate = new HashMap<>();
308 nodeTypesToCreate.stream().forEach(nodeType -> {
309 allTypesToCreate.put(nodeType.getMappedNodeType().getKey(), nodeType.getMappedNodeType().getValue());
310 nodeTypeMetadataList.add(nodeType.getNodeTypeMetadata());
312 nodeTypesMetadataList.setNodeMetadataList(nodeTypeMetadataList);
313 resourceImportManager.importAllNormativeResource(allTypesToCreate, nodeTypesMetadataList, user, model,true, false);
316 private List<NodeTypeDefinition> getNodeTypesToCreate(final String model, final ServiceCsarInfo csarInfo) {
317 List<NodeTypeDefinition> namesOfNodeTypesToCreate = new ArrayList<>();
319 for (final NodeTypeDefinition nodeTypeDefinition : csarInfo.getNodeTypesUsed()) {
320 Either<Component, StorageOperationStatus> result = toscaOperationFacade
321 .getLatestByToscaResourceName(nodeTypeDefinition.getMappedNodeType().getKey(), model);
322 if (result.isRight() && result.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
323 namesOfNodeTypesToCreate.add(nodeTypeDefinition);
324 } else if (result.isLeft()) {
325 Resource latestResource = (Resource) result.left().value();
326 Entry<String, Object> latestMappedToscaTemplate = getResourceToscaTemplate(latestResource.getUniqueId(),
327 latestResource.getToscaArtifacts().get(ToscaExportHandler.ASSET_TOSCA_TEMPLATE), csarInfo.getModifier().getUserId());
328 Map<String, Object> mappedToscaTemplate = (Map<String, Object>) nodeTypeDefinition.getMappedNodeType().getValue();
329 Map<String, Object> newMappedToscaTemplate =
330 getNewChangesToToscaTemplate(mappedToscaTemplate, (Map<String, Object>) latestMappedToscaTemplate.getValue());
331 if (!newMappedToscaTemplate.equals(latestMappedToscaTemplate.getValue())) {
332 latestMappedToscaTemplate.setValue(newMappedToscaTemplate);
333 nodeTypeDefinition.setMappedNodeType(latestMappedToscaTemplate);
334 namesOfNodeTypesToCreate.add(nodeTypeDefinition);
338 return namesOfNodeTypesToCreate;
341 private Entry<String, Object> getResourceToscaTemplate(String uniqueId, ArtifactDefinition assetToscaTemplate, String userId) {
342 String assetToToscaTemplate = assetToscaTemplate.getUniqueId();
343 ImmutablePair<String, byte[]> toscaTemplate = artifactsBusinessLogic.
344 handleDownloadRequestById(uniqueId, assetToToscaTemplate, userId, ComponentTypeEnum.RESOURCE, null, null);
345 Map<String, Object> mappedToscaTemplate = new Yaml().load(new String(toscaTemplate.right));
346 Either<Map<String, Object>, ImportUtils.ResultStatusEnum> eitherNodeTypes =
347 findFirstToscaMapElement(mappedToscaTemplate, TypeUtils.ToscaTagNamesEnum.NODE_TYPES);
348 if (eitherNodeTypes.isRight()) {
349 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
351 Entry<String, Object> entry = eitherNodeTypes.left().value().entrySet().iterator().next();
355 private Map<String, Object> getNewChangesToToscaTemplate(Map<String, Object> mappedToscaTemplate, Map<String, Object> latestMappedToscaTemplate) {
356 Map<String, Object> newMappedToscaTemplate = new HashMap<>(latestMappedToscaTemplate);
358 Map<String, Object> properties = (Map<String, Object>) mappedToscaTemplate.get("properties");
359 Map<String, Object> latestProperties = (Map<String, Object>) latestMappedToscaTemplate.get("properties");
360 Map<String, Object> allProperties = combinedEntries(properties, latestProperties);
361 if ((MapUtils.isEmpty(latestProperties) && MapUtils.isNotEmpty(allProperties)) ||
362 (MapUtils.isNotEmpty(latestProperties) && !allProperties.equals(latestProperties))) {
363 newMappedToscaTemplate.put("properties", allProperties);
365 return newMappedToscaTemplate;
368 private Map<String, Object> combinedEntries(Map<String, Object> firstMap, Map<String, Object> secondMap) {
369 if (MapUtils.isEmpty(firstMap)) {
370 firstMap = new HashMap<>();
372 Map<String, Object> combinedEntries = new HashMap<>(firstMap);
373 if (MapUtils.isEmpty(secondMap)) {
374 return combinedEntries;
376 combinedEntries.putAll(secondMap);
377 return combinedEntries;
380 protected Service createServiceFromYaml(Service service, String topologyTemplateYaml, String yamlName, Map<String, NodeTypeInfo> nodeTypesInfo,
382 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
383 boolean shouldLock, boolean inTransaction, String nodeName, final String userId)
384 throws BusinessLogicException {
385 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
386 Service createdService;
387 CreateServiceFromYamlParameter csfyp = new CreateServiceFromYamlParameter();
389 ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic
390 .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, service);
391 log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", service.getName());
392 csfyp.setYamlName(yamlName);
393 csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
394 csfyp.setCreatedArtifacts(createdArtifacts);
395 csfyp.setTopologyTemplateYaml(topologyTemplateYaml);
396 csfyp.setNodeTypesInfo(nodeTypesInfo);
397 csfyp.setCsarInfo(csarInfo);
398 csfyp.setNodeName(nodeName);
399 createdService = createServiceAndRIsFromYaml(service, false, nodeTypesArtifactsToCreate, shouldLock, inTransaction, csfyp, userId);
400 log.debug("#createResourceFromYaml - The resource {} has been created ", service.getName());
401 } catch (ComponentException | BusinessLogicException e) {
402 log.debug("Create Service from yaml failed", e);
404 } catch (StorageException e) {
405 log.debug("create Service From Yaml failed,get StorageException:{}", e);
408 return createdService;
411 protected Service createServiceAndRIsFromYaml(Service service, boolean isNormative,
412 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
413 boolean shouldLock, boolean inTransaction, CreateServiceFromYamlParameter csfyp,
415 throws BusinessLogicException {
416 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
417 String yamlName = csfyp.getYamlName();
418 ParsedToscaYamlInfo parsedToscaYamlInfo = csfyp.getParsedToscaYamlInfo();
419 List<ArtifactDefinition> createdArtifacts = csfyp.getCreatedArtifacts();
420 String topologyTemplateYaml = csfyp.getTopologyTemplateYaml();
421 Map<String, NodeTypeInfo> nodeTypesInfo = csfyp.getNodeTypesInfo();
422 CsarInfo csarInfo = csfyp.getCsarInfo();
423 String nodeName = csfyp.getNodeName();
425 Either<Boolean, ResponseFormat> lockResult = serviceBusinessLogic.lockComponentByName(service.getSystemName(), service, CREATE_RESOURCE);
426 if (lockResult.isRight()) {
427 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
428 throw new ComponentException(lockResult.right().value());
430 log.debug("name is locked {} status = {}", service.getSystemName(), lockResult);
432 boolean rollback = false;
434 log.trace("************* Adding properties to service from interface yaml {}", yamlName);
435 Map<String, PropertyDefinition> properties = parsedToscaYamlInfo.getProperties();
436 if (properties != null && !properties.isEmpty()) {
437 final List<PropertyDefinition> propertiesList = new ArrayList<>();
438 properties.forEach((propertyName, propertyDefinition) -> {
439 propertyDefinition.setName(propertyName);
440 propertiesList.add(propertyDefinition);
442 service.setProperties(propertiesList);
444 log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
445 service = serviceImportParseLogic.createServiceTransaction(service, csarInfo.getModifier(), isNormative);
446 log.trace("************* Going to add inputs from yaml {}", yamlName);
447 Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
448 service = serviceImportParseLogic.createInputsOnService(service, inputs);
449 log.trace("************* Finished to add inputs from yaml {}", yamlName);
450 ListDataDefinition<RequirementSubstitutionFilterPropertyDataDefinition> substitutionFilterProperties = parsedToscaYamlInfo.getSubstitutionFilterProperties();
451 service = serviceImportParseLogic.createSubstitutionFilterOnService(service, substitutionFilterProperties);
452 log.trace("************* Added Substitution filter from interface yaml {}", yamlName);
453 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances();
454 log.trace("************* Going to create nodes, RI's and Relations from yaml {}", yamlName);
455 service = createRIAndRelationsFromYaml(yamlName, service, uploadComponentInstanceInfoMap, topologyTemplateYaml,
456 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName);
457 log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName);
458 log.trace("************* Going to add outputs from yaml {}", yamlName);
459 Map<String, OutputDefinition> outputs = parsedToscaYamlInfo.getOutputs();
460 service = serviceImportParseLogic.createOutputsOnService(service, outputs, userId);
461 log.trace("************* Finished to add outputs from yaml {}", yamlName);
463 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes
464 = groupBusinessLogic.validateUpdateVfGroupNames(parsedToscaYamlInfo.getGroups(), service.getSystemName());
465 if (validateUpdateVfGroupNamesRes.isRight()) {
466 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
467 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
469 Map<String, GroupDefinition> groups;
470 log.trace("************* Going to add groups from yaml {}", yamlName);
471 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
472 groups = validateUpdateVfGroupNamesRes.left().value();
474 groups = parsedToscaYamlInfo.getGroups();
476 Either<Service, ResponseFormat> createGroupsOnResource = createGroupsOnResource(service, groups);
477 if (createGroupsOnResource.isRight()) {
478 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
479 throw new ComponentException(createGroupsOnResource.right().value());
481 service = createGroupsOnResource.left().value();
483 Either<Service, ResponseFormat> createPoliciesOnResource = createPoliciesOnResource(service, parsedToscaYamlInfo.getPolicies());
484 if (createPoliciesOnResource.isRight()) {
485 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
486 throw new ComponentException(createPoliciesOnResource.right().value());
488 service = createPoliciesOnResource.left().value();
489 log.trace("************* Going to add artifacts from yaml {}", yamlName);
490 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
491 Either<Service, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
492 createdArtifacts, yamlName, csarInfo, service, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
493 if (createArtifactsEither.isRight()) {
494 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
495 throw new ComponentException(createArtifactsEither.right().value());
497 service = serviceImportParseLogic.getServiceWithGroups(createArtifactsEither.left().value().getUniqueId());
498 service = updateInputs(service, userId);
500 ASDCKpiApi.countCreatedResourcesKPI();
502 } catch (ComponentException | StorageException | BusinessLogicException e) {
504 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
507 if (!inTransaction) {
509 janusGraphDao.rollback();
511 janusGraphDao.commit();
515 graphLockOperation.unlockComponentByName(service.getSystemName(), service.getUniqueId(), NodeTypeEnum.Resource);
520 private Service updateInputs(final Service component, final String userId) {
521 final List<InputDefinition> inputs = component.getInputs();
522 final List<ComponentInstance> componentInstances = component.getComponentInstances();
523 final String componentUniqueId = component.getUniqueId();
524 final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = component.getComponentInstancesProperties();
525 for (final InputDefinition input : inputs) {
526 if (isInputFromComponentInstanceProperty(input.getName(), componentInstances, componentInstancesProperties)) {
527 associateInputToComponentInstanceProperty(userId, input, componentInstances, componentInstancesProperties,
530 associateInputToServiceProperty(userId, input, component);
535 final Either<List<InputDefinition>, StorageOperationStatus> either
536 = toscaOperationFacade.updateInputsToComponent(inputs, componentUniqueId);
537 if (either.isRight()) {
538 throw new ComponentException(ActionStatus.GENERAL_ERROR);
544 private boolean isInputFromComponentInstanceProperty(final String inputName, final List<ComponentInstance> componentInstances,
545 final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties) {
546 if (CollectionUtils.isNotEmpty(componentInstances)) {
547 // get instance's names
548 final List<String> componentInstancesNames = componentInstances.stream().map(ComponentInstanceDataDefinition::getNormalizedName)
550 final Optional<String> componentInstancesNameOptional = componentInstancesNames.stream()
551 .filter(cin -> inputName.startsWith(cin + "_")).findFirst();
552 if (componentInstancesNameOptional.isPresent() && MapUtils.isNotEmpty(componentInstancesProperties)) {
553 final Optional<String> componentInstanceIdOptional = componentInstancesProperties.keySet().stream()
554 .filter(key -> key.endsWith("." + componentInstancesNameOptional.get())).findFirst();
555 if (componentInstanceIdOptional.isPresent()) {
556 // get property's name
557 final String propertyNameFromInput = extractPropertyNameFromInputName(inputName, componentInstancesNames);
558 return componentInstancesProperties.get(componentInstanceIdOptional.get()).stream()
559 .anyMatch(prop -> prop.getName().equals(propertyNameFromInput) && prop.getValue() != null
560 && prop.getValue().contains(ToscaGetFunctionType.GET_INPUT.getFunctionName()));
567 private void associateInputToComponentInstanceProperty(final String userId, final InputDefinition input,
568 final List<ComponentInstance> componentInstances,
569 final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties,
570 String componentUniqueId) {
572 final List<String> componentInstancesNames = componentInstances.stream().map(ComponentInstanceDataDefinition::getNormalizedName)
574 final String propertyNameFromInput = extractPropertyNameFromInputName(input.getName(), componentInstancesNames);
576 final Optional<String> componentInstancesNameOptional = componentInstancesNames.stream()
577 .filter(cin -> input.getName().startsWith(cin + "_")).findFirst();
579 final Optional<String> componentInstanceIdOptional = componentInstancesProperties.keySet().stream()
580 .filter(key -> key.endsWith("." + componentInstancesNameOptional.get())).findFirst();
582 final String componentInstanceId = componentInstanceIdOptional.get();
583 final List<ComponentInstanceProperty> componentInstanceProperties = componentInstancesProperties.get(componentInstanceId);
585 final ComponentInstanceProperty componentInstanceProperty = componentInstanceProperties.stream()
586 .filter(prop -> prop.getName().equals(propertyNameFromInput) && prop.getValue() != null
587 && prop.getValue().contains(ToscaGetFunctionType.GET_INPUT.getFunctionName())).findFirst().get();
590 updateInput(input, componentInstanceProperty, userId, componentInstanceId);
592 final Either<Map<String, List<ComponentInstanceProperty>>, StorageOperationStatus> either =
593 toscaOperationFacade.updateComponentInstancePropsToComponent(Collections.singletonMap(componentInstanceId,
594 Collections.singletonList(componentInstanceProperty)), componentUniqueId);
595 if (either.isRight()) {
596 throw new ComponentException(ActionStatus.GENERAL_ERROR);
600 private void associateInputToServiceProperty(final String userId,
601 final InputDefinition input, final Service component) {
602 final List<PropertyDefinition> properties = component.getProperties();
603 if (CollectionUtils.isNotEmpty(properties)) {
604 final String propertyNameFromInput = input.getName();
605 final Optional<PropertyDefinition> propDefOptional = properties.stream().filter(prop -> prop.getName().equals(propertyNameFromInput))
607 if (propDefOptional.isPresent()) {
609 final String componentUniqueId = component.getUniqueId();
610 final PropertyDefinition propertyDefinition = propDefOptional.get();
611 updateProperty(propertyDefinition, input, componentUniqueId);
612 final JSONObject jsonObject = new JSONObject();
613 jsonObject.put(ToscaGetFunctionType.GET_INPUT.getFunctionName(), input.getName());
614 propertyDefinition.setValue(jsonObject.toJSONString());
615 updateInput(input, propertyDefinition, userId, componentUniqueId);
617 final Either<PropertyDefinition, StorageOperationStatus> either
618 = toscaOperationFacade.updatePropertyOfComponent(component, propertyDefinition);
619 if (either.isRight()) {
620 throw new ComponentException(ActionStatus.GENERAL_ERROR);
626 private void updateProperty(final PropertyDefinition propertyDefinition, final InputDefinition input, final String componentUniqueId) {
627 propertyDefinition.setParentUniqueId(componentUniqueId);
628 final GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
629 getInputValueDataDefinition.setInputId(input.getUniqueId());
630 getInputValueDataDefinition.setInputName(input.getName());
631 getInputValueDataDefinition.setPropName(propertyDefinition.getName());
632 propertyDefinition.setGetInputValues(Collections.singletonList(getInputValueDataDefinition));
635 private void updateInput(final InputDefinition input, final PropertyDefinition propertyDefinition,
636 final String userId, final String componentUniqueId) {
637 input.setProperties(Collections.singletonList(new ComponentInstanceProperty(propertyDefinition)));
638 input.setInstanceUniqueId(componentUniqueId);
639 input.setOwnerId(userId);
640 input.setPropertyId(propertyDefinition.getUniqueId());
641 input.setParentPropertyType(propertyDefinition.getType());
644 private String extractPropertyNameFromInputName(final String inputName, final List<String> componentInstancesNames) {
645 final AtomicReference<String> result = new AtomicReference<>(inputName);
646 componentInstancesNames.forEach(cin -> result.set(result.get().replace(cin + "_", "")));
650 protected Either<Resource, ResponseFormat> createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum operation,
651 List<ArtifactDefinition> createdArtifacts, String yamlFileName,
652 CsarInfo csarInfo, Resource preparedResource,
653 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
654 boolean inTransaction, boolean shouldLock) {
655 String nodeName = nodeTypeInfoToUpdateArtifacts.getNodeName();
656 Resource resource = preparedResource;
657 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = nodeTypeInfoToUpdateArtifacts
658 .getNodeTypesArtifactsToHandle();
659 if (preparedResource.getResourceType() == ResourceTypeEnum.VF) {
660 if (nodeName != null && nodeTypesArtifactsToHandle.get(nodeName) != null && !nodeTypesArtifactsToHandle.get(nodeName).isEmpty()) {
661 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = handleNodeTypeArtifacts(preparedResource,
662 nodeTypesArtifactsToHandle.get(nodeName), createdArtifacts, csarInfo.getModifier(), inTransaction, true);
663 if (handleNodeTypeArtifactsRes.isRight()) {
664 return Either.right(handleNodeTypeArtifactsRes.right().value());
668 Either<Resource, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedResource, csarInfo, createdArtifacts,
669 new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction);
670 log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
671 if (createdCsarArtifactsEither.isRight()) {
672 return createdCsarArtifactsEither;
674 resource = createdCsarArtifactsEither.left().value();
676 return Either.left(resource);
679 protected Either<Resource, ResponseFormat> handleVfCsarArtifacts(Resource resource, CsarInfo csarInfo, List<ArtifactDefinition> createdArtifacts,
680 ArtifactOperationInfo artifactOperation, boolean shouldLock,
681 boolean inTransaction) {
682 if (csarInfo.getCsar() != null) {
683 createOrUpdateSingleNonMetaArtifactToComstants(resource, csarInfo, artifactOperation, shouldLock, inTransaction);
684 Either<Resource, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, resource, createdArtifacts, shouldLock,
685 inTransaction, artifactOperation);
686 if (eitherCreateResult.isRight()) {
687 return Either.right(eitherCreateResult.right().value());
689 Either<Resource, StorageOperationStatus> eitherGerResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
690 if (eitherGerResource.isRight()) {
691 ResponseFormat responseFormat = componentsUtils
692 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), resource);
693 return Either.right(responseFormat);
695 resource = eitherGerResource.left().value();
696 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
697 .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
698 if (artifacsMetaCsarStatus.isLeft()) {
699 return getResourceResponseFormatEither(resource, csarInfo, createdArtifacts, artifactOperation, shouldLock, inTransaction,
700 artifacsMetaCsarStatus);
702 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(resource, csarInfo, shouldLock, inTransaction);
705 return Either.left(resource);
708 protected void createOrUpdateSingleNonMetaArtifactToComstants(Resource resource, CsarInfo csarInfo, ArtifactOperationInfo artifactOperation,
709 boolean shouldLock, boolean inTransaction) {
710 String vendorLicenseModelId = null;
711 String vfLicenseModelId = null;
712 if (artifactOperation.getArtifactOperationEnum() == ArtifactOperationEnum.UPDATE) {
713 Map<String, ArtifactDefinition> deploymentArtifactsMap = resource.getDeploymentArtifacts();
714 if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
715 for (Map.Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
716 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
717 vendorLicenseModelId = artifactEntry.getValue().getUniqueId();
719 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
720 vfLicenseModelId = artifactEntry.getValue().getUniqueId();
725 createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL,
726 Constants.VENDOR_LICENSE_MODEL, ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
727 Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME, Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId,
728 artifactOperation, null, true, shouldLock, inTransaction);
729 createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
730 ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL, Constants.VF_LICENSE_DISPLAY_NAME,
731 Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId, artifactOperation, null, true, shouldLock, inTransaction);
734 private Either<Resource, ResponseFormat> getResourceResponseFormatEither(Resource resource, CsarInfo csarInfo,
735 List<ArtifactDefinition> createdArtifacts,
736 ArtifactOperationInfo artifactOperation, boolean shouldLock,
737 boolean inTransaction,
738 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus) {
740 String artifactsFileName = artifacsMetaCsarStatus.left().value().getKey();
741 String artifactsContents = artifacsMetaCsarStatus.left().value().getValue();
742 Either<Resource, ResponseFormat> createArtifactsFromCsar;
743 if (ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
744 createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic
745 .createResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts);
747 Either<Component, ResponseFormat> result = csarArtifactsAndGroupsBusinessLogic
748 .updateResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
750 if ((result.left().value() instanceof Resource) && result.isLeft()) {
751 Resource service1 = (Resource) result.left().value();
752 createArtifactsFromCsar = Either.left(service1);
754 createArtifactsFromCsar = Either.right(result.right().value());
757 if (createArtifactsFromCsar.isRight()) {
758 log.debug("Couldn't create artifacts from artifacts.meta");
759 return Either.right(createArtifactsFromCsar.right().value());
761 return Either.left(createArtifactsFromCsar.left().value());
762 } catch (Exception e) {
763 log.debug("Exception occured in getResourceResponseFormatEither, message:{}", e.getMessage(), e);
764 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
768 private <T extends Component> Either<T, ResponseFormat> createOrUpdateNonMetaArtifactsComp(CsarInfo csarInfo, T component,
769 List<ArtifactDefinition> createdArtifacts,
770 boolean shouldLock, boolean inTransaction,
771 ArtifactOperationInfo artifactOperation) {
772 Either<T, ResponseFormat> resStatus = null;
773 Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
775 Either<List<CsarUtils.NonMetaArtifactInfo>, String> artifactPathAndNameList = getValidArtifactNames(csarInfo, collectedWarningMessages);
776 if (artifactPathAndNameList.isRight()) {
778 getComponentsUtils().getResponseFormatByArtifactId(ActionStatus.ARTIFACT_NAME_INVALID, artifactPathAndNameList.right().value()));
780 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = null;
781 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
782 vfCsarArtifactsToHandle = new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
783 vfCsarArtifactsToHandle.put(artifactOperation.getArtifactOperationEnum(), artifactPathAndNameList.left().value());
785 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandleRes = findVfCsarArtifactsToHandle(
786 component, artifactPathAndNameList.left().value(), csarInfo.getModifier());
787 if (findVfCsarArtifactsToHandleRes.isRight()) {
788 resStatus = Either.right(findVfCsarArtifactsToHandleRes.right().value());
790 if (resStatus == null) {
791 vfCsarArtifactsToHandle = findVfCsarArtifactsToHandleRes.left().value();
794 if (resStatus == null && vfCsarArtifactsToHandle != null) {
795 resStatus = processCsarArtifacts(csarInfo, component, createdArtifacts, shouldLock, inTransaction, resStatus,
796 vfCsarArtifactsToHandle);
798 if (resStatus == null) {
799 resStatus = Either.left(component);
801 } catch (Exception e) {
802 resStatus = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
803 log.debug("Exception occured in createNonMetaArtifacts, message:{}", e.getMessage(), e);
805 CsarUtils.handleWarningMessages(collectedWarningMessages);
810 protected Either<Resource, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Resource resource,
811 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
812 boolean inTransaction, ArtifactOperationInfo artifactOperation) {
813 return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation);
816 protected <T extends Component> Either<T, ResponseFormat> processCsarArtifacts(CsarInfo csarInfo, Component comp,
817 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
818 boolean inTransaction, Either<T, ResponseFormat> resStatus,
819 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle) {
820 for (Map.Entry<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> currArtifactOperationPair : vfCsarArtifactsToHandle
822 Optional<ResponseFormat> optionalCreateInDBError = currArtifactOperationPair.getValue().stream().map(
823 e -> createOrUpdateSingleNonMetaArtifact(comp, csarInfo, e.getPath(), e.getArtifactName(), e.getArtifactType(),
824 e.getArtifactGroupType(), e.getArtifactLabel(), e.getDisplayName(), CsarUtils.ARTIFACT_CREATED_FROM_CSAR, e.getArtifactUniqueId(),
825 new ArtifactOperationInfo(false, false, currArtifactOperationPair.getKey()), createdArtifacts, e.isFromCsar(), shouldLock,
826 inTransaction)).filter(Either::isRight).map(e -> e.right().value()).findAny();
827 if (optionalCreateInDBError.isPresent()) {
828 resStatus = Either.right(optionalCreateInDBError.get());
835 protected Either<Boolean, ResponseFormat> createOrUpdateSingleNonMetaArtifact(Component component, CsarInfo csarInfo, String artifactPath,
836 String artifactFileName, String artifactType,
837 ArtifactGroupTypeEnum artifactGroupType, String artifactLabel,
838 String artifactDisplayName, String artifactDescription,
839 String artifactId, ArtifactOperationInfo operation,
840 List<ArtifactDefinition> createdArtifacts, boolean isFromCsar,
841 boolean shouldLock, boolean inTransaction) {
842 byte[] artifactFileBytes = null;
843 if (csarInfo.getCsar().containsKey(artifactPath)) {
844 artifactFileBytes = csarInfo.getCsar().get(artifactPath);
846 Either<Boolean, ResponseFormat> result = Either.left(true);
847 if (operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE
848 || operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE) {
849 if (serviceImportParseLogic.isArtifactDeletionRequired(artifactId, artifactFileBytes, isFromCsar)) {
850 Either<ArtifactDefinition, ResponseFormat> handleDelete = artifactsBusinessLogic
851 .handleDelete(component.getUniqueId(), artifactId, csarInfo.getModifier(), component, shouldLock, inTransaction);
852 if (handleDelete.isRight()) {
853 result = Either.right(handleDelete.right().value());
857 if (org.apache.commons.lang.StringUtils.isEmpty(artifactId) && artifactFileBytes != null) {
858 operation = new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
861 if (artifactFileBytes != null) {
862 Map<String, Object> vendorLicenseModelJson = ArtifactUtils
863 .buildJsonForUpdateArtifact(artifactId, artifactFileName, artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
864 artifactDescription, artifactFileBytes, null, isFromCsar);
865 Either<Either<ArtifactDefinition, Operation>, ResponseFormat> eitherNonMetaArtifacts = csarArtifactsAndGroupsBusinessLogic
866 .createOrUpdateCsarArtifactFromJson(component, csarInfo.getModifier(), vendorLicenseModelJson, operation);
867 serviceImportParseLogic.addNonMetaCreatedArtifactsToSupportRollback(operation, createdArtifacts, eitherNonMetaArtifacts);
868 if (eitherNonMetaArtifacts.isRight()) {
869 BeEcompErrorManager.getInstance().logInternalFlowError("UploadLicenseArtifact",
870 "Failed to upload license artifact: " + artifactFileName + "With csar uuid: " + csarInfo.getCsarUUID(),
871 BeEcompErrorManager.ErrorSeverity.WARNING);
872 return Either.right(eitherNonMetaArtifacts.right().value());
878 private Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifacts(Resource nodeTypeResource,
879 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
880 List<ArtifactDefinition> createdArtifacts, User user,
881 boolean inTransaction, boolean ignoreLifecycleState) {
882 List<ArtifactDefinition> handleNodeTypeArtifactsRequestRes;
883 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = null;
884 Either<Resource, ResponseFormat> changeStateResponse;
886 changeStateResponse = checkoutResource(nodeTypeResource, user, inTransaction);
887 if (changeStateResponse.isRight()) {
888 return Either.right(changeStateResponse.right().value());
890 nodeTypeResource = changeStateResponse.left().value();
891 List<ArtifactDefinition> handledNodeTypeArtifacts = new ArrayList<>();
892 log.debug("************* Going to handle artifacts of node type resource {}. ", nodeTypeResource.getName());
893 for (Map.Entry<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> curOperationEntry : nodeTypeArtifactsToHandle
895 ArtifactsBusinessLogic.ArtifactOperationEnum curOperation = curOperationEntry.getKey();
896 List<ArtifactDefinition> curArtifactsToHandle = curOperationEntry.getValue();
897 if (curArtifactsToHandle != null && !curArtifactsToHandle.isEmpty()) {
898 log.debug("************* Going to {} artifact to vfc {}", curOperation.name(), nodeTypeResource.getName());
899 handleNodeTypeArtifactsRequestRes = artifactsBusinessLogic
900 .handleArtifactsRequestForInnerVfcComponent(curArtifactsToHandle, nodeTypeResource, user, createdArtifacts,
901 new ArtifactOperationInfo(false, ignoreLifecycleState, curOperation), false, inTransaction);
902 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(curOperation)) {
903 createdArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
905 handledNodeTypeArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
908 handleNodeTypeArtifactsRes = Either.left(handledNodeTypeArtifacts);
909 } catch (Exception e) {
910 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
911 handleNodeTypeArtifactsRes = Either.right(responseFormat);
912 log.debug("Exception occured when handleVfcArtifacts, error is:{}", e.getMessage(), e);
914 return handleNodeTypeArtifactsRes;
917 private Either<Resource, ResponseFormat> checkoutResource(Resource resource, User user, boolean inTransaction) {
918 Either<Resource, ResponseFormat> checkoutResourceRes;
920 if (!resource.getComponentMetadataDefinition().getMetadataDataDefinition().getState()
921 .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
922 Either<? extends Component, ResponseFormat> checkoutRes = lifecycleBusinessLogic
923 .changeComponentState(resource.getComponentType(), resource.getUniqueId(), user, LifeCycleTransitionEnum.CHECKOUT,
924 new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
925 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR), inTransaction, true);
926 if (checkoutRes.isRight()) {
927 checkoutResourceRes = Either.right(checkoutRes.right().value());
929 checkoutResourceRes = Either.left((Resource) checkoutRes.left().value());
932 checkoutResourceRes = Either.left(resource);
934 } catch (Exception e) {
935 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
936 checkoutResourceRes = Either.right(responseFormat);
937 log.debug("Exception occured when checkoutResource {} , error is:{}", resource.getName(), e.getMessage(), e);
939 return checkoutResourceRes;
942 protected Either<Service, ResponseFormat> createOrUpdateArtifacts(ArtifactOperationEnum operation, List<ArtifactDefinition> createdArtifacts,
943 String yamlFileName, CsarInfo csarInfo, Service preparedService,
944 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
945 boolean inTransaction, boolean shouldLock) {
946 Either<Service, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedService, csarInfo, createdArtifacts,
947 new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction);
948 log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
949 if (createdCsarArtifactsEither.isRight()) {
950 return createdCsarArtifactsEither;
952 return Either.left(createdCsarArtifactsEither.left().value());
955 protected Either<Service, ResponseFormat> handleVfCsarArtifacts(Service service, CsarInfo csarInfo, List<ArtifactDefinition> createdArtifacts,
956 ArtifactOperationInfo artifactOperation, boolean shouldLock,
957 boolean inTransaction) {
958 if (csarInfo.getCsar() != null) {
959 String vendorLicenseModelId = null;
960 String vfLicenseModelId = null;
961 if (artifactOperation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE) {
962 Map<String, ArtifactDefinition> deploymentArtifactsMap = service.getDeploymentArtifacts();
963 if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
964 for (Map.Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
965 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
966 vendorLicenseModelId = artifactEntry.getValue().getUniqueId();
968 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
969 vfLicenseModelId = artifactEntry.getValue().getUniqueId();
974 createOrUpdateSingleNonMetaArtifact(service, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL,
975 Constants.VENDOR_LICENSE_MODEL, ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
976 Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME, Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId,
977 artifactOperation, null, true, shouldLock, inTransaction);
978 createOrUpdateSingleNonMetaArtifact(service, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
979 ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL,
980 Constants.VF_LICENSE_DISPLAY_NAME, Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId, artifactOperation, null, true, shouldLock,
982 Either<Service, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, service, createdArtifacts, shouldLock,
983 inTransaction, artifactOperation);
984 if (eitherCreateResult.isRight()) {
985 return Either.right(eitherCreateResult.right().value());
987 Either<Service, StorageOperationStatus> eitherGerResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
988 if (eitherGerResource.isRight()) {
989 ResponseFormat responseFormat = componentsUtils
990 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), service,
991 ComponentTypeEnum.SERVICE);
992 return Either.right(responseFormat);
994 service = eitherGerResource.left().value();
995 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
996 .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
997 if (artifacsMetaCsarStatus.isLeft()) {
998 String artifactsFileName = artifacsMetaCsarStatus.left().value().getKey();
999 String artifactsContents = artifacsMetaCsarStatus.left().value().getValue();
1000 Either<Service, ResponseFormat> createArtifactsFromCsar;
1001 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
1002 createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic
1003 .createResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts);
1005 Either<Component, ResponseFormat> result = csarArtifactsAndGroupsBusinessLogic
1006 .updateResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
1008 if ((result.left().value() instanceof Service) && result.isLeft()) {
1009 Service service1 = (Service) result.left().value();
1010 createArtifactsFromCsar = Either.left(service1);
1012 createArtifactsFromCsar = Either.right(result.right().value());
1015 if (createArtifactsFromCsar.isRight()) {
1016 log.debug("Couldn't create artifacts from artifacts.meta");
1017 return Either.right(createArtifactsFromCsar.right().value());
1019 return Either.left(createArtifactsFromCsar.left().value());
1021 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(service, csarInfo, shouldLock, inTransaction);
1024 return Either.left(service);
1027 protected Either<Service, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Service resource,
1028 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
1029 boolean inTransaction, ArtifactOperationInfo artifactOperation) {
1030 return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation);
1033 protected Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandle(
1034 Component component, List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList, User user) {
1035 List<ArtifactDefinition> existingArtifacts = new ArrayList<>();
1036 if (component.getDeploymentArtifacts() != null && !component.getDeploymentArtifacts().isEmpty()) {
1037 existingArtifacts.addAll(component.getDeploymentArtifacts().values());
1039 if (component.getArtifacts() != null && !component.getArtifacts().isEmpty()) {
1040 existingArtifacts.addAll(component.getArtifacts().values());
1042 existingArtifacts = existingArtifacts.stream().filter(this::isNonMetaArtifact).collect(toList());
1043 List<String> artifactsToIgnore = new ArrayList<>();
1044 if (component.getGroups() != null) {
1045 component.getGroups().forEach(g -> {
1046 if (g.getArtifacts() != null && !g.getArtifacts().isEmpty()) {
1047 artifactsToIgnore.addAll(g.getArtifacts());
1051 existingArtifacts = existingArtifacts.stream().filter(a -> !artifactsToIgnore.contains(a.getUniqueId())).collect(toList());
1052 return organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifacts, component, user);
1055 private boolean isNonMetaArtifact(ArtifactDefinition artifact) {
1056 boolean result = true;
1057 if (artifact.getMandatory() || artifact.getArtifactName() == null || !isValidArtifactType(artifact)) {
1063 private boolean isValidArtifactType(ArtifactDefinition artifact) {
1064 final String artifactType = artifact.getArtifactType();
1065 return artifactType != null
1066 && !ArtifactTypeEnum.VENDOR_LICENSE.getType().equals(ArtifactTypeEnum.findType(artifactType))
1067 && !ArtifactTypeEnum.VF_LICENSE.getType().equals(ArtifactTypeEnum.findType(artifactType));
1070 protected Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> organizeVfCsarArtifactsByArtifactOperation(
1071 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList, List<ArtifactDefinition> existingArtifactsToHandle, Component component,
1073 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> nodeTypeArtifactsToHandle = new EnumMap<>(
1074 ArtifactsBusinessLogic.ArtifactOperationEnum.class);
1075 Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
1076 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> nodeTypeArtifactsToHandleRes = Either
1077 .left(nodeTypeArtifactsToHandle);
1079 List<CsarUtils.NonMetaArtifactInfo> artifactsToUpload = new ArrayList<>(artifactPathAndNameList);
1080 List<CsarUtils.NonMetaArtifactInfo> artifactsToUpdate = new ArrayList<>();
1081 List<CsarUtils.NonMetaArtifactInfo> artifactsToDelete = new ArrayList<>();
1082 for (CsarUtils.NonMetaArtifactInfo currNewArtifact : artifactPathAndNameList) {
1083 ArtifactDefinition foundArtifact;
1084 if (!existingArtifactsToHandle.isEmpty()) {
1085 foundArtifact = existingArtifactsToHandle.stream().filter(a -> a.getArtifactName().equals(currNewArtifact.getArtifactName()))
1086 .findFirst().orElse(null);
1087 if (foundArtifact != null) {
1088 if (ArtifactTypeEnum.findType(foundArtifact.getArtifactType()).equals(currNewArtifact.getArtifactType())) {
1089 if (!foundArtifact.getArtifactChecksum().equals(currNewArtifact.getArtifactChecksum())) {
1090 currNewArtifact.setArtifactUniqueId(foundArtifact.getUniqueId());
1091 artifactsToUpdate.add(currNewArtifact);
1093 existingArtifactsToHandle.remove(foundArtifact);
1094 artifactsToUpload.remove(currNewArtifact);
1096 log.debug("Can't upload two artifact with the same name {}.", currNewArtifact.getArtifactName());
1097 ResponseFormat responseFormat = ResponseFormatManager.getInstance()
1098 .getResponseFormat(ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, currNewArtifact.getArtifactName(),
1099 currNewArtifact.getArtifactType(), foundArtifact.getArtifactType());
1100 AuditingActionEnum auditingAction = artifactsBusinessLogic.detectAuditingType(
1101 new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE),
1102 foundArtifact.getArtifactChecksum());
1103 artifactsBusinessLogic.handleAuditing(auditingAction, component, component.getUniqueId(), user, null, null,
1104 foundArtifact.getUniqueId(), responseFormat, component.getComponentType(), null);
1105 responseWrapper.setInnerElement(responseFormat);
1111 if (responseWrapper.isEmpty()) {
1112 for (ArtifactDefinition currArtifact : existingArtifactsToHandle) {
1113 if (currArtifact.getIsFromCsar()) {
1114 artifactsToDelete.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
1115 ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null,
1116 currArtifact.getUniqueId(), currArtifact.getIsFromCsar()));
1118 artifactsToUpdate.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
1119 ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null,
1120 currArtifact.getUniqueId(), currArtifact.getIsFromCsar()));
1124 if (responseWrapper.isEmpty()) {
1125 if (!artifactsToUpload.isEmpty()) {
1126 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, artifactsToUpload);
1128 if (!artifactsToUpdate.isEmpty()) {
1129 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE, artifactsToUpdate);
1131 if (!artifactsToDelete.isEmpty()) {
1132 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE, artifactsToDelete);
1135 if (!responseWrapper.isEmpty()) {
1136 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
1138 } catch (Exception e) {
1139 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1140 responseWrapper.setInnerElement(responseFormat);
1141 log.debug("Exception occured when findNodeTypeArtifactsToHandle, error is:{}", e.getMessage(), e);
1142 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
1144 return nodeTypeArtifactsToHandleRes;
1147 protected Either<List<CsarUtils.NonMetaArtifactInfo>, String> getValidArtifactNames(CsarInfo csarInfo,
1148 Map<String, Set<List<String>>> collectedWarningMessages) {
1149 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = csarInfo.getCsar().entrySet().stream()
1150 .filter(e -> Pattern.compile(VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN).matcher(e.getKey()).matches())
1151 .map(e -> CsarUtils.validateNonMetaArtifact(e.getKey(), e.getValue(), collectedWarningMessages)).filter(Either::isLeft)
1152 .map(e -> e.left().value()).collect(toList());
1153 Pattern englishNumbersAndUnderScoresOnly = Pattern.compile(CsarUtils.VALID_ENGLISH_ARTIFACT_NAME);
1154 for (CsarUtils.NonMetaArtifactInfo nonMetaArtifactInfo : artifactPathAndNameList) {
1155 if (!englishNumbersAndUnderScoresOnly.matcher(nonMetaArtifactInfo.getDisplayName()).matches()) {
1156 return Either.right(nonMetaArtifactInfo.getArtifactName());
1159 return Either.left(artifactPathAndNameList);
1162 protected Either<Service, ResponseFormat> createGroupsOnResource(Service service, Map<String, GroupDefinition> groups) {
1163 if (groups != null && !groups.isEmpty()) {
1164 List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, service);
1165 serviceImportParseLogic.handleGroupsProperties(service, groups);
1166 serviceImportParseLogic.fillGroupsFinalFields(groupsAsList);
1167 Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic.createGroups(service, groupsAsList, true);
1168 if (createGroups.isRight()) {
1169 return Either.right(createGroups.right().value());
1172 return Either.left(service);
1174 return getServiceResponseFormatEither(service);
1177 private Either<Service, ResponseFormat> createPoliciesOnResource(final Service service,
1178 final Map<String, PolicyDefinition> policies) {
1179 if (MapUtils.isEmpty(policies)) {
1180 return Either.left(service);
1182 final Map<String, List<AttributeDefinition>> instanceAttributeMap =
1183 service.getComponentInstancesAttributes()
1184 .entrySet().stream()
1186 toMap(Entry::getKey,
1187 entry -> entry.getValue().stream().map(AttributeDefinition.class::cast).collect(toList()))
1189 policies.values().stream()
1190 .map(PolicyDataDefinition::getProperties)
1191 .flatMap(Collection::stream)
1192 .filter(PropertyDataDefinition::isToscaFunction)
1193 .forEach(policyDefinition ->
1194 toscaFunctionService
1195 .updateFunctionWithDataFromSelfComponent(policyDefinition.getToscaFunction(), service, service.getComponentInstancesProperties(),
1196 instanceAttributeMap)
1198 policyBusinessLogic.createPolicies(service, policies);
1199 return getServiceResponseFormatEither(service);
1202 private Either<Service, ResponseFormat> getServiceResponseFormatEither(Service service) {
1203 Either<Service, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
1204 if (updatedResource.isRight()) {
1205 ResponseFormat responseFormat = componentsUtils
1206 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), service,
1207 ComponentTypeEnum.SERVICE);
1208 return Either.right(responseFormat);
1210 return Either.left(updatedResource.left().value());
1213 protected List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups, Service component) {
1214 List<GroupDefinition> result = new ArrayList<>();
1215 List<ComponentInstance> componentInstances = component.getComponentInstances();
1216 if (groups != null) {
1217 for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
1218 String groupName = entry.getKey();
1219 GroupDefinition groupDefinition = entry.getValue();
1220 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
1221 updatedGroupDefinition.setMembers(null);
1222 Map<String, String> members = groupDefinition.getMembers();
1223 if (members != null) {
1224 serviceImportParseLogic.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
1226 result.add(updatedGroupDefinition);
1232 protected Resource createRIAndRelationsFromYaml(String yamlName, Resource resource,
1233 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap,
1234 String topologyTemplateYaml, List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1235 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1236 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
1239 log.debug("************* Going to create all nodes {}", yamlName);
1240 handleNodeTypes(yamlName, resource, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
1241 csarInfo, nodeName);
1242 log.debug("************* Going to create all resource instances {}", yamlName);
1243 resource = createResourceInstances(yamlName, resource, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes());
1244 log.debug("************* Finished to create all resource instances {}", yamlName);
1245 resource = createResourceInstancesRelations(csarInfo.getModifier(), yamlName, resource, uploadComponentInstanceInfoMap);
1246 log.debug("************* Going to create positions {}", yamlName);
1247 compositionBusinessLogic.setPositionsForComponentInstances(resource, csarInfo.getModifier().getUserId());
1248 log.debug("************* Finished to set positions {}", yamlName);
1250 } catch (Exception e) {
1251 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1255 protected Resource createResourceInstancesRelations(User user, String yamlName, Resource resource,
1256 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1257 log.debug("#createResourceInstancesRelations - Going to create relations ");
1258 List<ComponentInstance> componentInstancesList = resource.getComponentInstances();
1259 if (((MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)) &&
1260 resource.getResourceType() != ResourceTypeEnum.PNF)) { // PNF can have no resource instances
1261 log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
1262 resource.getUniqueId(), yamlName);
1263 BeEcompErrorManager.getInstance()
1264 .logInternalDataError("createResourceInstancesRelations", "No instances found in a resource or nn yaml template. ",
1265 BeEcompErrorManager.ErrorSeverity.ERROR);
1266 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName));
1268 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1269 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1270 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1271 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1272 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1273 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1274 Map<String, Resource> originCompMap = new HashMap<>();
1275 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1276 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1277 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1278 Map<String, Map<String, InterfaceDefinition>> instInterfaces = new HashMap<>();
1279 log.debug("enter ServiceImportBusinessLogic createResourceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. ");
1280 final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache;
1281 if (applicationDataTypeCache != null) {
1282 Resource finalResource = resource;
1283 uploadResInstancesMap.values().forEach(
1284 i -> processComponentInstance(yamlName, finalResource, componentInstancesList,
1285 componentsUtils.getAllDataTypes(applicationDataTypeCache, finalResource.getModel()), instProperties, instCapabilities,
1286 instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs, instNodeFilter,
1287 instInterfaces, i));
1289 serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, resource, instProperties);
1290 serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, resource, instInputs);
1291 serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts);
1292 serviceImportParseLogic.associateArtifactsToInstances(yamlName, resource, instArtifacts);
1293 serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements);
1294 serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes);
1295 resource = serviceImportParseLogic.getResourceAfterCreateRelations(resource);
1296 serviceImportParseLogic.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList, relations);
1297 serviceImportParseLogic.associateResourceInstances(yamlName, resource, relations);
1298 handleSubstitutionMappings(resource, uploadResInstancesMap);
1299 log.debug("************* in create relations, getResource start");
1300 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
1301 log.debug("************* in create relations, getResource end");
1302 if (eitherGetResource.isRight()) {
1303 throw new ComponentException(
1304 componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource));
1306 return eitherGetResource.left().value();
1309 protected void processProperty(Resource resource, Map<String, DataTypeDefinition> allDataTypes,
1310 Map<String, InputDefinition> currPropertiesMap, List<ComponentInstanceInput> instPropList,
1311 List<UploadPropInfo> propertyList) {
1312 UploadPropInfo propertyInfo = propertyList.get(0);
1313 String propName = propertyInfo.getName();
1314 if (!currPropertiesMap.containsKey(propName)) {
1315 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName));
1317 processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, resource.getInputs());
1320 private void processProperty(Map<String, DataTypeDefinition> allDataTypes, Map<String, InputDefinition> currPropertiesMap,
1321 List<ComponentInstanceInput> instPropList, UploadPropInfo propertyInfo, String propName,
1322 List<InputDefinition> inputs2) {
1323 InputDefinition curPropertyDef = currPropertiesMap.get(propName);
1324 ComponentInstanceInput property = null;
1325 String value = null;
1326 List<GetInputValueDataDefinition> getInputs = null;
1327 boolean isValidate = true;
1328 if (propertyInfo.getValue() != null) {
1329 getInputs = propertyInfo.getGet_input();
1330 isValidate = getInputs == null || getInputs.isEmpty();
1332 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
1334 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
1337 property = new ComponentInstanceInput(curPropertyDef, value, null);
1338 String validPropertyVAlue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
1339 property.setValue(validPropertyVAlue);
1340 if (isNotEmpty(getInputs)) {
1341 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1342 for (GetInputValueDataDefinition getInput : getInputs) {
1343 List<InputDefinition> inputs = inputs2;
1344 if (CollectionUtils.isEmpty(inputs)) {
1345 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1347 Optional<InputDefinition> optional = inputs.stream().filter(p -> p.getName().equals(getInput.getInputName())).findAny();
1348 if (!optional.isPresent()) {
1349 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1351 InputDefinition input = optional.get();
1352 getInput.setInputId(input.getUniqueId());
1353 getInputValues.add(getInput);
1354 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
1355 processGetInput(getInputValues, inputs, getInputIndex);
1357 property.setGetInputValues(getInputValues);
1359 instPropList.add(property);
1360 currPropertiesMap.remove(property.getName());
1363 protected void handleSubstitutionMappings(Resource resource, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1364 if (resource.getResourceType() == ResourceTypeEnum.VF) {
1365 Either<Resource, StorageOperationStatus> getResourceRes = toscaOperationFacade.getToscaFullElement(resource.getUniqueId());
1366 if (getResourceRes.isRight()) {
1367 ResponseFormat responseFormat = componentsUtils
1368 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource);
1369 throw new ComponentException(responseFormat);
1371 getResourceRes = updateCalculatedCapReqWithSubstitutionMappings(getResourceRes.left().value(), uploadResInstancesMap);
1372 if (getResourceRes.isRight()) {
1373 ResponseFormat responseFormat = componentsUtils
1374 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource);
1375 throw new ComponentException(responseFormat);
1380 protected Resource createResourceInstances(String yamlName, Resource resource, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1381 Map<String, Resource> nodeNamespaceMap) {
1382 Either<Resource, ResponseFormat> eitherResource = null;
1383 log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
1384 if (MapUtils.isEmpty(uploadResInstancesMap) && resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
1385 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
1386 throw new ComponentException(responseFormat);
1388 Map<String, Resource> existingNodeTypeMap = new HashMap<>();
1389 if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
1390 nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v));
1392 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1393 uploadResInstancesMap.values()
1394 .forEach(i -> createAndAddResourceInstance(i, yamlName, resource, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap));
1395 if (MapUtils.isNotEmpty(resourcesInstancesMap)) {
1397 toscaOperationFacade.associateComponentInstancesToComponent(resource, resourcesInstancesMap, false, false);
1398 } catch (StorageException exp) {
1399 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
1400 log.debug("Failed to add component instances to container component {}", resource.getName());
1401 ResponseFormat responseFormat = componentsUtils
1402 .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
1403 eitherResource = Either.right(responseFormat);
1404 throw new ByResponseFormatComponentException(eitherResource.right().value());
1408 log.debug("*************Going to get resource {}", resource.getUniqueId());
1409 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade
1410 .getToscaElement(resource.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter());
1411 log.debug("*************finished to get resource {}", resource.getUniqueId());
1412 if (eitherGetResource.isRight()) {
1413 ResponseFormat responseFormat = componentsUtils
1414 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource);
1415 throw new ComponentException(responseFormat);
1417 if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances()) &&
1418 resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
1419 log.debug("Error when create resource instance from csar. ComponentInstances list empty");
1420 BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty");
1421 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
1423 return eitherGetResource.left().value();
1426 protected void handleNodeTypes(String yamlName, Resource resource, String topologyTemplateYaml, boolean needLock,
1427 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1428 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1431 for (Map.Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
1432 if (nodeTypeEntry.getValue().isNested()) {
1433 handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1434 nodeTypeEntry.getKey());
1435 log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
1438 Map<String, Object> mappedToscaTemplate = null;
1439 if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo
1440 .containsKey(nodeName)) {
1441 mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
1443 if (MapUtils.isEmpty(mappedToscaTemplate)) {
1444 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
1446 createResourcesFromYamlNodeTypesList(yamlName, resource, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle,
1447 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
1448 } catch (ComponentException e) {
1449 ResponseFormat responseFormat =
1450 e.getResponseFormat() != null ? e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
1451 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
1453 } catch (StorageException e) {
1454 ResponseFormat responseFormat = componentsUtils
1455 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
1456 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
1458 } catch (Exception e) {
1459 log.debug("Exception occured when handleNodeTypes, error is:{}", e.getMessage(), e);
1460 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1464 protected Resource handleNestedVfc(Service service,
1465 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1466 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1469 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
1470 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
1471 createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
1473 log.debug("************* Finished to create node types from yaml {}", yamlName);
1474 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1475 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1476 return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
1478 return new Resource();
1479 } catch (Exception e) {
1480 log.debug("Exception occured when handleNestedVFc, error is:{}", e.getMessage(), e);
1481 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1485 protected Resource handleNestedVfc(Resource resource,
1486 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1487 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1489 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
1490 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
1491 log.debug("************* Going to create node types from yaml {}", yamlName);
1492 createResourcesFromYamlNodeTypesList(yamlName, resource, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
1494 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1495 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1496 resource = handleComplexVfc(resource, nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
1501 protected Resource handleComplexVfc(Resource resource,
1502 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1503 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1504 String nodeName, String yamlName) {
1505 Resource oldComplexVfc = null;
1506 Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(resource, csarInfo, nodeName, nodesInfo);
1507 Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
1508 .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
1509 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
1510 oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
1511 serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), nodeName).getRight());
1513 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
1514 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1515 } else if (oldComplexVfcRes.isLeft()) {
1516 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
1517 Either<Boolean, ResponseFormat> eitherValidation = serviceImportParseLogic
1518 .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc,
1519 ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
1520 if (eitherValidation.isLeft()) {
1521 oldComplexVfc = oldComplexVfcRes.left().value();
1524 newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc,
1526 csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
1527 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
1528 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR);
1529 log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
1530 final Resource result = serviceImportParseLogic
1531 .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true);
1532 csarInfo.getCreatedNodes().put(nodeName, result);
1533 csarInfo.removeNodeFromQueue();
1537 private Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Resource resource, Map<String, Object> mappedToscaTemplate,
1539 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1540 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1541 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
1542 Either<String, ImportUtils.ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
1543 TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
1544 if (toscaVersion.isRight()) {
1545 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
1547 Map<String, Object> mapToConvert = new HashMap<>();
1548 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value());
1549 Map<String, Object> nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate);
1550 createNodeTypes(yamlName, resource, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert,
1552 return csarInfo.getCreatedNodes();
1555 protected void createNodeTypes(String yamlName, Resource resource, boolean needLock,
1556 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1557 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1558 Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
1559 Iterator<Map.Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet().iterator();
1560 Resource vfcCreated = null;
1561 while (nodesNameValueIter.hasNext()) {
1562 Map.Entry<String, Object> nodeType = nodesNameValueIter.next();
1563 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle =
1564 nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeType.getKey());
1565 if (nodeTypesInfo.containsKey(nodeType.getKey())) {
1566 log.trace("************* Going to handle nested vfc {}", nodeType.getKey());
1567 vfcCreated = handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1569 log.trace("************* Finished to handle nested vfc {}", nodeType.getKey());
1570 } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames()
1571 .containsKey(nodeType.getKey())) {
1572 log.trace("************* Going to create node {}", nodeType.getKey());
1573 ImmutablePair<Resource, ActionStatus> resourceCreated = createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(),
1574 mapToConvert, resource, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true);
1575 log.debug("************* Finished to create node {}", nodeType.getKey());
1576 vfcCreated = resourceCreated.getLeft();
1577 csarInfo.getCreatedNodesToscaResourceNames().put(nodeType.getKey(), vfcCreated.getToscaResourceName());
1579 if (vfcCreated != null) {
1580 csarInfo.getCreatedNodes().put(nodeType.getKey(), vfcCreated);
1582 mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());
1586 protected ImmutablePair<Resource, ActionStatus> createNodeTypeResourceFromYaml(String yamlName, Map.Entry<String, Object> nodeNameValue,
1587 User user, Map<String, Object> mapToConvert, Resource resourceVf,
1589 Map<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
1590 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1591 boolean forceCertificationAllowed, CsarInfo csarInfo,
1593 final var validatedUser = serviceBusinessLogic.validateUser(user, "CheckIn Resource", resourceVf, AuditingActionEnum.CHECKIN_RESOURCE,
1595 UploadResourceInfo resourceMetaData = serviceImportParseLogic.fillResourceMetadata(yamlName, resourceVf, nodeNameValue.getKey(),
1597 String singleVfcYaml = serviceImportParseLogic.buildNodeTypeYaml(nodeNameValue, mapToConvert, resourceMetaData.getResourceType(), csarInfo);
1598 return serviceImportParseLogic.createResourceFromNodeType(singleVfcYaml, resourceMetaData, validatedUser, true, needLock,
1599 nodeTypeArtifactsToHandle,
1600 nodeTypesNewCreatedArtifacts, forceCertificationAllowed, csarInfo, nodeNameValue.getKey(), isNested);
1603 protected Service createRIAndRelationsFromYaml(String yamlName, Service service,
1604 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap,
1605 String topologyTemplateYaml, List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1606 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1607 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
1609 log.debug("************* Going to create all nodes {}", yamlName);
1610 handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts,
1611 nodeTypesInfo, csarInfo, nodeName);
1612 if (MapUtils.isNotEmpty(uploadComponentInstanceInfoMap)) {
1613 log.debug("************* Going to create all resource instances {}", yamlName);
1614 service = createServiceInstances(yamlName, service, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes());
1615 log.debug("************* Going to create all relations {}", yamlName);
1616 service = createServiceInstancesRelations(csarInfo.getModifier(), yamlName, service, uploadComponentInstanceInfoMap);
1617 log.debug("************* Going to create positions {}", yamlName);
1618 compositionBusinessLogic.setPositionsForComponentInstances(service, csarInfo.getModifier().getUserId());
1619 log.debug("************* Finished to set positions {}", yamlName);
1624 protected Service createServiceInstancesRelations(User user, String yamlName, Service service,
1625 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1626 log.debug("#createResourceInstancesRelations - Going to create relations ");
1627 List<ComponentInstance> componentInstancesList = service.getComponentInstances();
1628 if (MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)) { // PNF can have no resource instances
1629 log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
1630 service.getUniqueId(), yamlName);
1631 BeEcompErrorManager.getInstance()
1632 .logInternalDataError("createResourceInstancesRelations", "No instances found in a component or nn yaml template. ",
1633 BeEcompErrorManager.ErrorSeverity.ERROR);
1634 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName));
1636 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1637 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1638 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1639 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1640 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1641 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1642 Map<String, Resource> originCompMap = new HashMap<>();
1643 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1644 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1645 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1646 Map<String, Map<String, InterfaceDefinition>> instInterfaces = new HashMap<>();
1647 log.debug("enter ServiceImportBusinessLogic createServiceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. ");
1648 final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache;
1649 if (applicationDataTypeCache != null) {
1650 final Map<String, DataTypeDefinition> allDataTypesMap =
1651 componentsUtils.getAllDataTypes(applicationDataTypeCache, service.getModel());
1652 final Service service1 = service;
1653 uploadResInstancesMap.values().forEach(
1654 i -> processComponentInstance(yamlName, service1, componentInstancesList,
1655 allDataTypesMap, instProperties,
1656 instCapabilities, instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs,
1657 instNodeFilter, instInterfaces, i)
1660 updatePropertyToscaFunctionData(service, instProperties, instAttributes);
1661 serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, service, instProperties);
1662 serviceImportParseLogic.associateComponentInstanceInterfacesToComponent(
1667 serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, service, instInputs);
1668 serviceImportParseLogic.associateCINodeFilterToComponent(yamlName, service, instNodeFilter);
1669 serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, service, instDeploymentArtifacts);
1670 serviceImportParseLogic.associateArtifactsToInstances(yamlName, service, instArtifacts);
1671 serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, service, instCapabilities, instRequirements);
1672 log.debug("enter createServiceInstancesRelations test,instRequirements:{},instCapabilities:{}", instRequirements, instCapabilities);
1673 serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, service, instAttributes);
1674 ToscaElement serviceTemplate = ModelConverter.convertToToscaElement(service);
1675 Map<String, ListCapabilityDataDefinition> capabilities = serviceTemplate.getCapabilities();
1676 Map<String, ListRequirementDataDefinition> requirements = serviceTemplate.getRequirements();
1677 serviceImportParseLogic.associateCapabilitiesToService(yamlName, service, capabilities);
1678 serviceImportParseLogic.associateRequirementsToService(yamlName, service, requirements);
1679 service = getResourceAfterCreateRelations(service);
1680 addRelationsToRI(yamlName, service, uploadResInstancesMap, componentInstancesList, relations);
1681 serviceImportParseLogic.associateResourceInstances(yamlName, service, relations);
1682 log.debug("************* in create relations, getResource start");
1683 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
1684 log.debug("************* in create relations, getResource end");
1685 if (eitherGetResource.isRight()) {
1686 throw new ComponentException(componentsUtils
1687 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service,
1688 service.getComponentType()));
1690 return eitherGetResource.left().value();
1693 private void updatePropertyToscaFunctionData(final Component service,
1694 final Map<String, List<ComponentInstanceProperty>> instancePropertyMap,
1695 final Map<String, List<AttributeDefinition>> instanceAttributeMap) {
1696 final Component updatedService =
1697 toscaOperationFacade.getToscaElement(service.getUniqueId()).left()
1698 .on(storageOperationStatus -> {
1699 final ActionStatus status = componentsUtils.convertFromStorageResponse(storageOperationStatus);
1700 final ResponseFormat responseFormat =
1701 componentsUtils.getResponseFormatByComponent(status, service, service.getComponentType());
1702 throw new ComponentException(responseFormat);
1705 instancePropertyMap.values().forEach(instancePropertyList ->
1706 instancePropertyList.stream()
1707 .filter(PropertyDataDefinition::isToscaFunction)
1708 .forEach(instanceProperty -> {
1709 toscaFunctionService.updateFunctionWithDataFromSelfComponent(instanceProperty.getToscaFunction(),
1710 updatedService, instancePropertyMap, instanceAttributeMap);
1711 instanceProperty.setValue(instanceProperty.getToscaFunction().getValue());
1716 protected void processComponentInstance(String yamlName, Component component, List<ComponentInstance> componentInstancesList,
1717 Map<String, DataTypeDefinition> allDataTypes,
1718 Map<String, List<ComponentInstanceProperty>> instProperties,
1719 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
1720 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements,
1721 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts,
1722 Map<String, Map<String, ArtifactDefinition>> instArtifacts,
1723 Map<String, List<AttributeDefinition>> instAttributes, Map<String, Resource> originCompMap,
1724 Map<String, List<ComponentInstanceInput>> instInputs,
1725 Map<String, UploadNodeFilterInfo> instNodeFilter,
1726 Map<String, Map<String, InterfaceDefinition>> instInterfaces,
1727 UploadComponentInstanceInfo uploadComponentInstanceInfo) {
1728 log.debug("enter ServiceImportBusinessLogic processComponentInstance");
1729 Optional<ComponentInstance> currentCompInstanceOpt = componentInstancesList.stream()
1730 .filter(i -> i.getName().equals(uploadComponentInstanceInfo.getName())).findFirst();
1731 if (currentCompInstanceOpt.isEmpty()) {
1732 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), component.getUniqueId());
1733 BeEcompErrorManager.getInstance()
1734 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, component.getUniqueId(),
1735 BeEcompErrorManager.ErrorSeverity.ERROR);
1736 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1737 throw new ComponentException(responseFormat);
1739 ComponentInstance currentCompInstance = currentCompInstanceOpt.get();
1740 String resourceInstanceId = currentCompInstance.getUniqueId();
1741 Resource originResource = getOriginResource(yamlName, originCompMap, currentCompInstance);
1742 if (MapUtils.isNotEmpty(originResource.getRequirements())) {
1743 instRequirements.put(currentCompInstance, originResource.getRequirements());
1745 if (MapUtils.isNotEmpty(originResource.getCapabilities())) {
1746 processComponentInstanceCapabilities(allDataTypes, instCapabilties, uploadComponentInstanceInfo, currentCompInstance, originResource);
1748 if (originResource.getDeploymentArtifacts() != null && !originResource.getDeploymentArtifacts().isEmpty()) {
1749 instDeploymentArtifacts.put(resourceInstanceId, originResource.getDeploymentArtifacts());
1751 if (originResource.getArtifacts() != null && !originResource.getArtifacts().isEmpty()) {
1752 instArtifacts.put(resourceInstanceId, originResource.getArtifacts());
1754 if (originResource.getAttributes() != null && !originResource.getAttributes().isEmpty()) {
1755 instAttributes.put(resourceInstanceId, originResource.getAttributes());
1756 addAttributeValueToResourceInstance(instAttributes, uploadComponentInstanceInfo.getAttributes());
1758 if (uploadComponentInstanceInfo.getUploadNodeFilterInfo() != null) {
1759 instNodeFilter.put(resourceInstanceId, uploadComponentInstanceInfo.getUploadNodeFilterInfo());
1761 if (MapUtils.isNotEmpty(uploadComponentInstanceInfo.getInterfaces())) {
1763 ResponseFormat addInterfacesToRiRes = addInterfaceValuesToRi(
1764 uploadComponentInstanceInfo,
1767 currentCompInstance,
1770 if (addInterfacesToRiRes.getStatus() != 200) {
1771 throw new ComponentException(addInterfacesToRiRes);
1774 if (originResource.getResourceType() != ResourceTypeEnum.VF) {
1775 ResponseFormat addPropertiesValueToRiRes = addPropertyValuesToRi(uploadComponentInstanceInfo, component, originResource,
1776 currentCompInstance, instProperties, allDataTypes);
1777 if (addPropertiesValueToRiRes.getStatus() != 200) {
1778 throw new ComponentException(addPropertiesValueToRiRes);
1781 addInputsValuesToRi(uploadComponentInstanceInfo, component, originResource, currentCompInstance, instInputs, allDataTypes);
1785 protected void addInputsValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component, Resource originResource,
1786 ComponentInstance currentCompInstance, Map<String, List<ComponentInstanceInput>> instInputs,
1787 Map<String, DataTypeDefinition> allDataTypes) {
1788 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
1790 if (MapUtils.isNotEmpty(propMap)) {
1791 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
1792 List<ComponentInstanceInput> instPropList = new ArrayList<>();
1793 if (CollectionUtils.isEmpty(originResource.getInputs())) {
1794 log.debug("failed to find properties ");
1795 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND));
1797 originResource.getInputs().forEach(p -> serviceImportParseLogic.addInput(currPropertiesMap, p));
1798 for (List<UploadPropInfo> propertyList : propMap.values()) {
1799 processProperty(component, allDataTypes, currPropertiesMap, instPropList, propertyList);
1801 currPropertiesMap.values().forEach(p -> instPropList.add(new ComponentInstanceInput(p)));
1802 instInputs.put(currentCompInstance.getUniqueId(), instPropList);
1804 } catch (Exception e) {
1805 log.debug("failed to add Inputs Values To Ri");
1806 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1810 protected void processProperty(Component component, Map<String, DataTypeDefinition> allDataTypes,
1811 Map<String, InputDefinition> currPropertiesMap, List<ComponentInstanceInput> instPropList,
1812 List<UploadPropInfo> propertyList) {
1813 UploadPropInfo propertyInfo = propertyList.get(0);
1814 String propName = propertyInfo.getName();
1815 if (!currPropertiesMap.containsKey(propName)) {
1816 log.debug("failed to find property {} ", propName);
1817 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName));
1819 processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, component.getInputs());
1822 protected void processGetInput(List<GetInputValueDataDefinition> getInputValues, List<InputDefinition> inputs,
1823 GetInputValueDataDefinition getInputIndex) {
1824 Optional<InputDefinition> optional;
1825 if (getInputIndex != null) {
1826 optional = inputs.stream().filter(p -> p.getName().equals(getInputIndex.getInputName())).findAny();
1827 if (!optional.isPresent()) {
1828 log.debug("Failed to find input {} ", getInputIndex.getInputName());
1829 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1831 InputDefinition inputIndex = optional.get();
1832 getInputIndex.setInputId(inputIndex.getUniqueId());
1833 getInputValues.add(getInputIndex);
1837 private void addAttributeValueToResourceInstance(Map<String, List<AttributeDefinition>> instAttributes,
1838 Map<String, UploadAttributeInfo> attributeMap) {
1839 if (attributeMap == null) {
1842 attributeMap.forEach((attributeName, attributeValue) -> instAttributes.values()
1843 .forEach(value -> value.stream().filter(attr -> attr.getName().equals(attributeName)).forEach(attr -> {
1844 if (attributeValue.getValue() instanceof Collection<?> || attributeValue.getValue() instanceof Map<?, ?>) {
1845 Gson gson = new Gson();
1846 String json = gson.toJson(attributeValue.getValue());
1847 attr.setValue(json);
1849 attr.setValue(String.valueOf(attributeValue.getValue()));
1854 protected ResponseFormat addPropertyValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component,
1855 Resource originResource, ComponentInstance currentCompInstance,
1856 Map<String, List<ComponentInstanceProperty>> instProperties,
1857 Map<String, DataTypeDefinition> allDataTypes) {
1858 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
1859 Map<String, PropertyDefinition> currPropertiesMap = new HashMap<>();
1860 List<PropertyDefinition> originalPropertyList = originResource.getProperties();
1861 if (MapUtils.isNotEmpty(propMap) && CollectionUtils.isEmpty(originalPropertyList)) {
1862 log.debug("failed to find properties ");
1863 return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND);
1865 if (CollectionUtils.isEmpty(originalPropertyList)) {
1866 return componentsUtils.getResponseFormat(ActionStatus.OK);
1868 originalPropertyList.stream()
1869 .filter(property -> !currPropertiesMap.containsKey(property.getName()))
1870 .forEach(property -> currPropertiesMap.put(property.getName(), property));
1871 List<ComponentInstanceProperty> instPropList = new ArrayList<>();
1872 if (MapUtils.isNotEmpty(propMap)) {
1873 for (final List<UploadPropInfo> propertyList : propMap.values()) {
1874 UploadPropInfo propertyInfo = propertyList.get(0);
1875 String propName = propertyInfo.getName();
1876 if (!currPropertiesMap.containsKey(propName)) {
1877 log.debug("failed to find property {} ", propName);
1878 return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName);
1880 PropertyDefinition curPropertyDef = currPropertiesMap.get(propName);
1881 String value = null;
1882 final List<GetInputValueDataDefinition> getInputs = new ArrayList<>();
1883 boolean isValidate = true;
1884 if (propertyInfo.getValue() != null) {
1885 getInputs.addAll(propertyInfo.getGet_input());
1886 isValidate = getInputs.isEmpty();
1888 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
1890 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
1893 final var property = new ComponentInstanceProperty(curPropertyDef, value, null);
1894 String validatePropValue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
1895 property.setValue(validatePropValue);
1896 property.setToscaFunction(propertyInfo.getToscaFunction());
1897 if (!getInputs.isEmpty()) {
1898 final List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1899 for (final GetInputValueDataDefinition getInput : getInputs) {
1900 final List<InputDefinition> inputs = component.getInputs();
1901 if (inputs == null || inputs.isEmpty()) {
1902 log.debug("Failed to add property {} to instance. Inputs list is empty ", property);
1903 serviceBusinessLogic.rollbackWithException(ActionStatus.INPUTS_NOT_FOUND,
1904 property.getGetInputValues().stream().map(GetInputValueDataDefinition::getInputName).collect(toList()).toString());
1906 InputDefinition input = serviceImportParseLogic.findInputByName(inputs, getInput);
1907 getInput.setInputId(input.getUniqueId());
1908 getInputValues.add(getInput);
1909 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
1910 if (getInputIndex != null) {
1911 input = serviceImportParseLogic.findInputByName(inputs, getInputIndex);
1912 getInputIndex.setInputId(input.getUniqueId());
1913 getInputValues.add(getInputIndex);
1916 property.setGetInputValues(getInputValues);
1918 instPropList.add(property);
1919 currPropertiesMap.remove(property.getName());
1922 if (!currPropertiesMap.isEmpty()) {
1923 for (PropertyDefinition value : currPropertiesMap.values()) {
1924 instPropList.add(new ComponentInstanceProperty(value));
1927 instProperties.put(currentCompInstance.getUniqueId(), instPropList);
1928 return componentsUtils.getResponseFormat(ActionStatus.OK);
1931 protected ResponseFormat addInterfaceValuesToRi(
1932 UploadComponentInstanceInfo uploadComponentInstanceInfo,
1933 Component component,
1934 Resource originResource, ComponentInstance currentCompInstance,
1935 Map<String, Map<String, InterfaceDefinition>> instInterfaces
1937 Map<String, UploadInterfaceInfo> instanceInterfacesMap = uploadComponentInstanceInfo.getInterfaces();
1938 Map<String, InterfaceDefinition> currInterfacesMap = new HashMap<>();
1939 Map<String, InterfaceDefinition> interfacesFromNodeType = originResource.getInterfaces();
1940 if ((MapUtils.isNotEmpty(instanceInterfacesMap)) && (MapUtils.isEmpty(interfacesFromNodeType))) {
1941 log.debug("failed to find interfaces ");
1942 return componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT);
1944 if (interfacesFromNodeType == null || interfacesFromNodeType.isEmpty()) {
1945 return componentsUtils.getResponseFormat(ActionStatus.OK);
1947 for (Map.Entry<String, InterfaceDefinition> entryInstances : interfacesFromNodeType.entrySet()) {
1948 String interfaceName = entryInstances.getKey().substring(entryInstances.getKey().lastIndexOf(".") + 1);
1949 if (!currInterfacesMap.containsKey(interfaceName)) {
1950 currInterfacesMap.put(interfaceName, entryInstances.getValue());
1954 Map<String, InterfaceDefinition> instInterfacesMap = new HashMap<>();
1955 if (MapUtils.isNotEmpty(instanceInterfacesMap)) {
1956 for (UploadInterfaceInfo uploadInterfaceInfo : instanceInterfacesMap.values()) {
1957 String interfaceName = uploadInterfaceInfo.getName();
1958 if (!currInterfacesMap.containsKey(interfaceName)) {
1959 log.debug("failed to find interface {} ", interfaceName);
1960 return componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT, interfaceName);
1962 InterfaceDefinition currentInterfaceDef = currInterfacesMap.get(interfaceName);
1963 Map<String, OperationDataDefinition> operationsToAdd = new HashMap<>();
1965 Map<String, OperationDataDefinition> operations = uploadInterfaceInfo.getOperations();
1966 for (Map.Entry<String, OperationDataDefinition> operation : operations.entrySet()) {
1967 OperationDataDefinition templateOperation = currentInterfaceDef.getOperationsMap().get(operation.getKey());
1968 OperationDataDefinition instanceOperation = operation.getValue();
1970 ListDataDefinition<OperationInputDefinition> instanceInputs = instanceOperation.getInputs();
1971 mergeOperationInputDefinitions(templateOperation.getInputs(), instanceInputs);
1972 templateOperation.setInputs(instanceInputs);
1974 templateOperation.setImplementation(instanceOperation.getImplementation());
1976 templateOperation.setDescription(instanceOperation.getDescription());
1977 operationsToAdd.put(operation.getKey(), templateOperation);
1979 InterfaceDefinition interfaceDef = new InterfaceDefinition();
1980 interfaceDef.setModel(component.getModel());
1981 interfaceDef.setType(currentInterfaceDef.getType());
1982 interfaceDef.setUniqueId(currentInterfaceDef.getType());
1983 interfaceDef.setDescription(uploadInterfaceInfo.getDescription());
1984 interfaceDef.setOperations(operationsToAdd);
1985 instInterfacesMap.put(interfaceName, interfaceDef);
1986 currInterfacesMap.remove(interfaceName);
1989 if (!currInterfacesMap.isEmpty()) {
1990 for (InterfaceDefinition value : currInterfacesMap.values()) {
1991 instInterfacesMap.put(value.getUniqueId(), value);
1994 instInterfaces.put(currentCompInstance.getUniqueId(), instInterfacesMap);
1995 return componentsUtils.getResponseFormat(ActionStatus.OK);
1998 private void mergeOperationInputDefinitions(ListDataDefinition<OperationInputDefinition> inputsFromNodeType,
1999 ListDataDefinition<OperationInputDefinition> instanceInputs) {
2000 instanceInputs.getListToscaDataDefinition().forEach(
2001 instanceInput -> inputsFromNodeType.getListToscaDataDefinition().stream().filter(
2002 templateInput -> templateInput.getName().equals(instanceInput.getName())
2004 newInstanceInput -> {
2005 instanceInput.setSourceProperty(newInstanceInput.getSourceProperty());
2006 instanceInput.setSource(newInstanceInput.getSource());
2007 instanceInput.setType(newInstanceInput.getType());
2011 instanceInputs.getListToscaDataDefinition().stream()
2012 .filter(instanceInput -> inputsFromNodeType.getListToscaDataDefinition().stream().noneMatch(
2013 inputFromNodeType -> inputFromNodeType.getName().equals(instanceInput.getName())
2015 .forEach(oldInput -> oldInput.setType("string"));
2018 protected void processComponentInstanceCapabilities(Map<String, DataTypeDefinition> allDataTypes,
2019 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
2020 UploadComponentInstanceInfo uploadComponentInstanceInfo,
2021 ComponentInstance currentCompInstance, Resource originResource) {
2022 log.debug("enter processComponentInstanceCapabilities");
2023 Map<String, List<CapabilityDefinition>> originCapabilities;
2024 if (MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities())) {
2025 originCapabilities = new HashMap<>();
2026 Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
2027 originResource.getCapabilities().forEach((k, v) -> serviceImportParseLogic.addCapabilities(originCapabilities, k, v));
2028 uploadComponentInstanceInfo.getCapabilities().values()
2029 .forEach(l -> serviceImportParseLogic.addCapabilitiesProperties(newPropertiesMap, l));
2030 updateCapabilityPropertiesValues(allDataTypes, originCapabilities, newPropertiesMap);
2032 originCapabilities = originResource.getCapabilities();
2034 instCapabilties.put(currentCompInstance, originCapabilities);
2037 protected void updateCapabilityPropertiesValues(Map<String, DataTypeDefinition> allDataTypes,
2038 Map<String, List<CapabilityDefinition>> originCapabilities,
2039 Map<String, Map<String, UploadPropInfo>> newPropertiesMap) {
2040 originCapabilities.values().stream().flatMap(Collection::stream).filter(c -> newPropertiesMap.containsKey(c.getName()))
2041 .forEach(c -> updatePropertyValues(c.getProperties(), newPropertiesMap.get(c.getName()), allDataTypes));
2044 protected void updatePropertyValues(List<ComponentInstanceProperty> properties, Map<String, UploadPropInfo> newProperties,
2045 Map<String, DataTypeDefinition> allDataTypes) {
2046 properties.forEach(p -> updatePropertyValue(p, newProperties.get(p.getName()), allDataTypes));
2049 protected String updatePropertyValue(ComponentInstanceProperty property, UploadPropInfo propertyInfo,
2050 Map<String, DataTypeDefinition> allDataTypes) {
2051 String value = null;
2052 List<GetInputValueDataDefinition> getInputs = null;
2053 boolean isValidate = true;
2054 if (null != propertyInfo && propertyInfo.getValue() != null) {
2055 getInputs = propertyInfo.getGet_input();
2056 isValidate = getInputs == null || getInputs.isEmpty();
2058 value = getPropertyJsonStringValue(propertyInfo.getValue(), property.getType());
2060 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
2063 property.setValue(value);
2064 return serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
2067 protected Resource getOriginResource(String yamlName, Map<String, Resource> originCompMap, ComponentInstance currentCompInstance) {
2068 Resource originResource;
2069 log.debug("after enter ServiceImportBusinessLogic processComponentInstance, enter getOriginResource");
2070 if (!originCompMap.containsKey(currentCompInstance.getComponentUid())) {
2071 Either<Resource, StorageOperationStatus> getOriginResourceRes = toscaOperationFacade
2072 .getToscaFullElement(currentCompInstance.getComponentUid());
2073 if (getOriginResourceRes.isRight()) {
2074 ResponseFormat responseFormat = componentsUtils
2075 .getResponseFormat(componentsUtils.convertFromStorageResponse(getOriginResourceRes.right().value()), yamlName);
2076 throw new ComponentException(responseFormat);
2078 originResource = getOriginResourceRes.left().value();
2079 originCompMap.put(originResource.getUniqueId(), originResource);
2081 originResource = originCompMap.get(currentCompInstance.getComponentUid());
2083 return originResource;
2086 protected Either<Resource, StorageOperationStatus> updateCalculatedCapReqWithSubstitutionMappings(Resource resource,
2087 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
2088 Either<Resource, StorageOperationStatus> updateRes = null;
2089 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities = new HashMap<>();
2090 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements = new HashMap<>();
2091 StorageOperationStatus status = toscaOperationFacade.deleteAllCalculatedCapabilitiesRequirements(resource.getUniqueId());
2092 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
2093 log.debug("Failed to delete all calculated capabilities and requirements of resource {} upon update. Status is {}",
2094 resource.getUniqueId(), status);
2095 updateRes = Either.right(status);
2097 if (updateRes == null) {
2098 fillUpdatedInstCapabilitiesRequirements(resource.getComponentInstances(), uploadResInstancesMap, updatedInstCapabilities,
2099 updatedInstRequirements);
2100 status = toscaOperationFacade.associateOrAddCalculatedCapReq(updatedInstCapabilities, updatedInstRequirements, resource);
2101 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
2102 updateRes = Either.right(status);
2105 if (updateRes == null) {
2106 updateRes = Either.left(resource);
2111 protected void fillUpdatedInstCapabilitiesRequirements(List<ComponentInstance> componentInstances,
2112 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
2113 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities,
2114 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements) {
2115 componentInstances.stream().forEach(i -> {
2116 fillUpdatedInstCapabilities(updatedInstCapabilities, i, uploadResInstancesMap.get(i.getName()).getCapabilitiesNamesToUpdate());
2117 fillUpdatedInstRequirements(updatedInstRequirements, i, uploadResInstancesMap.get(i.getName()).getRequirementsNamesToUpdate());
2121 protected void fillUpdatedInstCapabilities(Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilties,
2122 ComponentInstance instance, Map<String, String> capabilitiesNamesToUpdate) {
2123 Map<String, List<CapabilityDefinition>> updatedCapabilities = new HashMap<>();
2124 Set<String> updatedCapNames = new HashSet<>();
2125 if (MapUtils.isNotEmpty(capabilitiesNamesToUpdate)) {
2126 for (Map.Entry<String, List<CapabilityDefinition>> requirements : instance.getCapabilities().entrySet()) {
2127 updatedCapabilities.put(requirements.getKey(), requirements.getValue().stream().filter(
2128 c -> capabilitiesNamesToUpdate.containsKey(c.getName()) && !updatedCapNames.contains(capabilitiesNamesToUpdate.get(c.getName())))
2130 c.setParentName(c.getName());
2131 c.setName(capabilitiesNamesToUpdate.get(c.getName()));
2132 updatedCapNames.add(c.getName());
2134 }).collect(toList()));
2137 if (MapUtils.isNotEmpty(updatedCapabilities)) {
2138 updatedInstCapabilties.put(instance, updatedCapabilities);
2142 protected void fillUpdatedInstRequirements(Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements,
2143 ComponentInstance instance, Map<String, String> requirementsNamesToUpdate) {
2144 Map<String, List<RequirementDefinition>> updatedRequirements = new HashMap<>();
2145 Set<String> updatedReqNames = new HashSet<>();
2146 if (MapUtils.isNotEmpty(requirementsNamesToUpdate)) {
2147 for (Map.Entry<String, List<RequirementDefinition>> requirements : instance.getRequirements().entrySet()) {
2148 updatedRequirements.put(requirements.getKey(), requirements.getValue().stream().filter(
2149 r -> requirementsNamesToUpdate.containsKey(r.getName()) && !updatedReqNames.contains(requirementsNamesToUpdate.get(r.getName())))
2151 r.setParentName(r.getName());
2152 r.setName(requirementsNamesToUpdate.get(r.getName()));
2153 updatedReqNames.add(r.getName());
2155 }).collect(toList()));
2158 if (MapUtils.isNotEmpty(updatedRequirements)) {
2159 updatedInstRequirements.put(instance, updatedRequirements);
2163 protected void addRelationsToRI(String yamlName, Service service, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
2164 List<ComponentInstance> componentInstancesList, List<RequirementCapabilityRelDef> relations) {
2165 for (Map.Entry<String, UploadComponentInstanceInfo> entry : uploadResInstancesMap.entrySet()) {
2166 UploadComponentInstanceInfo uploadComponentInstanceInfo = entry.getValue();
2167 ComponentInstance currentCompInstance = null;
2168 for (ComponentInstance compInstance : componentInstancesList) {
2169 if (compInstance.getName().equals(uploadComponentInstanceInfo.getName())) {
2170 currentCompInstance = compInstance;
2174 if (currentCompInstance == null) {
2175 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), service.getUniqueId());
2176 BeEcompErrorManager.getInstance()
2177 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, service.getUniqueId(),
2178 BeEcompErrorManager.ErrorSeverity.ERROR);
2179 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2180 throw new ComponentException(responseFormat);
2182 ResponseFormat addRelationToRiRes = addRelationToRI(yamlName, service, entry.getValue(), relations);
2183 if (addRelationToRiRes.getStatus() != 200) {
2184 throw new ComponentException(addRelationToRiRes);
2189 protected ResponseFormat addRelationToRI(String yamlName, Service service, UploadComponentInstanceInfo nodesInfoValue,
2190 List<RequirementCapabilityRelDef> relations) {
2191 List<ComponentInstance> componentInstancesList = service.getComponentInstances();
2192 ComponentInstance currentCompInstance = null;
2193 for (ComponentInstance compInstance : componentInstancesList) {
2194 if (compInstance.getName().equals(nodesInfoValue.getName())) {
2195 currentCompInstance = compInstance;
2199 if (currentCompInstance == null) {
2200 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, nodesInfoValue.getName(), service.getUniqueId());
2201 BeEcompErrorManager.getInstance()
2202 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + nodesInfoValue.getName() + IN_RESOURCE, service.getUniqueId(),
2203 BeEcompErrorManager.ErrorSeverity.ERROR);
2204 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2206 String resourceInstanceId = currentCompInstance.getUniqueId();
2207 Map<String, List<UploadReqInfo>> regMap = nodesInfoValue.getRequirements();
2208 if (regMap != null) {
2209 Iterator<Map.Entry<String, List<UploadReqInfo>>> nodesRegValue = regMap.entrySet().iterator();
2210 while (nodesRegValue.hasNext()) {
2211 Map.Entry<String, List<UploadReqInfo>> nodesRegInfoEntry = nodesRegValue.next();
2212 List<UploadReqInfo> uploadRegInfoList = nodesRegInfoEntry.getValue();
2213 for (UploadReqInfo uploadRegInfo : uploadRegInfoList) {
2214 log.debug("Going to create relation {}", uploadRegInfo.getName());
2215 String regName = uploadRegInfo.getName();
2216 RequirementCapabilityRelDef regCapRelDef = new RequirementCapabilityRelDef();
2217 regCapRelDef.setFromNode(resourceInstanceId);
2218 log.debug("try to find available requirement {} ", regName);
2219 Either<RequirementDefinition, ResponseFormat> eitherReqStatus = serviceImportParseLogic
2220 .findAvailableRequirement(regName, yamlName, nodesInfoValue, currentCompInstance, uploadRegInfo.getCapabilityName());
2221 if (eitherReqStatus.isRight()) {
2222 log.debug("failed to find available requirement {} status is {}", regName, eitherReqStatus.right().value());
2223 return eitherReqStatus.right().value();
2225 RequirementDefinition validReq = eitherReqStatus.left().value();
2226 List<CapabilityRequirementRelationship> reqAndRelationshipPairList = regCapRelDef.getRelationships();
2227 if (reqAndRelationshipPairList == null) {
2228 reqAndRelationshipPairList = new ArrayList<>();
2230 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
2231 reqAndRelationshipPair.setRequirement(regName);
2232 reqAndRelationshipPair.setRequirementOwnerId(validReq.getOwnerId());
2233 reqAndRelationshipPair.setRequirementUid(validReq.getUniqueId());
2234 RelationshipImpl relationship = new RelationshipImpl();
2235 relationship.setType(validReq.getCapability());
2236 reqAndRelationshipPair.setRelationships(relationship);
2237 ComponentInstance currentCapCompInstance = null;
2238 for (ComponentInstance compInstance : componentInstancesList) {
2239 if (compInstance.getName().equals(uploadRegInfo.getNode())) {
2240 currentCapCompInstance = compInstance;
2244 if (currentCapCompInstance == null) {
2245 log.debug("The component instance with name {} not found on resource {} ", uploadRegInfo.getNode(), service.getUniqueId());
2246 BeEcompErrorManager.getInstance()
2247 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadRegInfo.getNode() + IN_RESOURCE, service.getUniqueId(),
2248 BeEcompErrorManager.ErrorSeverity.ERROR);
2249 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2251 regCapRelDef.setToNode(currentCapCompInstance.getUniqueId());
2252 log.debug("try to find aviable Capability req name is {} ", validReq.getName());
2253 CapabilityDefinition aviableCapForRel = serviceImportParseLogic
2254 .findAvailableCapabilityByTypeOrName(validReq, currentCapCompInstance, uploadRegInfo);
2255 if (aviableCapForRel == null) {
2256 BeEcompErrorManager.getInstance().logInternalDataError(
2257 "aviable capability was not found. req name is " + validReq.getName() + " component instance is " + currentCapCompInstance
2258 .getUniqueId(), service.getUniqueId(), BeEcompErrorManager.ErrorSeverity.ERROR);
2259 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2261 reqAndRelationshipPair.setCapability(aviableCapForRel.getName());
2262 reqAndRelationshipPair.setCapabilityUid(aviableCapForRel.getUniqueId());
2263 reqAndRelationshipPair.setCapabilityOwnerId(aviableCapForRel.getOwnerId());
2264 CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship();
2265 capReqRel.setRelation(reqAndRelationshipPair);
2266 if (StringUtils.isNotEmpty(uploadRegInfo.getRelationshipTemplate())) {
2267 capReqRel.setOperations(getOperations(nodesInfoValue.getOperations(), uploadRegInfo.getRelationshipTemplate()));
2269 reqAndRelationshipPairList.add(capReqRel);
2270 regCapRelDef.setRelationships(reqAndRelationshipPairList);
2271 relations.add(regCapRelDef);
2275 return componentsUtils.getResponseFormat(ActionStatus.OK, yamlName);
2278 private List<OperationUi> getOperations(final Map<String, List<OperationUi>> operations, final String relationshipTemplate) {
2279 final List<OperationUi> operationUiList = new ArrayList<>();
2280 operations.forEach((operationKey, operationValues) -> {
2281 if (operationKey.equals(relationshipTemplate)) {
2282 operationUiList.addAll(operationValues);
2285 return operationUiList;
2288 protected Service getResourceAfterCreateRelations(Service service) {
2289 ComponentParametersView parametersView = serviceImportParseLogic.getComponentFilterAfterCreateRelations();
2290 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId(), parametersView);
2291 if (eitherGetResource.isRight()) {
2292 serviceImportParseLogic.throwComponentExceptionByResource(eitherGetResource.right().value(), service);
2294 return eitherGetResource.left().value();
2297 protected Service createServiceInstances(String yamlName, Service service, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
2298 Map<String, Resource> nodeNamespaceMap) {
2299 Either<Resource, ResponseFormat> eitherResource = null;
2300 log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
2301 if (MapUtils.isEmpty(uploadResInstancesMap)) { // PNF can have no resource instances
2302 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
2303 throw new ComponentException(responseFormat);
2305 Map<String, Resource> existingNodeTypeMap = new HashMap<>();
2306 if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
2307 nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v));
2309 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
2310 uploadResInstancesMap.values()
2311 .forEach(i -> createAndAddResourceInstance(i, yamlName, service, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap));
2312 if (MapUtils.isNotEmpty(resourcesInstancesMap)) {
2314 toscaOperationFacade.associateComponentInstancesToComponent(service, resourcesInstancesMap, false, false);
2315 } catch (StorageException exp) {
2316 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
2317 log.debug("Failed to add component instances to container component {}", service.getName());
2318 ResponseFormat responseFormat = componentsUtils
2319 .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
2320 eitherResource = Either.right(responseFormat);
2321 throw new ComponentException(eitherResource.right().value());
2325 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade
2326 .getToscaElement(service.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter());
2327 log.debug("*************finished to get resource {}", service.getUniqueId());
2328 if (eitherGetResource.isRight()) {
2329 ResponseFormat responseFormat = componentsUtils
2330 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service,
2331 ComponentTypeEnum.SERVICE);
2332 throw new ComponentException(responseFormat);
2334 if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances())) { // PNF can have no resource instances
2335 log.debug("Error when create resource instance from csar. ComponentInstances list empty");
2336 BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty");
2337 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
2339 return eitherGetResource.left().value();
2342 protected void createAndAddResourceInstance(UploadComponentInstanceInfo uploadComponentInstanceInfo, String yamlName, Component component,
2343 Map<String, Resource> nodeNamespaceMap, Map<String, Resource> existingnodeTypeMap,
2344 Map<ComponentInstance, Resource> resourcesInstancesMap) {
2345 log.debug("*************Going to create resource instances {}", uploadComponentInstanceInfo.getName());
2347 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
2348 uploadComponentInstanceInfo.setType(nodeNamespaceMap.get(uploadComponentInstanceInfo.getType()).getToscaResourceName());
2350 Resource refResource = validateResourceInstanceBeforeCreate(yamlName, uploadComponentInstanceInfo, existingnodeTypeMap);
2351 ComponentInstance componentInstance = new ComponentInstance();
2352 componentInstance.setComponentUid(refResource.getUniqueId());
2353 Collection<String> directives = uploadComponentInstanceInfo.getDirectives();
2354 if (directives != null && !directives.isEmpty()) {
2355 componentInstance.setDirectives(new ArrayList<>(directives));
2357 UploadNodeFilterInfo uploadNodeFilterInfo = uploadComponentInstanceInfo.getUploadNodeFilterInfo();
2358 if (uploadNodeFilterInfo != null) {
2360 .setNodeFilter(new CINodeFilterUtils().getNodeFilterDataDefinition(uploadNodeFilterInfo, componentInstance.getUniqueId()));
2362 ComponentTypeEnum containerComponentType = component.getComponentType();
2363 NodeTypeEnum containerNodeType = containerComponentType.getNodeType();
2364 if (containerNodeType.equals(NodeTypeEnum.Resource) && MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities()) && MapUtils
2365 .isNotEmpty(refResource.getCapabilities())) {
2366 serviceImportParseLogic.setCapabilityNamesTypes(refResource.getCapabilities(), uploadComponentInstanceInfo.getCapabilities());
2367 Map<String, List<CapabilityDefinition>> validComponentInstanceCapabilities = serviceImportParseLogic
2368 .getValidComponentInstanceCapabilities(refResource.getUniqueId(), refResource.getCapabilities(),
2369 uploadComponentInstanceInfo.getCapabilities());
2370 componentInstance.setCapabilities(validComponentInstanceCapabilities);
2372 if (!existingnodeTypeMap.containsKey(uploadComponentInstanceInfo.getType())) {
2373 ResponseFormat responseFormat = componentsUtils
2374 .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(),
2375 uploadComponentInstanceInfo.getType());
2376 throw new ComponentException(responseFormat);
2378 Resource origResource = existingnodeTypeMap.get(uploadComponentInstanceInfo.getType());
2379 componentInstance.setName(uploadComponentInstanceInfo.getName());
2380 componentInstance.setIcon(origResource.getIcon());
2381 resourcesInstancesMap.put(componentInstance, origResource);
2382 } catch (Exception e) {
2383 throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
2387 protected Resource validateResourceInstanceBeforeCreate(String yamlName, UploadComponentInstanceInfo uploadComponentInstanceInfo,
2388 Map<String, Resource> nodeNamespaceMap) {
2389 Resource refResource;
2391 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
2392 refResource = nodeNamespaceMap.get(uploadComponentInstanceInfo.getType());
2394 Either<Resource, StorageOperationStatus> findResourceEither = toscaOperationFacade
2395 .getLatestResourceByToscaResourceName(uploadComponentInstanceInfo.getType());
2396 if (findResourceEither.isRight()) {
2397 ResponseFormat responseFormat = componentsUtils
2398 .getResponseFormat(componentsUtils.convertFromStorageResponse(findResourceEither.right().value()));
2399 throw new ComponentException(responseFormat);
2401 refResource = findResourceEither.left().value();
2402 nodeNamespaceMap.put(refResource.getToscaResourceName(), refResource);
2404 String componentState = refResource.getComponentMetadataDefinition().getMetadataDataDefinition().getState();
2405 if (componentState.equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
2406 ResponseFormat responseFormat = componentsUtils
2407 .getResponseFormat(ActionStatus.ILLEGAL_COMPONENT_STATE, refResource.getComponentType().getValue(), refResource.getName(),
2409 throw new ComponentException(responseFormat);
2411 if (!ModelConverter.isAtomicComponent(refResource) && refResource.getResourceType() != ResourceTypeEnum.VF) {
2412 log.debug("validateResourceInstanceBeforeCreate - ref resource type is ", refResource.getResourceType());
2413 ResponseFormat responseFormat = componentsUtils
2414 .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(),
2415 uploadComponentInstanceInfo.getType());
2416 throw new ComponentException(responseFormat);
2419 } catch (Exception e) {
2420 throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
2424 protected void handleServiceNodeTypes(String yamlName, Service service, String topologyTemplateYaml, boolean needLock,
2425 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2426 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo,
2427 CsarInfo csarInfo, String nodeName) {
2429 for (Map.Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
2430 boolean isResourceNotExisted = validateResourceNotExisted(nodeTypeEntry.getKey());
2431 if (nodeTypeEntry.getValue().isNested() && isResourceNotExisted) {
2432 handleNestedVF(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
2433 nodeTypeEntry.getKey());
2434 log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
2437 Map<String, Object> mappedToscaTemplate = null;
2438 if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo
2439 .containsKey(nodeName)) {
2440 mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
2442 if (MapUtils.isEmpty(mappedToscaTemplate)) {
2443 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
2445 createResourcesFromYamlNodeTypesList(yamlName, service, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle,
2446 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
2447 } catch (ComponentException | StorageException e) {
2449 } catch (Exception e) {
2450 log.debug("Exception occured when handleServiceNodeTypes, error is:{}", e.getMessage(), e);
2451 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2455 protected boolean validateResourceNotExisted(String type) {
2457 Either<Resource, StorageOperationStatus> latestResource = toscaOperationFacade.getLatestResourceByToscaResourceName(type);
2458 return latestResource.isRight();
2459 } catch (Exception e) {
2460 log.debug("Exception occured when validateResourceNotExisted, error is:{}", e.getMessage(), e);
2461 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2465 protected Resource handleNestedVF(Service service,
2466 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2467 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
2470 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
2471 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
2472 createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
2474 log.debug("************* Finished to create node types from yaml {}", yamlName);
2475 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
2476 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
2477 return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
2479 return new Resource();
2480 } catch (Exception e) {
2481 log.debug("Exception occured when handleNestedVF, error is:{}", e.getMessage(), e);
2482 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2486 protected Resource handleComplexVfc(
2487 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2488 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName) {
2490 Resource oldComplexVfc = null;
2491 Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(csarInfo, nodeName, nodesInfo);
2492 Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
2493 .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
2494 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
2495 oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
2496 serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), nodeName)
2499 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
2500 log.debug("Failed to fetch previous complex VFC by tosca resource name {}. Status is {}. ", newComplexVfc.getToscaResourceName(),
2501 oldComplexVfcRes.right().value());
2502 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2503 } else if (oldComplexVfcRes.isLeft()) {
2504 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
2505 Either<Boolean, ResponseFormat> eitherValidation = serviceImportParseLogic
2506 .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc,
2507 ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
2508 if (eitherValidation.isLeft()) {
2509 oldComplexVfc = oldComplexVfcRes.left().value();
2512 newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc,
2514 csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
2515 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
2516 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR);
2517 log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
2518 final Resource result = serviceImportParseLogic
2519 .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true);
2520 csarInfo.getCreatedNodes().put(nodeName, result);
2521 csarInfo.removeNodeFromQueue();
2523 } catch (Exception e) {
2524 log.debug("Exception occured when handleComplexVfc, error is:{}", e.getMessage(), e);
2525 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2529 protected Resource handleComplexVfc(
2530 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2531 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName,
2532 Resource oldComplexVfc, Resource newComplexVfc) {
2533 Resource handleComplexVfcRes;
2535 Map<String, Object> mappedToscaTemplate = nodesInfo.get(nodeName).getMappedToscaTemplate();
2536 String yamlContent = new String(csarInfo.getCsar().get(yamlName));
2537 Map<String, NodeTypeInfo> newNodeTypesInfo = nodesInfo.entrySet().stream()
2538 .collect(toMap(Map.Entry::getKey, e -> e.getValue().getUnmarkedCopy()));
2539 CsarInfo.markNestedVfc(mappedToscaTemplate, newNodeTypesInfo);
2540 if (oldComplexVfc == null) {
2541 handleComplexVfcRes = createResourceFromYaml(newComplexVfc, yamlContent, yamlName, newNodeTypesInfo, csarInfo, nodesArtifactsToHandle,
2542 false, true, nodeName);
2544 handleComplexVfcRes = updateResourceFromYaml(oldComplexVfc, newComplexVfc, AuditingActionEnum.UPDATE_RESOURCE_METADATA,
2545 createdArtifacts, yamlContent, yamlName, csarInfo, newNodeTypesInfo, nodesArtifactsToHandle, nodeName, true);
2547 return handleComplexVfcRes;
2548 } catch (Exception e) {
2549 log.debug("Exception occured when handleComplexVfc, error is:{}", e.getMessage(), e);
2550 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2554 protected Resource updateResourceFromYaml(Resource oldRresource, Resource newRresource, AuditingActionEnum actionEnum,
2555 List<ArtifactDefinition> createdArtifacts, String yamlFileName, String yamlFileContent,
2556 CsarInfo csarInfo, Map<String, NodeTypeInfo> nodeTypesInfo,
2557 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2558 String nodeName, boolean isNested) {
2559 boolean inTransaction = true;
2560 boolean shouldLock = false;
2561 Resource preparedResource = null;
2562 ParsedToscaYamlInfo uploadComponentInstanceInfoMap = null;
2564 uploadComponentInstanceInfoMap = csarBusinessLogic
2565 .getParsedToscaYamlInfo(yamlFileContent, yamlFileName, nodeTypesInfo, csarInfo, nodeName, oldRresource);
2566 Map<String, UploadComponentInstanceInfo> instances = uploadComponentInstanceInfoMap.getInstances();
2567 if (MapUtils.isEmpty(instances) && newRresource.getResourceType() != ResourceTypeEnum.PNF) {
2568 throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlFileName);
2570 preparedResource = updateExistingResourceByImport(newRresource, oldRresource, csarInfo.getModifier(), inTransaction, shouldLock,
2572 log.trace("YAML topology file found in CSAR, file name: {}, contents: {}", yamlFileName, yamlFileContent);
2573 serviceImportParseLogic.handleResourceGenericType(preparedResource);
2574 handleNodeTypes(yamlFileName, preparedResource, yamlFileContent, shouldLock, nodeTypesArtifactsToHandle, createdArtifacts, nodeTypesInfo,
2575 csarInfo, nodeName);
2576 preparedResource = serviceImportParseLogic.createInputsOnResource(preparedResource, uploadComponentInstanceInfoMap.getInputs());
2577 preparedResource = createResourceInstances(yamlFileName, preparedResource, instances, csarInfo.getCreatedNodes());
2578 preparedResource = createResourceInstancesRelations(csarInfo.getModifier(), yamlFileName, preparedResource, instances);
2579 } catch (ComponentException e) {
2580 ResponseFormat responseFormat =
2581 e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
2582 log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat);
2584 .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum);
2586 } catch (StorageException e) {
2587 ResponseFormat responseFormat = componentsUtils
2588 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
2589 log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat);
2591 .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum);
2594 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic.validateUpdateVfGroupNames(
2595 uploadComponentInstanceInfoMap.getGroups(), preparedResource.getSystemName());
2596 if (validateUpdateVfGroupNamesRes.isRight()) {
2597 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
2599 Map<String, GroupDefinition> groups;
2600 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
2601 groups = validateUpdateVfGroupNamesRes.left().value();
2603 groups = uploadComponentInstanceInfoMap.getGroups();
2605 serviceImportParseLogic.handleGroupsProperties(preparedResource, groups);
2606 preparedResource = serviceImportParseLogic.updateGroupsOnResource(preparedResource, groups);
2607 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToHandle);
2608 Either<Resource, ResponseFormat> updateArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE,
2609 createdArtifacts, yamlFileName, csarInfo, preparedResource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
2610 if (updateArtifactsEither.isRight()) {
2611 log.debug("failed to update artifacts {}", updateArtifactsEither.right().value());
2612 throw new ComponentException(updateArtifactsEither.right().value());
2614 preparedResource = serviceImportParseLogic.getResourceWithGroups(updateArtifactsEither.left().value().getUniqueId());
2615 ActionStatus mergingPropsAndInputsStatus = resourceDataMergeBusinessLogic.mergeResourceEntities(oldRresource, preparedResource);
2616 if (mergingPropsAndInputsStatus != ActionStatus.OK) {
2617 ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(mergingPropsAndInputsStatus, preparedResource);
2618 throw new ComponentException(responseFormat);
2620 compositionBusinessLogic.setPositionsForComponentInstances(preparedResource, csarInfo.getModifier().getUserId());
2621 return preparedResource;
2624 protected Resource createResourceFromYaml(Resource resource, String topologyTemplateYaml, String yamlName,
2625 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
2626 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
2627 boolean shouldLock, boolean inTransaction, String nodeName) {
2628 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
2629 Resource createdResource;
2631 ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic
2632 .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, resource);
2633 if (MapUtils.isEmpty(parsedToscaYamlInfo.getInstances()) && resource.getResourceType() != ResourceTypeEnum.PNF) {
2634 throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2636 log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", resource.getName());
2637 createdResource = createResourceAndRIsFromYaml(yamlName, resource, parsedToscaYamlInfo, AuditingActionEnum.IMPORT_RESOURCE, false,
2638 createdArtifacts, topologyTemplateYaml, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName);
2639 log.debug("#createResourceFromYaml - The resource {} has been created ", resource.getName());
2640 } catch (ComponentException e) {
2641 ResponseFormat responseFormat =
2642 e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
2643 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
2645 } catch (StorageException e) {
2646 ResponseFormat responseFormat = componentsUtils
2647 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
2648 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
2651 return createdResource;
2654 protected Resource createResourceAndRIsFromYaml(String yamlName, Resource resource, ParsedToscaYamlInfo parsedToscaYamlInfo,
2655 AuditingActionEnum actionEnum, boolean isNormative, List<ArtifactDefinition> createdArtifacts,
2656 String topologyTemplateYaml, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
2657 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
2658 boolean shouldLock, boolean inTransaction, String nodeName) {
2659 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2661 Either<Boolean, ResponseFormat> lockResult = serviceBusinessLogic
2662 .lockComponentByName(resource.getSystemName(), resource, CREATE_RESOURCE);
2663 if (lockResult.isRight()) {
2664 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2665 throw new ComponentException(lockResult.right().value());
2667 log.debug("name is locked {} status = {}", resource.getSystemName(), lockResult);
2670 log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
2671 Resource genericResource = serviceBusinessLogic.fetchAndSetDerivedFromGenericType(resource);
2672 resource = createResourceTransaction(resource, csarInfo.getModifier(), isNormative);
2673 log.trace("************* Going to add inputs from yaml {}", yamlName);
2674 Map<String, Object> yamlMap = ImportUtils.loadYamlAsStrictMap(csarInfo.getMainTemplateContent());
2675 Map<String, Object> metadata = (Map<String, Object>) yamlMap.get("metadata");
2676 String type = (String) metadata.get("type");
2677 if (resource.shouldGenerateInputs() && !"Service".equalsIgnoreCase(type)) {
2678 serviceBusinessLogic.generateAndAddInputsFromGenericTypeProperties(resource, genericResource);
2680 Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
2681 resource = serviceImportParseLogic.createInputsOnResource(resource, inputs);
2682 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances();
2683 resource = createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap, topologyTemplateYaml,
2684 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName);
2685 log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName);
2686 // validate update vf module group names
2687 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic.validateUpdateVfGroupNames(
2688 parsedToscaYamlInfo.getGroups(), resource.getSystemName());
2689 if (validateUpdateVfGroupNamesRes.isRight()) {
2690 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2691 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
2693 Map<String, GroupDefinition> groups;
2694 log.trace("************* Going to add groups from yaml {}", yamlName);
2695 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
2696 groups = validateUpdateVfGroupNamesRes.left().value();
2698 groups = parsedToscaYamlInfo.getGroups();
2700 Either<Resource, ResponseFormat> createGroupsOnResource = createGroupsOnResource(resource, groups);
2701 if (createGroupsOnResource.isRight()) {
2702 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2703 throw new ComponentException(createGroupsOnResource.right().value());
2705 resource = createGroupsOnResource.left().value();
2706 log.trace("************* Going to add artifacts from yaml {}", yamlName);
2707 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
2708 Either<Resource, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
2709 createdArtifacts, yamlName, csarInfo, resource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
2710 if (createArtifactsEither.isRight()) {
2711 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2712 throw new ComponentException(createArtifactsEither.right().value());
2714 resource = serviceImportParseLogic.getResourceWithGroups(createArtifactsEither.left().value().getUniqueId());
2715 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.CREATED);
2716 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, actionEnum);
2717 ASDCKpiApi.countCreatedResourcesKPI();
2719 } catch (ComponentException | StorageException e) {
2720 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2723 if (!inTransaction) {
2724 janusGraphDao.commit();
2727 graphLockOperation.unlockComponentByName(resource.getSystemName(), resource.getUniqueId(), NodeTypeEnum.Resource);
2732 protected Either<Resource, ResponseFormat> createGroupsOnResource(Resource resource, Map<String, GroupDefinition> groups) {
2733 if (groups != null && !groups.isEmpty()) {
2734 List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, resource);
2735 serviceImportParseLogic.handleGroupsProperties(resource, groups);
2736 serviceImportParseLogic.fillGroupsFinalFields(groupsAsList);
2737 Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic.createGroups(resource, groupsAsList, true);
2738 if (createGroups.isRight()) {
2739 return Either.right(createGroups.right().value());
2742 return Either.left(resource);
2744 Either<Resource, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
2745 if (updatedResource.isRight()) {
2746 ResponseFormat responseFormat = componentsUtils
2747 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), resource);
2748 return Either.right(responseFormat);
2750 return Either.left(updatedResource.left().value());
2753 protected List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups, Resource component) {
2754 List<GroupDefinition> result = new ArrayList<>();
2755 List<ComponentInstance> componentInstances = component.getComponentInstances();
2756 if (groups != null) {
2757 for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
2758 String groupName = entry.getKey();
2759 GroupDefinition groupDefinition = entry.getValue();
2760 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
2761 updatedGroupDefinition.setMembers(null);
2762 Map<String, String> members = groupDefinition.getMembers();
2763 if (members != null) {
2764 updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
2766 result.add(updatedGroupDefinition);
2772 protected void updateGroupMembers(Map<String, GroupDefinition> groups, GroupDefinition updatedGroupDefinition, Resource component,
2773 List<ComponentInstance> componentInstances, String groupName, Map<String, String> members) {
2774 Set<String> compInstancesNames = members.keySet();
2775 if (CollectionUtils.isEmpty(componentInstances)) {
2776 String membersAstString = compInstancesNames.stream().collect(joining(","));
2777 log.debug("The members: {}, in group: {}, cannot be found in component {}. There are no component instances.", membersAstString,
2778 groupName, component.getNormalizedName());
2779 throw new ComponentException(componentsUtils
2780 .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(),
2781 serviceImportParseLogic.getComponentTypeForResponse(component)));
2783 Map<String, String> memberNames = componentInstances.stream().collect(toMap(ComponentInstance::getName, ComponentInstance::getUniqueId));
2784 memberNames.putAll(groups.keySet().stream().collect(toMap(g -> g, g -> "")));
2785 Map<String, String> relevantInstances = memberNames.entrySet().stream().filter(n -> compInstancesNames.contains(n.getKey()))
2786 .collect(toMap(Map.Entry::getKey, Map.Entry::getValue));
2787 if (relevantInstances == null || relevantInstances.size() != compInstancesNames.size()) {
2788 List<String> foundMembers = new ArrayList<>();
2789 if (relevantInstances != null) {
2790 foundMembers = relevantInstances.keySet().stream().collect(toList());
2792 compInstancesNames.removeAll(foundMembers);
2793 String membersAstString = compInstancesNames.stream().collect(joining(","));
2794 throw new ComponentException(componentsUtils
2795 .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(),
2796 serviceImportParseLogic.getComponentTypeForResponse(component)));
2798 updatedGroupDefinition.setMembers(relevantInstances);
2801 protected Resource createResourceTransaction(Resource resource, User user, boolean isNormative) {
2802 Either<Boolean, StorageOperationStatus> eitherValidation = toscaOperationFacade
2803 .validateComponentNameExists(resource.getName(), resource.getResourceType(), resource.getComponentType());
2804 if (eitherValidation.isRight()) {
2805 ResponseFormat errorResponse = componentsUtils
2806 .getResponseFormat(componentsUtils.convertFromStorageResponse(eitherValidation.right().value()));
2807 throw new ComponentException(errorResponse);
2809 if (Boolean.TRUE.equals(eitherValidation.left().value())) {
2810 log.debug("resource with name: {}, already exists", resource.getName());
2811 ResponseFormat errorResponse = componentsUtils
2812 .getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resource.getName());
2813 throw new ComponentException(errorResponse);
2815 log.debug("send resource {} to dao for create", resource.getName());
2816 serviceImportParseLogic.createArtifactsPlaceHolderData(resource, user);
2818 log.debug("enrich resource with creator, version and state");
2819 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2820 resource.setVersion(INITIAL_VERSION);
2821 resource.setHighestVersion(true);
2822 if (resource.getResourceType() != null && resource.getResourceType() != ResourceTypeEnum.VF) {
2823 resource.setAbstract(false);
2826 return toscaOperationFacade.createToscaComponent(resource).left()
2827 .on(r -> serviceImportParseLogic.throwComponentExceptionByResource(r, resource));
2830 protected ImmutablePair<Resource, ActionStatus> updateExistingResourceByImport(Resource newResource, Resource oldResource, User user,
2831 boolean inTransaction, boolean needLock, boolean isNested) {
2832 String lockedResourceId = oldResource.getUniqueId();
2833 log.debug("found resource: name={}, id={}, version={}, state={}", oldResource.getName(), lockedResourceId, oldResource.getVersion(),
2834 oldResource.getLifecycleState());
2835 ImmutablePair<Resource, ActionStatus> resourcePair = null;
2837 serviceBusinessLogic.lockComponent(lockedResourceId, oldResource, needLock, "Update Resource by Import");
2838 oldResource = serviceImportParseLogic.prepareResourceForUpdate(oldResource, newResource, user, inTransaction, false);
2839 serviceImportParseLogic.mergeOldResourceMetadataWithNew(oldResource, newResource);
2840 serviceImportParseLogic.validateResourceFieldsBeforeUpdate(oldResource, newResource, inTransaction, isNested);
2841 serviceImportParseLogic.validateCapabilityTypesCreate(user, serviceImportParseLogic.getCapabilityTypeOperation(), newResource,
2842 AuditingActionEnum.IMPORT_RESOURCE, inTransaction);
2843 createNewResourceToOldResource(newResource, oldResource, user);
2844 Either<Resource, StorageOperationStatus> overrideResource = toscaOperationFacade.overrideComponent(newResource, oldResource);
2845 if (overrideResource.isRight()) {
2846 ResponseFormat responseFormat = new ResponseFormat();
2847 serviceBusinessLogic.throwComponentException(responseFormat);
2849 log.debug("Resource updated successfully!!!");
2850 resourcePair = new ImmutablePair<>(overrideResource.left().value(), ActionStatus.OK);
2851 return resourcePair;
2853 if (resourcePair == null) {
2854 BeEcompErrorManager.getInstance().logBeSystemError("Change LifecycleState - Certify");
2855 janusGraphDao.rollback();
2856 } else if (!inTransaction) {
2857 janusGraphDao.commit();
2860 log.debug("unlock resource {}", lockedResourceId);
2861 graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource);
2866 protected void createNewResourceToOldResource(Resource newResource, Resource oldResource, User user) {
2867 newResource.setContactId(newResource.getContactId().toLowerCase());
2868 newResource.setCreatorUserId(user.getUserId());
2869 newResource.setCreatorFullName(user.getFullName());
2870 newResource.setLastUpdaterUserId(user.getUserId());
2871 newResource.setLastUpdaterFullName(user.getFullName());
2872 newResource.setUniqueId(oldResource.getUniqueId());
2873 newResource.setVersion(oldResource.getVersion());
2874 newResource.setInvariantUUID(oldResource.getInvariantUUID());
2875 newResource.setLifecycleState(oldResource.getLifecycleState());
2876 newResource.setUUID(oldResource.getUUID());
2877 newResource.setNormalizedName(oldResource.getNormalizedName());
2878 newResource.setSystemName(oldResource.getSystemName());
2879 if (oldResource.getCsarUUID() != null) {
2880 newResource.setCsarUUID(oldResource.getCsarUUID());
2882 if (oldResource.getCsarVersionId() != null) {
2883 newResource.setCsarVersionId(oldResource.getCsarVersionId());
2885 if (oldResource.getImportedToscaChecksum() != null) {
2886 newResource.setImportedToscaChecksum(oldResource.getImportedToscaChecksum());
2888 if (newResource.getDerivedFromGenericType() == null || newResource.getDerivedFromGenericType().isEmpty()) {
2889 newResource.setDerivedFromGenericType(oldResource.getDerivedFromGenericType());
2891 if (newResource.getDerivedFromGenericVersion() == null || newResource.getDerivedFromGenericVersion().isEmpty()) {
2892 newResource.setDerivedFromGenericVersion(oldResource.getDerivedFromGenericVersion());
2894 if (newResource.getToscaArtifacts() == null || newResource.getToscaArtifacts().isEmpty()) {
2895 serviceBusinessLogic.setToscaArtifactsPlaceHolders(newResource, user);
2897 if (newResource.getInterfaces() == null || newResource.getInterfaces().isEmpty()) {
2898 newResource.setInterfaces(oldResource.getInterfaces());
2900 if (CollectionUtils.isEmpty(newResource.getProperties())) {
2901 newResource.setProperties(oldResource.getProperties());
2903 if (newResource.getModel() == null) {
2904 newResource.setModel(oldResource.getModel());
2908 protected Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Service service, Map<String, Object> mappedToscaTemplate,
2910 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2911 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
2912 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
2914 Either<String, ImportUtils.ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
2915 TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
2916 if (toscaVersion.isRight()) {
2917 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
2919 Map<String, Object> mapToConvert = new HashMap<>();
2920 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value());
2921 Map<String, Object> nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate);
2922 createNodeTypes(yamlName, service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
2923 mapToConvert, nodeTypes);
2924 return csarInfo.getCreatedNodes();
2925 } catch (Exception e) {
2926 log.debug("Exception occured when createResourcesFromYamlNodeTypesList,error is:{}", e.getMessage(), e);
2927 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2931 protected void createNodeTypes(String yamlName, Service service, boolean needLock,
2932 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2933 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
2934 Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
2935 Iterator<Map.Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet().iterator();
2936 Resource vfcCreated = null;
2937 while (nodesNameValueIter.hasNext()) {
2938 Map.Entry<String, Object> nodeType = nodesNameValueIter.next();
2939 String nodeTypeKey = nodeType.getKey();
2940 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle =
2941 nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeTypeKey);
2942 if (nodeTypesInfo.containsKey(nodeTypeKey)) {
2943 vfcCreated = handleNestedVfc(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
2945 log.trace("************* Finished to handle nested vfc {}", nodeTypeKey);
2946 } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames()
2947 .containsKey(nodeTypeKey)) {
2948 ImmutablePair<Resource, ActionStatus> resourceCreated = serviceImportParseLogic
2949 .createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(), mapToConvert, service, needLock,
2950 nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true);
2951 log.debug("************* Finished to create node {}", nodeTypeKey);
2952 vfcCreated = resourceCreated.getLeft();
2953 csarInfo.getCreatedNodesToscaResourceNames().put(nodeTypeKey, vfcCreated.getName());
2955 if (vfcCreated != null) {
2956 csarInfo.getCreatedNodes().put(nodeTypeKey, vfcCreated);
2958 mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());