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 com.google.gson.JsonElement;
29 import com.google.gson.JsonObject;
30 import com.google.gson.JsonParser;
31 import fj.data.Either;
32 import java.util.ArrayList;
33 import java.util.Collection;
34 import java.util.Collections;
35 import java.util.EnumMap;
36 import java.util.HashMap;
37 import java.util.HashSet;
38 import java.util.Iterator;
39 import java.util.List;
41 import java.util.Map.Entry;
42 import java.util.Optional;
44 import java.util.concurrent.atomic.AtomicReference;
45 import java.util.regex.Pattern;
46 import java.util.stream.Collectors;
49 import org.apache.commons.collections.CollectionUtils;
50 import org.apache.commons.collections.MapUtils;
51 import org.apache.commons.lang3.StringUtils;
52 import org.apache.commons.lang3.tuple.ImmutablePair;
53 import org.json.simple.JSONObject;
54 import org.openecomp.sdc.be.components.csar.CsarArtifactsAndGroupsBusinessLogic;
55 import org.openecomp.sdc.be.components.csar.CsarBusinessLogic;
56 import org.openecomp.sdc.be.components.csar.CsarInfo;
57 import org.openecomp.sdc.be.components.csar.ServiceCsarInfo;
58 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
59 import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
60 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
61 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
62 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
63 import org.openecomp.sdc.be.components.impl.utils.CINodeFilterUtils;
64 import org.openecomp.sdc.be.components.impl.utils.CreateServiceFromYamlParameter;
65 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
66 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
67 import org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic;
68 import org.openecomp.sdc.be.config.BeEcompErrorManager;
69 import org.openecomp.sdc.be.config.ConfigurationManager;
70 import org.openecomp.sdc.be.dao.api.ActionStatus;
71 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
72 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
73 import org.openecomp.sdc.be.datamodel.utils.ArtifactUtils;
74 import org.openecomp.sdc.be.datatypes.elements.ComponentInstanceDataDefinition;
75 import org.openecomp.sdc.be.datatypes.elements.CustomYamlFunction;
76 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
77 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
78 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
79 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
80 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
81 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
82 import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition;
83 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
84 import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterPropertyDataDefinition;
85 import org.openecomp.sdc.be.datatypes.elements.SubPropertyToscaFunction;
86 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
87 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
88 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
89 import org.openecomp.sdc.be.datatypes.tosca.ToscaGetFunctionType;
90 import org.openecomp.sdc.be.impl.ComponentsUtils;
91 import org.openecomp.sdc.be.info.NodeTypeInfoToUpdateArtifacts;
92 import org.openecomp.sdc.be.model.ArtifactDefinition;
93 import org.openecomp.sdc.be.model.AttributeDefinition;
94 import org.openecomp.sdc.be.model.CapabilityDefinition;
95 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
96 import org.openecomp.sdc.be.model.Component;
97 import org.openecomp.sdc.be.model.ComponentInstance;
98 import org.openecomp.sdc.be.model.ComponentInstanceInput;
99 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
100 import org.openecomp.sdc.be.model.ComponentParametersView;
101 import org.openecomp.sdc.be.model.DataTypeDefinition;
102 import org.openecomp.sdc.be.model.DistributionStatusEnum;
103 import org.openecomp.sdc.be.model.GroupDefinition;
104 import org.openecomp.sdc.be.model.InputDefinition;
105 import org.openecomp.sdc.be.model.InterfaceDefinition;
106 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
107 import org.openecomp.sdc.be.model.LifecycleStateEnum;
108 import org.openecomp.sdc.be.model.NodeTypeDefinition;
109 import org.openecomp.sdc.be.model.NodeTypeInfo;
110 import org.openecomp.sdc.be.model.NodeTypeMetadata;
111 import org.openecomp.sdc.be.model.NodeTypesMetadataList;
112 import org.openecomp.sdc.be.model.Operation;
113 import org.openecomp.sdc.be.model.OutputDefinition;
114 import org.openecomp.sdc.be.model.ParsedToscaYamlInfo;
115 import org.openecomp.sdc.be.model.PolicyDefinition;
116 import org.openecomp.sdc.be.model.PropertyDefinition;
117 import org.openecomp.sdc.be.model.RelationshipImpl;
118 import org.openecomp.sdc.be.model.RelationshipInfo;
119 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
120 import org.openecomp.sdc.be.model.RequirementDefinition;
121 import org.openecomp.sdc.be.model.Resource;
122 import org.openecomp.sdc.be.model.Service;
123 import org.openecomp.sdc.be.model.UploadAttributeInfo;
124 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
125 import org.openecomp.sdc.be.model.UploadInterfaceInfo;
126 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
127 import org.openecomp.sdc.be.model.UploadPropInfo;
128 import org.openecomp.sdc.be.model.UploadReqInfo;
129 import org.openecomp.sdc.be.model.UploadResourceInfo;
130 import org.openecomp.sdc.be.model.User;
131 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
132 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
133 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
134 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
135 import org.openecomp.sdc.be.model.operations.StorageException;
136 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
137 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
138 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
139 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
140 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
141 import org.openecomp.sdc.be.tosca.CsarUtils;
142 import org.openecomp.sdc.be.tosca.ToscaExportHandler;
143 import org.openecomp.sdc.be.ui.model.OperationUi;
144 import org.openecomp.sdc.be.utils.TypeUtils;
145 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
146 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
147 import org.openecomp.sdc.common.api.Constants;
148 import org.openecomp.sdc.common.datastructure.Wrapper;
149 import org.openecomp.sdc.common.kpi.api.ASDCKpiApi;
150 import org.openecomp.sdc.common.log.wrappers.Logger;
151 import org.openecomp.sdc.common.util.ValidationUtils;
152 import org.openecomp.sdc.exception.ResponseFormat;
153 import org.springframework.beans.factory.annotation.Autowired;
154 import org.yaml.snakeyaml.Yaml;
158 @org.springframework.stereotype.Component("serviceImportBusinessLogic")
159 public class ServiceImportBusinessLogic {
161 protected static final String CREATE_RESOURCE = "Create Resource";
162 private static final String INITIAL_VERSION = "0.1";
163 private static final String IN_RESOURCE = " in resource {} ";
164 private static final String COMPONENT_INSTANCE_WITH_NAME = "component instance with name ";
165 private static final String COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE = "component instance with name {} in resource {} ";
166 private static final String CERTIFICATION_ON_IMPORT = "certification on import";
167 private static final String VALIDATE_DERIVED_BEFORE_UPDATE = "validate derived before update";
168 private static final String PLACE_HOLDER_RESOURCE_TYPES = "validForResourceTypes";
169 private static final String CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES = "Create Resource - validateCapabilityTypesCreate";
170 private static final String CATEGORY_IS_EMPTY = "Resource category is empty";
171 private static final Logger log = Logger.getLogger(ServiceImportBusinessLogic.class);
173 private final ComponentsUtils componentsUtils;
174 private final ToscaOperationFacade toscaOperationFacade;
175 private final ServiceBusinessLogic serviceBusinessLogic;
176 private final CsarBusinessLogic csarBusinessLogic;
177 private final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic;
178 private final LifecycleBusinessLogic lifecycleBusinessLogic;
179 private final CompositionBusinessLogic compositionBusinessLogic;
180 private final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic;
181 private final ServiceImportParseLogic serviceImportParseLogic;
182 private final GroupBusinessLogic groupBusinessLogic;
183 private final PolicyBusinessLogic policyBusinessLogic;
184 private final ResourceImportManager resourceImportManager;
185 private final JanusGraphDao janusGraphDao;
186 private final ArtifactsBusinessLogic artifactsBusinessLogic;
187 private final IGraphLockOperation graphLockOperation;
188 private final ToscaFunctionService toscaFunctionService;
189 private final DataTypeBusinessLogic dataTypeBusinessLogic;
190 private ApplicationDataTypeCache applicationDataTypeCache;
192 public ServiceImportBusinessLogic(final GroupBusinessLogic groupBusinessLogic, final ArtifactsBusinessLogic artifactsBusinessLogic,
193 final ComponentsUtils componentsUtils, final ToscaOperationFacade toscaOperationFacade,
194 final ServiceBusinessLogic serviceBusinessLogic, final CsarBusinessLogic csarBusinessLogic,
195 final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic,
196 final LifecycleBusinessLogic lifecycleBusinessLogic, final CompositionBusinessLogic compositionBusinessLogic,
197 final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic,
198 final ServiceImportParseLogic serviceImportParseLogic, final PolicyBusinessLogic policyBusinessLogic,
199 final ResourceImportManager resourceImportManager, final JanusGraphDao janusGraphDao,
200 final IGraphLockOperation graphLockOperation, final ToscaFunctionService toscaFunctionService,
201 final DataTypeBusinessLogic dataTypeBusinessLogic) {
202 this.componentsUtils = componentsUtils;
203 this.toscaOperationFacade = toscaOperationFacade;
204 this.serviceBusinessLogic = serviceBusinessLogic;
205 this.csarBusinessLogic = csarBusinessLogic;
206 this.csarArtifactsAndGroupsBusinessLogic = csarArtifactsAndGroupsBusinessLogic;
207 this.lifecycleBusinessLogic = lifecycleBusinessLogic;
208 this.compositionBusinessLogic = compositionBusinessLogic;
209 this.resourceDataMergeBusinessLogic = resourceDataMergeBusinessLogic;
210 this.serviceImportParseLogic = serviceImportParseLogic;
211 this.groupBusinessLogic = groupBusinessLogic;
212 this.policyBusinessLogic = policyBusinessLogic;
213 this.resourceImportManager = resourceImportManager;
214 this.janusGraphDao = janusGraphDao;
215 this.artifactsBusinessLogic = artifactsBusinessLogic;
216 this.graphLockOperation = graphLockOperation;
217 this.toscaFunctionService = toscaFunctionService;
218 this.dataTypeBusinessLogic = dataTypeBusinessLogic;
222 public void setApplicationDataTypeCache(ApplicationDataTypeCache applicationDataTypeCache) {
223 this.applicationDataTypeCache = applicationDataTypeCache;
226 public Service createService(Service service, AuditingActionEnum auditingAction, User user, Map<String, byte[]> csarUIPayload,
227 String payloadName) {
228 log.debug("enter createService");
229 service.setCreatorUserId(user.getUserId());
230 service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
231 service.setVersion(INITIAL_VERSION);
232 service.setConformanceLevel(ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel());
233 service.setDistributionStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
235 final var serviceBeforeCreate = serviceBusinessLogic.validateServiceBeforeCreate(service, user, auditingAction);
236 if (serviceBeforeCreate.isRight()) {
237 throw new ComponentException(ActionStatus.GENERAL_ERROR);
239 log.debug("enter createService,validateServiceBeforeCreate success");
240 String csarUUID = payloadName == null ? service.getCsarUUID() : payloadName;
241 log.debug("enter createService,get csarUUID:{}", csarUUID);
242 csarBusinessLogic.validateCsarBeforeCreate(service, csarUUID);
243 log.debug("CsarUUID is {} - going to create resource from CSAR", csarUUID);
244 return createServiceFromCsar(service, user, csarUIPayload, csarUUID);
245 } catch (final ComponentException e) {
246 log.debug("Exception occurred when createService: {}", e.getMessage(), e);
248 } catch (final Exception e) {
249 log.debug("Exception occurred when createService: {}", e.getMessage(), e);
250 throw new ComponentException(ActionStatus.GENERAL_ERROR);
254 protected Service createServiceFromCsar(Service service, User user, Map<String, byte[]> csarUIPayload, String csarUUID) {
255 log.trace("************* created successfully from YAML, resource TOSCA ");
257 ServiceCsarInfo csarInfo = csarBusinessLogic.getCsarInfo(service, null, user, csarUIPayload, csarUUID);
259 final Map<String, Object> dataTypesToCreate = getDatatypesToCreate(service.getModel(), csarInfo);
260 if (MapUtils.isNotEmpty(dataTypesToCreate)) {
261 dataTypeBusinessLogic.createDataTypeFromYaml(new Yaml().dump(dataTypesToCreate), service.getModel(), true);
262 dataTypesToCreate.entrySet().stream().forEach(createdOrUpdatedDataType -> {
263 applicationDataTypeCache.reload(service.getModel(), UniqueIdBuilder.buildDataTypeUid(service.getModel(), createdOrUpdatedDataType.getKey()));
266 final List<NodeTypeDefinition> nodeTypesToCreate = getNodeTypesToCreate(service.getModel(), csarInfo);
267 if (CollectionUtils.isNotEmpty(nodeTypesToCreate)) {
268 createNodeTypes(nodeTypesToCreate, service.getModel(), csarInfo.getModifier());
270 Map<String, NodeTypeInfo> nodeTypesInfo = csarInfo.extractTypesInfo();
271 Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandleRes = serviceImportParseLogic
272 .findNodeTypesArtifactsToHandle(nodeTypesInfo, csarInfo, service);
273 if (findNodeTypesArtifactsToHandleRes.isRight()) {
274 log.debug("failed to find node types for update with artifacts during import csar {}. ", csarInfo.getCsarUUID());
275 throw new ComponentException(findNodeTypesArtifactsToHandleRes.right().value());
277 return createServiceFromYaml(service, csarInfo.getMainTemplateContent(), csarInfo.getMainTemplateName(), nodeTypesInfo, csarInfo,
278 findNodeTypesArtifactsToHandleRes.left().value(), true, false, null, user.getUserId());
279 } catch (final ComponentException e) {
280 log.debug("Exception occurred when createServiceFromCsar,error is:{}", e.getMessage(), e);
282 } catch (final Exception e) {
283 log.debug("Exception occurred when createServiceFromCsar,error is:{}", e.getMessage(), e);
284 throw new ComponentException(ActionStatus.GENERAL_ERROR);
288 private Map<String, Object> getDatatypesToCreate(final String model, final CsarInfo csarInfo) {
289 final Map<String, Object> dataTypesToCreate = new HashMap<>();
291 for (final Entry<String, Object> dataTypeEntry : csarInfo.getDataTypes().entrySet()) {
292 final Either<DataTypeDefinition, JanusGraphOperationStatus> result = applicationDataTypeCache.get(model,
293 UniqueIdBuilder.buildDataTypeUid(model, dataTypeEntry.getKey()));
294 if (result.isRight() && result.right().value().equals(JanusGraphOperationStatus.NOT_FOUND)) {
295 dataTypesToCreate.put(dataTypeEntry.getKey(), dataTypeEntry.getValue());
296 log.info("Deploying unknown type " + dataTypeEntry.getKey() + " to model " + model + " from package " + csarInfo.getCsarUUID());
298 if (hasNewProperties(result, (Map<String, Map<String, Object>>) dataTypeEntry.getValue())) {
299 dataTypesToCreate.put(dataTypeEntry.getKey(), dataTypeEntry.getValue());
300 log.info("Deploying new version of type " + dataTypeEntry.getKey() + " to model " + model + " from package " + csarInfo.getCsarUUID());
303 return dataTypesToCreate;
306 private boolean hasNewProperties(final Either<DataTypeDefinition, JanusGraphOperationStatus> result, final Map<String, Map<String, Object>> dataType) {
307 return result.isLeft() && dataType.containsKey("properties") && result.left().value().getProperties() != null
308 && result.left().value().getProperties().size() != dataType.get("properties").size();
311 private void createNodeTypes(List<NodeTypeDefinition> nodeTypesToCreate, String model, User user) {
312 NodeTypesMetadataList nodeTypesMetadataList = new NodeTypesMetadataList();
313 List<NodeTypeMetadata> nodeTypeMetadataList = new ArrayList<>();
314 final Map<String, Object> allTypesToCreate = new HashMap<>();
315 nodeTypesToCreate.stream().forEach(nodeType -> {
316 allTypesToCreate.put(nodeType.getMappedNodeType().getKey(), nodeType.getMappedNodeType().getValue());
317 nodeTypeMetadataList.add(nodeType.getNodeTypeMetadata());
319 nodeTypesMetadataList.setNodeMetadataList(nodeTypeMetadataList);
320 resourceImportManager.importAllNormativeResource(allTypesToCreate, nodeTypesMetadataList, user, model,true, false);
323 private List<NodeTypeDefinition> getNodeTypesToCreate(final String model, final ServiceCsarInfo csarInfo) {
324 List<NodeTypeDefinition> namesOfNodeTypesToCreate = new ArrayList<>();
326 for (final NodeTypeDefinition nodeTypeDefinition : csarInfo.getNodeTypesUsed()) {
327 Either<Component, StorageOperationStatus> result = toscaOperationFacade
328 .getLatestByToscaResourceName(nodeTypeDefinition.getMappedNodeType().getKey(), model);
329 if (result.isRight() && result.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
330 namesOfNodeTypesToCreate.add(nodeTypeDefinition);
331 } else if (result.isLeft()) {
332 Resource latestResource = (Resource) result.left().value();
333 Entry<String, Object> latestMappedToscaTemplate = getResourceToscaTemplate(latestResource.getUniqueId(),
334 latestResource.getToscaArtifacts().get(ToscaExportHandler.ASSET_TOSCA_TEMPLATE), csarInfo.getModifier().getUserId());
335 Map<String, Object> mappedToscaTemplate = (Map<String, Object>) nodeTypeDefinition.getMappedNodeType().getValue();
336 Map<String, Object> newMappedToscaTemplate =
337 getNewChangesToToscaTemplate(mappedToscaTemplate, (Map<String, Object>) latestMappedToscaTemplate.getValue());
338 if (!newMappedToscaTemplate.equals(latestMappedToscaTemplate.getValue())) {
339 latestMappedToscaTemplate.setValue(newMappedToscaTemplate);
340 nodeTypeDefinition.setMappedNodeType(latestMappedToscaTemplate);
341 namesOfNodeTypesToCreate.add(nodeTypeDefinition);
345 return namesOfNodeTypesToCreate;
348 private Entry<String, Object> getResourceToscaTemplate(String uniqueId, ArtifactDefinition assetToscaTemplate, String userId) {
349 String assetToToscaTemplate = assetToscaTemplate.getUniqueId();
350 ImmutablePair<String, byte[]> toscaTemplate = artifactsBusinessLogic.
351 handleDownloadRequestById(uniqueId, assetToToscaTemplate, userId, ComponentTypeEnum.RESOURCE, null, null);
352 Map<String, Object> mappedToscaTemplate = new Yaml().load(new String(toscaTemplate.right));
353 Either<Map<String, Object>, ImportUtils.ResultStatusEnum> eitherNodeTypes =
354 findFirstToscaMapElement(mappedToscaTemplate, TypeUtils.ToscaTagNamesEnum.NODE_TYPES);
355 if (eitherNodeTypes.isRight()) {
356 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
358 Entry<String, Object> entry = eitherNodeTypes.left().value().entrySet().iterator().next();
362 private Map<String, Object> getNewChangesToToscaTemplate(Map<String, Object> mappedToscaTemplate, Map<String, Object> latestMappedToscaTemplate) {
363 Map<String, Object> newMappedToscaTemplate = new HashMap<>(latestMappedToscaTemplate);
365 Map<String, Object> properties = (Map<String, Object>) mappedToscaTemplate.get("properties");
366 Map<String, Object> latestProperties = (Map<String, Object>) latestMappedToscaTemplate.get("properties");
367 Map<String, Object> allProperties = combinedEntries(properties, latestProperties);
368 if ((MapUtils.isEmpty(latestProperties) && MapUtils.isNotEmpty(allProperties)) ||
369 (MapUtils.isNotEmpty(latestProperties) && !allProperties.equals(latestProperties))) {
370 newMappedToscaTemplate.put("properties", allProperties);
372 return newMappedToscaTemplate;
375 private Map<String, Object> combinedEntries(Map<String, Object> firstMap, Map<String, Object> secondMap) {
376 if (MapUtils.isEmpty(firstMap)) {
377 firstMap = new HashMap<>();
379 Map<String, Object> combinedEntries = new HashMap<>(firstMap);
380 if (MapUtils.isEmpty(secondMap)) {
381 return combinedEntries;
383 combinedEntries.putAll(secondMap);
384 return combinedEntries;
387 protected Service createServiceFromYaml(Service service, String topologyTemplateYaml, String yamlName, Map<String, NodeTypeInfo> nodeTypesInfo,
389 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
390 boolean shouldLock, boolean inTransaction, String nodeName, final String userId)
391 throws BusinessLogicException {
392 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
393 Service createdService;
394 CreateServiceFromYamlParameter csfyp = new CreateServiceFromYamlParameter();
396 ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic
397 .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, service);
398 log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", service.getName());
399 csfyp.setYamlName(yamlName);
400 csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
401 csfyp.setCreatedArtifacts(createdArtifacts);
402 csfyp.setTopologyTemplateYaml(topologyTemplateYaml);
403 csfyp.setNodeTypesInfo(nodeTypesInfo);
404 csfyp.setCsarInfo(csarInfo);
405 csfyp.setNodeName(nodeName);
406 createdService = createServiceAndRIsFromYaml(service, false, nodeTypesArtifactsToCreate, shouldLock, inTransaction, csfyp, userId);
407 log.debug("#createResourceFromYaml - The resource {} has been created ", service.getName());
408 } catch (ComponentException | BusinessLogicException e) {
409 log.debug("Create Service from yaml failed", e);
411 } catch (StorageException e) {
412 log.debug("create Service From Yaml failed,get StorageException:{}", e);
415 return createdService;
418 protected Service createServiceAndRIsFromYaml(Service service, boolean isNormative,
419 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
420 boolean shouldLock, boolean inTransaction, CreateServiceFromYamlParameter csfyp,
422 throws BusinessLogicException {
423 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
424 String yamlName = csfyp.getYamlName();
425 ParsedToscaYamlInfo parsedToscaYamlInfo = csfyp.getParsedToscaYamlInfo();
426 List<ArtifactDefinition> createdArtifacts = csfyp.getCreatedArtifacts();
427 String topologyTemplateYaml = csfyp.getTopologyTemplateYaml();
428 Map<String, NodeTypeInfo> nodeTypesInfo = csfyp.getNodeTypesInfo();
429 CsarInfo csarInfo = csfyp.getCsarInfo();
430 String nodeName = csfyp.getNodeName();
432 Either<Boolean, ResponseFormat> lockResult = serviceBusinessLogic.lockComponentByName(service.getSystemName(), service, CREATE_RESOURCE);
433 if (lockResult.isRight()) {
434 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
435 throw new ComponentException(lockResult.right().value());
437 log.debug("name is locked {} status = {}", service.getSystemName(), lockResult);
439 boolean rollback = false;
441 log.trace("************* Adding properties to service from interface yaml {}", yamlName);
442 Map<String, PropertyDefinition> properties = parsedToscaYamlInfo.getProperties();
443 if (properties != null && !properties.isEmpty()) {
444 final List<PropertyDefinition> propertiesList = new ArrayList<>();
445 properties.forEach((propertyName, propertyDefinition) -> {
446 propertyDefinition.setName(propertyName);
447 propertiesList.add(propertyDefinition);
449 service.setProperties(propertiesList);
451 log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
452 service = serviceImportParseLogic.createServiceTransaction(service, csarInfo.getModifier(), isNormative);
453 log.trace("************* Going to add inputs from yaml {}", yamlName);
454 Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
455 service = serviceImportParseLogic.createInputsOnService(service, inputs);
456 log.trace("************* Finished to add inputs from yaml {}", yamlName);
457 ListDataDefinition<SubstitutionFilterPropertyDataDefinition> substitutionFilterProperties = parsedToscaYamlInfo.getSubstitutionFilterProperties();
458 service = serviceImportParseLogic.createSubstitutionFilterOnService(service, substitutionFilterProperties);
459 log.trace("************* Added Substitution filter from interface yaml {}", yamlName);
460 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances();
461 log.trace("************* Going to create nodes, RI's and Relations from yaml {}", yamlName);
462 service = createRIAndRelationsFromYaml(yamlName, service, uploadComponentInstanceInfoMap, topologyTemplateYaml,
463 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName);
464 log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName);
465 log.trace("************* Going to add outputs from yaml {}", yamlName);
466 Map<String, OutputDefinition> outputs = parsedToscaYamlInfo.getOutputs();
467 service = serviceImportParseLogic.createOutputsOnService(service, outputs, userId);
468 log.trace("************* Finished to add outputs from yaml {}", yamlName);
470 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes
471 = groupBusinessLogic.validateUpdateVfGroupNames(parsedToscaYamlInfo.getGroups(), service.getSystemName());
472 if (validateUpdateVfGroupNamesRes.isRight()) {
473 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
474 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
476 Map<String, GroupDefinition> groups;
477 log.trace("************* Going to add groups from yaml {}", yamlName);
478 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
479 groups = validateUpdateVfGroupNamesRes.left().value();
481 groups = parsedToscaYamlInfo.getGroups();
483 Either<Service, ResponseFormat> createGroupsOnResource = createGroupsOnResource(service, groups);
484 if (createGroupsOnResource.isRight()) {
485 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
486 throw new ComponentException(createGroupsOnResource.right().value());
488 service = createGroupsOnResource.left().value();
490 Either<Service, ResponseFormat> createPoliciesOnResource = createPoliciesOnResource(service, parsedToscaYamlInfo.getPolicies());
491 if (createPoliciesOnResource.isRight()) {
492 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
493 throw new ComponentException(createPoliciesOnResource.right().value());
495 service = createPoliciesOnResource.left().value();
496 log.trace("************* Going to add artifacts from yaml {}", yamlName);
497 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
498 Either<Service, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
499 createdArtifacts, yamlName, csarInfo, service, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
500 if (createArtifactsEither.isRight()) {
501 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
502 throw new ComponentException(createArtifactsEither.right().value());
504 service = serviceImportParseLogic.getServiceWithGroups(createArtifactsEither.left().value().getUniqueId());
505 service = updateInputs(service, userId);
507 ASDCKpiApi.countCreatedResourcesKPI();
509 } catch (ComponentException | StorageException | BusinessLogicException e) {
511 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
514 if (!inTransaction) {
516 janusGraphDao.rollback();
518 janusGraphDao.commit();
522 graphLockOperation.unlockComponentByName(service.getSystemName(), service.getUniqueId(), NodeTypeEnum.Resource);
527 private Service updateInputs(final Service component, final String userId) {
528 final List<InputDefinition> inputs = component.getInputs();
529 final List<ComponentInstance> componentInstances = component.getComponentInstances();
530 final String componentUniqueId = component.getUniqueId();
531 final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = component.getComponentInstancesProperties();
532 for (final InputDefinition input : inputs) {
533 if (isInputFromComponentInstanceProperty(input.getName(), componentInstances, componentInstancesProperties)) {
534 associateInputToComponentInstanceProperty(userId, input, componentInstances, componentInstancesProperties,
537 associateInputToServiceProperty(userId, input, component);
542 final Either<List<InputDefinition>, StorageOperationStatus> either
543 = toscaOperationFacade.updateInputsToComponent(inputs, componentUniqueId);
544 if (either.isRight()) {
545 throw new ComponentException(ActionStatus.GENERAL_ERROR);
551 private boolean isInputFromComponentInstanceProperty(final String inputName, final List<ComponentInstance> componentInstances,
552 final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties) {
553 if (CollectionUtils.isNotEmpty(componentInstances)) {
554 // get instance's names
555 final List<String> componentInstancesNames = componentInstances.stream().map(ComponentInstanceDataDefinition::getNormalizedName)
557 final Optional<String> componentInstancesNameOptional = componentInstancesNames.stream()
558 .filter(cin -> inputName.startsWith(cin + "_")).findFirst();
559 if (componentInstancesNameOptional.isPresent() && MapUtils.isNotEmpty(componentInstancesProperties)) {
560 final Optional<String> componentInstanceIdOptional = componentInstancesProperties.keySet().stream()
561 .filter(key -> key.endsWith("." + componentInstancesNameOptional.get())).findFirst();
562 if (componentInstanceIdOptional.isPresent()) {
563 // get property's name
564 final String propertyNameFromInput = extractPropertyNameFromInputName(inputName, componentInstancesNames);
565 return componentInstancesProperties.get(componentInstanceIdOptional.get()).stream()
566 .anyMatch(prop -> prop.getName().equals(propertyNameFromInput) && prop.getValue() != null
567 && prop.getValue().contains(ToscaGetFunctionType.GET_INPUT.getFunctionName()));
574 private void associateInputToComponentInstanceProperty(final String userId, final InputDefinition input,
575 final List<ComponentInstance> componentInstances,
576 final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties,
577 String componentUniqueId) {
579 final List<String> componentInstancesNames = componentInstances.stream().map(ComponentInstanceDataDefinition::getNormalizedName)
581 final String propertyNameFromInput = extractPropertyNameFromInputName(input.getName(), componentInstancesNames);
583 final Optional<String> componentInstancesNameOptional = componentInstancesNames.stream()
584 .filter(cin -> input.getName().startsWith(cin + "_")).findFirst();
586 final Optional<String> componentInstanceIdOptional = componentInstancesProperties.keySet().stream()
587 .filter(key -> key.endsWith("." + componentInstancesNameOptional.get())).findFirst();
589 final String componentInstanceId = componentInstanceIdOptional.get();
590 final List<ComponentInstanceProperty> componentInstanceProperties = componentInstancesProperties.get(componentInstanceId);
592 final ComponentInstanceProperty componentInstanceProperty = componentInstanceProperties.stream()
593 .filter(prop -> prop.getName().equals(propertyNameFromInput) && prop.getValue() != null
594 && prop.getValue().contains(ToscaGetFunctionType.GET_INPUT.getFunctionName())).findFirst().get();
597 updateInput(input, componentInstanceProperty, userId, componentInstanceId);
599 final Either<Map<String, List<ComponentInstanceProperty>>, StorageOperationStatus> either =
600 toscaOperationFacade.updateComponentInstancePropsToComponent(Collections.singletonMap(componentInstanceId,
601 Collections.singletonList(componentInstanceProperty)), componentUniqueId);
602 if (either.isRight()) {
603 throw new ComponentException(ActionStatus.GENERAL_ERROR);
607 private void associateInputToServiceProperty(final String userId,
608 final InputDefinition input, final Service component) {
609 final List<PropertyDefinition> properties = component.getProperties();
610 if (CollectionUtils.isNotEmpty(properties)) {
611 final String propertyNameFromInput = input.getName();
612 final Optional<PropertyDefinition> propDefOptional = properties.stream().filter(prop -> prop.getName().equals(propertyNameFromInput))
614 if (propDefOptional.isPresent()) {
616 final String componentUniqueId = component.getUniqueId();
617 final PropertyDefinition propertyDefinition = propDefOptional.get();
618 updateProperty(propertyDefinition, input, componentUniqueId);
619 final JSONObject jsonObject = new JSONObject();
620 jsonObject.put(ToscaGetFunctionType.GET_INPUT.getFunctionName(), input.getName());
621 propertyDefinition.setValue(jsonObject.toJSONString());
622 updateInput(input, propertyDefinition, userId, componentUniqueId);
624 final Either<PropertyDefinition, StorageOperationStatus> either
625 = toscaOperationFacade.updatePropertyOfComponent(component, propertyDefinition);
626 if (either.isRight()) {
627 throw new ComponentException(ActionStatus.GENERAL_ERROR);
633 private void updateProperty(final PropertyDefinition propertyDefinition, final InputDefinition input, final String componentUniqueId) {
634 propertyDefinition.setParentUniqueId(componentUniqueId);
635 final GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
636 getInputValueDataDefinition.setInputId(input.getUniqueId());
637 getInputValueDataDefinition.setInputName(input.getName());
638 getInputValueDataDefinition.setPropName(propertyDefinition.getName());
639 propertyDefinition.setGetInputValues(Collections.singletonList(getInputValueDataDefinition));
642 private void updateInput(final InputDefinition input, final PropertyDefinition propertyDefinition,
643 final String userId, final String componentUniqueId) {
644 input.setProperties(Collections.singletonList(new ComponentInstanceProperty(propertyDefinition)));
645 input.setInstanceUniqueId(componentUniqueId);
646 input.setOwnerId(userId);
647 input.setPropertyId(propertyDefinition.getUniqueId());
648 input.setParentPropertyType(propertyDefinition.getType());
651 private String extractPropertyNameFromInputName(final String inputName, final List<String> componentInstancesNames) {
652 final AtomicReference<String> result = new AtomicReference<>(inputName);
653 componentInstancesNames.forEach(cin -> result.set(result.get().replace(cin + "_", "")));
657 protected Either<Resource, ResponseFormat> createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum operation,
658 List<ArtifactDefinition> createdArtifacts, String yamlFileName,
659 CsarInfo csarInfo, Resource preparedResource,
660 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
661 boolean inTransaction, boolean shouldLock) {
662 String nodeName = nodeTypeInfoToUpdateArtifacts.getNodeName();
663 Resource resource = preparedResource;
664 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = nodeTypeInfoToUpdateArtifacts
665 .getNodeTypesArtifactsToHandle();
666 if (preparedResource.getResourceType() == ResourceTypeEnum.VF) {
667 if (nodeName != null && nodeTypesArtifactsToHandle.get(nodeName) != null && !nodeTypesArtifactsToHandle.get(nodeName).isEmpty()) {
668 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = handleNodeTypeArtifacts(preparedResource,
669 nodeTypesArtifactsToHandle.get(nodeName), createdArtifacts, csarInfo.getModifier(), inTransaction, true);
670 if (handleNodeTypeArtifactsRes.isRight()) {
671 return Either.right(handleNodeTypeArtifactsRes.right().value());
675 Either<Resource, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedResource, csarInfo, createdArtifacts,
676 new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction);
677 log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
678 if (createdCsarArtifactsEither.isRight()) {
679 return createdCsarArtifactsEither;
681 resource = createdCsarArtifactsEither.left().value();
683 return Either.left(resource);
686 protected Either<Resource, ResponseFormat> handleVfCsarArtifacts(Resource resource, CsarInfo csarInfo, List<ArtifactDefinition> createdArtifacts,
687 ArtifactOperationInfo artifactOperation, boolean shouldLock,
688 boolean inTransaction) {
689 if (csarInfo.getCsar() != null) {
690 createOrUpdateSingleNonMetaArtifactToComstants(resource, csarInfo, artifactOperation, shouldLock, inTransaction);
691 Either<Resource, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, resource, createdArtifacts, shouldLock,
692 inTransaction, artifactOperation);
693 if (eitherCreateResult.isRight()) {
694 return Either.right(eitherCreateResult.right().value());
696 Either<Resource, StorageOperationStatus> eitherGerResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
697 if (eitherGerResource.isRight()) {
698 ResponseFormat responseFormat = componentsUtils
699 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), resource);
700 return Either.right(responseFormat);
702 resource = eitherGerResource.left().value();
703 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
704 .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
705 if (artifacsMetaCsarStatus.isLeft()) {
706 return getResourceResponseFormatEither(resource, csarInfo, createdArtifacts, artifactOperation, shouldLock, inTransaction,
707 artifacsMetaCsarStatus);
709 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(resource, csarInfo, shouldLock, inTransaction);
712 return Either.left(resource);
715 protected void createOrUpdateSingleNonMetaArtifactToComstants(Resource resource, CsarInfo csarInfo, ArtifactOperationInfo artifactOperation,
716 boolean shouldLock, boolean inTransaction) {
717 String vendorLicenseModelId = null;
718 String vfLicenseModelId = null;
719 if (artifactOperation.getArtifactOperationEnum() == ArtifactOperationEnum.UPDATE) {
720 Map<String, ArtifactDefinition> deploymentArtifactsMap = resource.getDeploymentArtifacts();
721 if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
722 for (Map.Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
723 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
724 vendorLicenseModelId = artifactEntry.getValue().getUniqueId();
726 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
727 vfLicenseModelId = artifactEntry.getValue().getUniqueId();
732 createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL,
733 Constants.VENDOR_LICENSE_MODEL, ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
734 Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME, Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId,
735 artifactOperation, null, true, shouldLock, inTransaction);
736 createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
737 ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL, Constants.VF_LICENSE_DISPLAY_NAME,
738 Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId, artifactOperation, null, true, shouldLock, inTransaction);
741 private Either<Resource, ResponseFormat> getResourceResponseFormatEither(Resource resource, CsarInfo csarInfo,
742 List<ArtifactDefinition> createdArtifacts,
743 ArtifactOperationInfo artifactOperation, boolean shouldLock,
744 boolean inTransaction,
745 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus) {
747 String artifactsFileName = artifacsMetaCsarStatus.left().value().getKey();
748 String artifactsContents = artifacsMetaCsarStatus.left().value().getValue();
749 Either<Resource, ResponseFormat> createArtifactsFromCsar;
750 if (ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
751 createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic
752 .createResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts);
754 Either<Component, ResponseFormat> result = csarArtifactsAndGroupsBusinessLogic
755 .updateResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
757 if ((result.left().value() instanceof Resource) && result.isLeft()) {
758 Resource service1 = (Resource) result.left().value();
759 createArtifactsFromCsar = Either.left(service1);
761 createArtifactsFromCsar = Either.right(result.right().value());
764 if (createArtifactsFromCsar.isRight()) {
765 log.debug("Couldn't create artifacts from artifacts.meta");
766 return Either.right(createArtifactsFromCsar.right().value());
768 return Either.left(createArtifactsFromCsar.left().value());
769 } catch (Exception e) {
770 log.debug("Exception occured in getResourceResponseFormatEither, message:{}", e.getMessage(), e);
771 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
775 private <T extends Component> Either<T, ResponseFormat> createOrUpdateNonMetaArtifactsComp(CsarInfo csarInfo, T component,
776 List<ArtifactDefinition> createdArtifacts,
777 boolean shouldLock, boolean inTransaction,
778 ArtifactOperationInfo artifactOperation) {
779 Either<T, ResponseFormat> resStatus = null;
780 Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
782 Either<List<CsarUtils.NonMetaArtifactInfo>, String> artifactPathAndNameList = getValidArtifactNames(csarInfo, collectedWarningMessages);
783 if (artifactPathAndNameList.isRight()) {
785 getComponentsUtils().getResponseFormatByArtifactId(ActionStatus.ARTIFACT_NAME_INVALID, artifactPathAndNameList.right().value()));
787 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = null;
788 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
789 vfCsarArtifactsToHandle = new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
790 vfCsarArtifactsToHandle.put(artifactOperation.getArtifactOperationEnum(), artifactPathAndNameList.left().value());
792 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandleRes = findVfCsarArtifactsToHandle(
793 component, artifactPathAndNameList.left().value(), csarInfo.getModifier());
794 if (findVfCsarArtifactsToHandleRes.isRight()) {
795 resStatus = Either.right(findVfCsarArtifactsToHandleRes.right().value());
797 if (resStatus == null) {
798 vfCsarArtifactsToHandle = findVfCsarArtifactsToHandleRes.left().value();
801 if (resStatus == null && vfCsarArtifactsToHandle != null) {
802 resStatus = processCsarArtifacts(csarInfo, component, createdArtifacts, shouldLock, inTransaction, resStatus,
803 vfCsarArtifactsToHandle);
805 if (resStatus == null) {
806 resStatus = Either.left(component);
808 } catch (Exception e) {
809 resStatus = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
810 log.debug("Exception occured in createNonMetaArtifacts, message:{}", e.getMessage(), e);
812 CsarUtils.handleWarningMessages(collectedWarningMessages);
817 protected Either<Resource, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Resource resource,
818 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
819 boolean inTransaction, ArtifactOperationInfo artifactOperation) {
820 return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation);
823 protected <T extends Component> Either<T, ResponseFormat> processCsarArtifacts(CsarInfo csarInfo, Component comp,
824 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
825 boolean inTransaction, Either<T, ResponseFormat> resStatus,
826 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle) {
827 for (Map.Entry<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> currArtifactOperationPair : vfCsarArtifactsToHandle
829 Optional<ResponseFormat> optionalCreateInDBError = currArtifactOperationPair.getValue().stream().map(
830 e -> createOrUpdateSingleNonMetaArtifact(comp, csarInfo, e.getPath(), e.getArtifactName(), e.getArtifactType(),
831 e.getArtifactGroupType(), e.getArtifactLabel(), e.getDisplayName(), CsarUtils.ARTIFACT_CREATED_FROM_CSAR, e.getArtifactUniqueId(),
832 new ArtifactOperationInfo(false, false, currArtifactOperationPair.getKey()), createdArtifacts, e.isFromCsar(), shouldLock,
833 inTransaction)).filter(Either::isRight).map(e -> e.right().value()).findAny();
834 if (optionalCreateInDBError.isPresent()) {
835 resStatus = Either.right(optionalCreateInDBError.get());
842 protected Either<Boolean, ResponseFormat> createOrUpdateSingleNonMetaArtifact(Component component, CsarInfo csarInfo, String artifactPath,
843 String artifactFileName, String artifactType,
844 ArtifactGroupTypeEnum artifactGroupType, String artifactLabel,
845 String artifactDisplayName, String artifactDescription,
846 String artifactId, ArtifactOperationInfo operation,
847 List<ArtifactDefinition> createdArtifacts, boolean isFromCsar,
848 boolean shouldLock, boolean inTransaction) {
849 byte[] artifactFileBytes = null;
850 if (csarInfo.getCsar().containsKey(artifactPath)) {
851 artifactFileBytes = csarInfo.getCsar().get(artifactPath);
853 Either<Boolean, ResponseFormat> result = Either.left(true);
854 if (operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE
855 || operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE) {
856 if (serviceImportParseLogic.isArtifactDeletionRequired(artifactId, artifactFileBytes, isFromCsar)) {
857 Either<ArtifactDefinition, ResponseFormat> handleDelete = artifactsBusinessLogic
858 .handleDelete(component.getUniqueId(), artifactId, csarInfo.getModifier(), component, shouldLock, inTransaction);
859 if (handleDelete.isRight()) {
860 result = Either.right(handleDelete.right().value());
864 if (org.apache.commons.lang.StringUtils.isEmpty(artifactId) && artifactFileBytes != null) {
865 operation = new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
868 if (artifactFileBytes != null) {
869 Map<String, Object> vendorLicenseModelJson = ArtifactUtils
870 .buildJsonForUpdateArtifact(artifactId, artifactFileName, artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
871 artifactDescription, artifactFileBytes, null, isFromCsar);
872 Either<Either<ArtifactDefinition, Operation>, ResponseFormat> eitherNonMetaArtifacts = csarArtifactsAndGroupsBusinessLogic
873 .createOrUpdateCsarArtifactFromJson(component, csarInfo.getModifier(), vendorLicenseModelJson, operation);
874 serviceImportParseLogic.addNonMetaCreatedArtifactsToSupportRollback(operation, createdArtifacts, eitherNonMetaArtifacts);
875 if (eitherNonMetaArtifacts.isRight()) {
876 BeEcompErrorManager.getInstance().logInternalFlowError("UploadLicenseArtifact",
877 "Failed to upload license artifact: " + artifactFileName + "With csar uuid: " + csarInfo.getCsarUUID(),
878 BeEcompErrorManager.ErrorSeverity.WARNING);
879 return Either.right(eitherNonMetaArtifacts.right().value());
885 private Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifacts(Resource nodeTypeResource,
886 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
887 List<ArtifactDefinition> createdArtifacts, User user,
888 boolean inTransaction, boolean ignoreLifecycleState) {
889 List<ArtifactDefinition> handleNodeTypeArtifactsRequestRes;
890 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = null;
891 Either<Resource, ResponseFormat> changeStateResponse;
893 changeStateResponse = checkoutResource(nodeTypeResource, user, inTransaction);
894 if (changeStateResponse.isRight()) {
895 return Either.right(changeStateResponse.right().value());
897 nodeTypeResource = changeStateResponse.left().value();
898 List<ArtifactDefinition> handledNodeTypeArtifacts = new ArrayList<>();
899 log.debug("************* Going to handle artifacts of node type resource {}. ", nodeTypeResource.getName());
900 for (Map.Entry<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> curOperationEntry : nodeTypeArtifactsToHandle
902 ArtifactsBusinessLogic.ArtifactOperationEnum curOperation = curOperationEntry.getKey();
903 List<ArtifactDefinition> curArtifactsToHandle = curOperationEntry.getValue();
904 if (curArtifactsToHandle != null && !curArtifactsToHandle.isEmpty()) {
905 log.debug("************* Going to {} artifact to vfc {}", curOperation.name(), nodeTypeResource.getName());
906 handleNodeTypeArtifactsRequestRes = artifactsBusinessLogic
907 .handleArtifactsRequestForInnerVfcComponent(curArtifactsToHandle, nodeTypeResource, user, createdArtifacts,
908 new ArtifactOperationInfo(false, ignoreLifecycleState, curOperation), false, inTransaction);
909 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(curOperation)) {
910 createdArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
912 handledNodeTypeArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
915 handleNodeTypeArtifactsRes = Either.left(handledNodeTypeArtifacts);
916 } catch (Exception e) {
917 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
918 handleNodeTypeArtifactsRes = Either.right(responseFormat);
919 log.debug("Exception occured when handleVfcArtifacts, error is:{}", e.getMessage(), e);
921 return handleNodeTypeArtifactsRes;
924 private Either<Resource, ResponseFormat> checkoutResource(Resource resource, User user, boolean inTransaction) {
925 Either<Resource, ResponseFormat> checkoutResourceRes;
927 if (!resource.getComponentMetadataDefinition().getMetadataDataDefinition().getState()
928 .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
929 Either<? extends Component, ResponseFormat> checkoutRes = lifecycleBusinessLogic
930 .changeComponentState(resource.getComponentType(), resource.getUniqueId(), user, LifeCycleTransitionEnum.CHECKOUT,
931 new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
932 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR), inTransaction, true);
933 if (checkoutRes.isRight()) {
934 checkoutResourceRes = Either.right(checkoutRes.right().value());
936 checkoutResourceRes = Either.left((Resource) checkoutRes.left().value());
939 checkoutResourceRes = Either.left(resource);
941 } catch (Exception e) {
942 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
943 checkoutResourceRes = Either.right(responseFormat);
944 log.debug("Exception occured when checkoutResource {} , error is:{}", resource.getName(), e.getMessage(), e);
946 return checkoutResourceRes;
949 protected Either<Service, ResponseFormat> createOrUpdateArtifacts(ArtifactOperationEnum operation, List<ArtifactDefinition> createdArtifacts,
950 String yamlFileName, CsarInfo csarInfo, Service preparedService,
951 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
952 boolean inTransaction, boolean shouldLock) {
953 Either<Service, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedService, csarInfo, createdArtifacts,
954 new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction);
955 log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
956 if (createdCsarArtifactsEither.isRight()) {
957 return createdCsarArtifactsEither;
959 return Either.left(createdCsarArtifactsEither.left().value());
962 protected Either<Service, ResponseFormat> handleVfCsarArtifacts(Service service, CsarInfo csarInfo, List<ArtifactDefinition> createdArtifacts,
963 ArtifactOperationInfo artifactOperation, boolean shouldLock,
964 boolean inTransaction) {
965 if (csarInfo.getCsar() != null) {
966 String vendorLicenseModelId = null;
967 String vfLicenseModelId = null;
968 if (artifactOperation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE) {
969 Map<String, ArtifactDefinition> deploymentArtifactsMap = service.getDeploymentArtifacts();
970 if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
971 for (Map.Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
972 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
973 vendorLicenseModelId = artifactEntry.getValue().getUniqueId();
975 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
976 vfLicenseModelId = artifactEntry.getValue().getUniqueId();
981 createOrUpdateSingleNonMetaArtifact(service, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL,
982 Constants.VENDOR_LICENSE_MODEL, ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
983 Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME, Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId,
984 artifactOperation, null, true, shouldLock, inTransaction);
985 createOrUpdateSingleNonMetaArtifact(service, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
986 ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL,
987 Constants.VF_LICENSE_DISPLAY_NAME, Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId, artifactOperation, null, true, shouldLock,
989 Either<Service, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, service, createdArtifacts, shouldLock,
990 inTransaction, artifactOperation);
991 if (eitherCreateResult.isRight()) {
992 return Either.right(eitherCreateResult.right().value());
994 Either<Service, StorageOperationStatus> eitherGerResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
995 if (eitherGerResource.isRight()) {
996 ResponseFormat responseFormat = componentsUtils
997 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), service,
998 ComponentTypeEnum.SERVICE);
999 return Either.right(responseFormat);
1001 service = eitherGerResource.left().value();
1002 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
1003 .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
1004 if (artifacsMetaCsarStatus.isLeft()) {
1005 String artifactsFileName = artifacsMetaCsarStatus.left().value().getKey();
1006 String artifactsContents = artifacsMetaCsarStatus.left().value().getValue();
1007 Either<Service, ResponseFormat> createArtifactsFromCsar;
1008 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
1009 createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic
1010 .createResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts);
1012 Either<Component, ResponseFormat> result = csarArtifactsAndGroupsBusinessLogic
1013 .updateResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
1015 if ((result.left().value() instanceof Service) && result.isLeft()) {
1016 Service service1 = (Service) result.left().value();
1017 createArtifactsFromCsar = Either.left(service1);
1019 createArtifactsFromCsar = Either.right(result.right().value());
1022 if (createArtifactsFromCsar.isRight()) {
1023 log.debug("Couldn't create artifacts from artifacts.meta");
1024 return Either.right(createArtifactsFromCsar.right().value());
1026 return Either.left(createArtifactsFromCsar.left().value());
1028 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(service, csarInfo, shouldLock, inTransaction);
1031 return Either.left(service);
1034 protected Either<Service, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Service resource,
1035 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
1036 boolean inTransaction, ArtifactOperationInfo artifactOperation) {
1037 return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation);
1040 protected Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandle(
1041 Component component, List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList, User user) {
1042 List<ArtifactDefinition> existingArtifacts = new ArrayList<>();
1043 if (component.getDeploymentArtifacts() != null && !component.getDeploymentArtifacts().isEmpty()) {
1044 existingArtifacts.addAll(component.getDeploymentArtifacts().values());
1046 if (component.getArtifacts() != null && !component.getArtifacts().isEmpty()) {
1047 existingArtifacts.addAll(component.getArtifacts().values());
1049 existingArtifacts = existingArtifacts.stream().filter(this::isNonMetaArtifact).collect(toList());
1050 List<String> artifactsToIgnore = new ArrayList<>();
1051 if (component.getGroups() != null) {
1052 component.getGroups().forEach(g -> {
1053 if (g.getArtifacts() != null && !g.getArtifacts().isEmpty()) {
1054 artifactsToIgnore.addAll(g.getArtifacts());
1058 existingArtifacts = existingArtifacts.stream().filter(a -> !artifactsToIgnore.contains(a.getUniqueId())).collect(toList());
1059 return organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifacts, component, user);
1062 private boolean isNonMetaArtifact(ArtifactDefinition artifact) {
1063 boolean result = true;
1064 if (artifact.getMandatory() || artifact.getArtifactName() == null || !isValidArtifactType(artifact)) {
1070 private boolean isValidArtifactType(ArtifactDefinition artifact) {
1071 final String artifactType = artifact.getArtifactType();
1072 return artifactType != null
1073 && !ArtifactTypeEnum.VENDOR_LICENSE.getType().equals(ArtifactTypeEnum.findType(artifactType))
1074 && !ArtifactTypeEnum.VF_LICENSE.getType().equals(ArtifactTypeEnum.findType(artifactType));
1077 protected Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> organizeVfCsarArtifactsByArtifactOperation(
1078 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList, List<ArtifactDefinition> existingArtifactsToHandle, Component component,
1080 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> nodeTypeArtifactsToHandle = new EnumMap<>(
1081 ArtifactsBusinessLogic.ArtifactOperationEnum.class);
1082 Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
1083 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> nodeTypeArtifactsToHandleRes = Either
1084 .left(nodeTypeArtifactsToHandle);
1086 List<CsarUtils.NonMetaArtifactInfo> artifactsToUpload = new ArrayList<>(artifactPathAndNameList);
1087 List<CsarUtils.NonMetaArtifactInfo> artifactsToUpdate = new ArrayList<>();
1088 List<CsarUtils.NonMetaArtifactInfo> artifactsToDelete = new ArrayList<>();
1089 for (CsarUtils.NonMetaArtifactInfo currNewArtifact : artifactPathAndNameList) {
1090 ArtifactDefinition foundArtifact;
1091 if (!existingArtifactsToHandle.isEmpty()) {
1092 foundArtifact = existingArtifactsToHandle.stream().filter(a -> a.getArtifactName().equals(currNewArtifact.getArtifactName()))
1093 .findFirst().orElse(null);
1094 if (foundArtifact != null) {
1095 if (ArtifactTypeEnum.findType(foundArtifact.getArtifactType()).equals(currNewArtifact.getArtifactType())) {
1096 if (!foundArtifact.getArtifactChecksum().equals(currNewArtifact.getArtifactChecksum())) {
1097 currNewArtifact.setArtifactUniqueId(foundArtifact.getUniqueId());
1098 artifactsToUpdate.add(currNewArtifact);
1100 existingArtifactsToHandle.remove(foundArtifact);
1101 artifactsToUpload.remove(currNewArtifact);
1103 log.debug("Can't upload two artifact with the same name {}.", currNewArtifact.getArtifactName());
1104 ResponseFormat responseFormat = ResponseFormatManager.getInstance()
1105 .getResponseFormat(ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, currNewArtifact.getArtifactName(),
1106 currNewArtifact.getArtifactType(), foundArtifact.getArtifactType());
1107 AuditingActionEnum auditingAction = artifactsBusinessLogic.detectAuditingType(
1108 new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE),
1109 foundArtifact.getArtifactChecksum());
1110 artifactsBusinessLogic.handleAuditing(auditingAction, component, component.getUniqueId(), user, null, null,
1111 foundArtifact.getUniqueId(), responseFormat, component.getComponentType(), null);
1112 responseWrapper.setInnerElement(responseFormat);
1118 if (responseWrapper.isEmpty()) {
1119 for (ArtifactDefinition currArtifact : existingArtifactsToHandle) {
1120 if (currArtifact.getIsFromCsar()) {
1121 artifactsToDelete.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
1122 ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null,
1123 currArtifact.getUniqueId(), currArtifact.getIsFromCsar()));
1125 artifactsToUpdate.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
1126 ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null,
1127 currArtifact.getUniqueId(), currArtifact.getIsFromCsar()));
1131 if (responseWrapper.isEmpty()) {
1132 if (!artifactsToUpload.isEmpty()) {
1133 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, artifactsToUpload);
1135 if (!artifactsToUpdate.isEmpty()) {
1136 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE, artifactsToUpdate);
1138 if (!artifactsToDelete.isEmpty()) {
1139 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE, artifactsToDelete);
1142 if (!responseWrapper.isEmpty()) {
1143 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
1145 } catch (Exception e) {
1146 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1147 responseWrapper.setInnerElement(responseFormat);
1148 log.debug("Exception occured when findNodeTypeArtifactsToHandle, error is:{}", e.getMessage(), e);
1149 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
1151 return nodeTypeArtifactsToHandleRes;
1154 protected Either<List<CsarUtils.NonMetaArtifactInfo>, String> getValidArtifactNames(CsarInfo csarInfo,
1155 Map<String, Set<List<String>>> collectedWarningMessages) {
1156 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = csarInfo.getCsar().entrySet().stream()
1157 .filter(e -> Pattern.compile(VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN).matcher(e.getKey()).matches())
1158 .map(e -> CsarUtils.validateNonMetaArtifact(e.getKey(), e.getValue(), collectedWarningMessages)).filter(Either::isLeft)
1159 .map(e -> e.left().value()).collect(toList());
1160 Pattern englishNumbersAndUnderScoresOnly = Pattern.compile(CsarUtils.VALID_ENGLISH_ARTIFACT_NAME);
1161 for (CsarUtils.NonMetaArtifactInfo nonMetaArtifactInfo : artifactPathAndNameList) {
1162 if (!englishNumbersAndUnderScoresOnly.matcher(nonMetaArtifactInfo.getDisplayName()).matches()) {
1163 return Either.right(nonMetaArtifactInfo.getArtifactName());
1166 return Either.left(artifactPathAndNameList);
1169 protected Either<Service, ResponseFormat> createGroupsOnResource(Service service, Map<String, GroupDefinition> groups) {
1170 if (groups != null && !groups.isEmpty()) {
1171 List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, service);
1172 serviceImportParseLogic.handleGroupsProperties(service, groups);
1173 serviceImportParseLogic.fillGroupsFinalFields(groupsAsList);
1174 Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic.createGroups(service, groupsAsList, true);
1175 if (createGroups.isRight()) {
1176 return Either.right(createGroups.right().value());
1179 return Either.left(service);
1181 return getServiceResponseFormatEither(service);
1184 private Either<Service, ResponseFormat> createPoliciesOnResource(final Service service,
1185 final Map<String, PolicyDefinition> policies) {
1186 if (MapUtils.isEmpty(policies)) {
1187 return Either.left(service);
1189 final Map<String, List<AttributeDefinition>> instanceAttributeMap =
1190 service.getComponentInstancesAttributes()
1191 .entrySet().stream()
1193 toMap(Entry::getKey,
1194 entry -> entry.getValue().stream().map(AttributeDefinition.class::cast).collect(toList()))
1196 policies.values().stream()
1197 .map(PolicyDataDefinition::getProperties)
1198 .flatMap(Collection::stream)
1199 .filter(PropertyDataDefinition::isToscaFunction)
1200 .forEach(policyDefinition ->
1201 toscaFunctionService
1202 .updateFunctionWithDataFromSelfComponent(policyDefinition.getToscaFunction(), service, service.getComponentInstancesProperties(),
1203 instanceAttributeMap)
1205 policyBusinessLogic.createPolicies(service, policies);
1206 return getServiceResponseFormatEither(service);
1209 private Either<Service, ResponseFormat> getServiceResponseFormatEither(Service service) {
1210 Either<Service, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
1211 if (updatedResource.isRight()) {
1212 ResponseFormat responseFormat = componentsUtils
1213 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), service,
1214 ComponentTypeEnum.SERVICE);
1215 return Either.right(responseFormat);
1217 return Either.left(updatedResource.left().value());
1220 protected List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups, Service component) {
1221 List<GroupDefinition> result = new ArrayList<>();
1222 List<ComponentInstance> componentInstances = component.getComponentInstances();
1223 if (groups != null) {
1224 for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
1225 String groupName = entry.getKey();
1226 GroupDefinition groupDefinition = entry.getValue();
1227 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
1228 updatedGroupDefinition.setMembers(null);
1229 Map<String, String> members = groupDefinition.getMembers();
1230 if (members != null) {
1231 serviceImportParseLogic.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
1233 result.add(updatedGroupDefinition);
1239 protected Resource createRIAndRelationsFromYaml(String yamlName, Resource resource,
1240 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap,
1241 String topologyTemplateYaml, List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1242 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1243 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
1246 log.debug("************* Going to create all nodes {}", yamlName);
1247 handleNodeTypes(yamlName, resource, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
1248 csarInfo, nodeName);
1249 log.debug("************* Going to create all resource instances {}", yamlName);
1250 resource = createResourceInstances(yamlName, resource, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes());
1251 log.debug("************* Finished to create all resource instances {}", yamlName);
1252 resource = createResourceInstancesRelations(csarInfo.getModifier(), yamlName, resource, uploadComponentInstanceInfoMap);
1253 log.debug("************* Going to create positions {}", yamlName);
1254 compositionBusinessLogic.setPositionsForComponentInstances(resource, csarInfo.getModifier().getUserId());
1255 log.debug("************* Finished to set positions {}", yamlName);
1257 } catch (Exception e) {
1258 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1262 protected Resource createResourceInstancesRelations(User user, String yamlName, Resource resource,
1263 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1264 log.debug("#createResourceInstancesRelations - Going to create relations ");
1265 List<ComponentInstance> componentInstancesList = resource.getComponentInstances();
1266 if (((MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)) &&
1267 resource.getResourceType() != ResourceTypeEnum.PNF)) { // PNF can have no resource instances
1268 log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
1269 resource.getUniqueId(), yamlName);
1270 BeEcompErrorManager.getInstance()
1271 .logInternalDataError("createResourceInstancesRelations", "No instances found in a resource or nn yaml template. ",
1272 BeEcompErrorManager.ErrorSeverity.ERROR);
1273 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName));
1275 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1276 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1277 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1278 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1279 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1280 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1281 Map<String, Resource> originCompMap = new HashMap<>();
1282 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1283 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1284 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1285 Map<String, Map<String, InterfaceDefinition>> instInterfaces = new HashMap<>();
1286 log.debug("enter ServiceImportBusinessLogic createResourceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. ");
1287 final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache;
1288 if (applicationDataTypeCache != null) {
1289 Resource finalResource = resource;
1290 uploadResInstancesMap.values().forEach(
1291 i -> processComponentInstance(yamlName, finalResource, componentInstancesList,
1292 componentsUtils.getAllDataTypes(applicationDataTypeCache, finalResource.getModel()), instProperties, instCapabilities,
1293 instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs, instNodeFilter,
1294 instInterfaces, i));
1296 serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, resource, instProperties);
1297 serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, resource, instInputs);
1298 serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts);
1299 serviceImportParseLogic.associateArtifactsToInstances(yamlName, resource, instArtifacts);
1300 serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements);
1301 serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes);
1302 resource = serviceImportParseLogic.getResourceAfterCreateRelations(resource);
1303 serviceImportParseLogic.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList, relations);
1304 serviceImportParseLogic.associateResourceInstances(yamlName, resource, relations);
1305 handleSubstitutionMappings(resource, uploadResInstancesMap);
1306 log.debug("************* in create relations, getResource start");
1307 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
1308 log.debug("************* in create relations, getResource end");
1309 if (eitherGetResource.isRight()) {
1310 throw new ComponentException(
1311 componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource));
1313 return eitherGetResource.left().value();
1316 protected void processProperty(Resource resource, Map<String, DataTypeDefinition> allDataTypes,
1317 Map<String, InputDefinition> currPropertiesMap, List<ComponentInstanceInput> instPropList,
1318 List<UploadPropInfo> propertyList) {
1319 UploadPropInfo propertyInfo = propertyList.get(0);
1320 String propName = propertyInfo.getName();
1321 if (!currPropertiesMap.containsKey(propName)) {
1322 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName));
1324 processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, resource.getInputs());
1327 private void processProperty(Map<String, DataTypeDefinition> allDataTypes, Map<String, InputDefinition> currPropertiesMap,
1328 List<ComponentInstanceInput> instPropList, UploadPropInfo propertyInfo, String propName,
1329 List<InputDefinition> inputs2) {
1330 InputDefinition curPropertyDef = currPropertiesMap.get(propName);
1331 ComponentInstanceInput property = null;
1332 String value = null;
1333 List<GetInputValueDataDefinition> getInputs = null;
1334 boolean isValidate = true;
1335 if (propertyInfo.getValue() != null) {
1336 getInputs = propertyInfo.getGet_input();
1337 isValidate = getInputs == null || getInputs.isEmpty();
1339 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
1341 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
1344 property = new ComponentInstanceInput(curPropertyDef, value, null);
1345 String validPropertyVAlue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
1346 property.setValue(validPropertyVAlue);
1347 if (isNotEmpty(getInputs)) {
1348 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1349 for (GetInputValueDataDefinition getInput : getInputs) {
1350 List<InputDefinition> inputs = inputs2;
1351 if (CollectionUtils.isEmpty(inputs)) {
1352 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1354 Optional<InputDefinition> optional = inputs.stream().filter(p -> p.getName().equals(getInput.getInputName())).findAny();
1355 if (!optional.isPresent()) {
1356 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1358 InputDefinition input = optional.get();
1359 getInput.setInputId(input.getUniqueId());
1360 getInputValues.add(getInput);
1361 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
1362 processGetInput(getInputValues, inputs, getInputIndex);
1364 property.setGetInputValues(getInputValues);
1366 instPropList.add(property);
1367 currPropertiesMap.remove(property.getName());
1370 protected void handleSubstitutionMappings(Resource resource, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1371 if (resource.getResourceType() == ResourceTypeEnum.VF) {
1372 Either<Resource, StorageOperationStatus> getResourceRes = toscaOperationFacade.getToscaFullElement(resource.getUniqueId());
1373 if (getResourceRes.isRight()) {
1374 ResponseFormat responseFormat = componentsUtils
1375 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource);
1376 throw new ComponentException(responseFormat);
1378 getResourceRes = updateCalculatedCapReqWithSubstitutionMappings(getResourceRes.left().value(), uploadResInstancesMap);
1379 if (getResourceRes.isRight()) {
1380 ResponseFormat responseFormat = componentsUtils
1381 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource);
1382 throw new ComponentException(responseFormat);
1387 protected Resource createResourceInstances(String yamlName, Resource resource, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1388 Map<String, Resource> nodeNamespaceMap) {
1389 Either<Resource, ResponseFormat> eitherResource = null;
1390 log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
1391 if (MapUtils.isEmpty(uploadResInstancesMap) && resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
1392 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
1393 throw new ComponentException(responseFormat);
1395 Map<String, Resource> existingNodeTypeMap = new HashMap<>();
1396 if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
1397 nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v));
1399 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1400 uploadResInstancesMap.values()
1401 .forEach(i -> createAndAddResourceInstance(i, yamlName, resource, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap));
1402 if (MapUtils.isNotEmpty(resourcesInstancesMap)) {
1404 toscaOperationFacade.associateComponentInstancesToComponent(resource, resourcesInstancesMap, false, false);
1405 } catch (StorageException exp) {
1406 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
1407 log.debug("Failed to add component instances to container component {}", resource.getName());
1408 ResponseFormat responseFormat = componentsUtils
1409 .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
1410 eitherResource = Either.right(responseFormat);
1411 throw new ByResponseFormatComponentException(eitherResource.right().value());
1415 log.debug("*************Going to get resource {}", resource.getUniqueId());
1416 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade
1417 .getToscaElement(resource.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter());
1418 log.debug("*************finished to get resource {}", resource.getUniqueId());
1419 if (eitherGetResource.isRight()) {
1420 ResponseFormat responseFormat = componentsUtils
1421 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource);
1422 throw new ComponentException(responseFormat);
1424 if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances()) &&
1425 resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
1426 log.debug("Error when create resource instance from csar. ComponentInstances list empty");
1427 BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty");
1428 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
1430 return eitherGetResource.left().value();
1433 protected void handleNodeTypes(String yamlName, Resource resource, String topologyTemplateYaml, boolean needLock,
1434 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1435 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1438 for (Map.Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
1439 if (nodeTypeEntry.getValue().isNested()) {
1440 handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1441 nodeTypeEntry.getKey());
1442 log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
1445 Map<String, Object> mappedToscaTemplate = null;
1446 if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo
1447 .containsKey(nodeName)) {
1448 mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
1450 if (MapUtils.isEmpty(mappedToscaTemplate)) {
1451 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
1453 createResourcesFromYamlNodeTypesList(yamlName, resource, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle,
1454 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
1455 } catch (ComponentException e) {
1456 ResponseFormat responseFormat =
1457 e.getResponseFormat() != null ? e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
1458 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
1460 } catch (StorageException e) {
1461 ResponseFormat responseFormat = componentsUtils
1462 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
1463 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
1465 } catch (Exception e) {
1466 log.debug("Exception occured when handleNodeTypes, error is:{}", e.getMessage(), e);
1467 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1471 protected Resource handleNestedVfc(Service service,
1472 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1473 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1476 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
1477 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
1478 createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
1480 log.debug("************* Finished to create node types from yaml {}", yamlName);
1481 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1482 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1483 return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
1485 return new Resource();
1486 } catch (Exception e) {
1487 log.debug("Exception occured when handleNestedVFc, error is:{}", e.getMessage(), e);
1488 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1492 protected Resource handleNestedVfc(Resource resource,
1493 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1494 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1496 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
1497 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
1498 log.debug("************* Going to create node types from yaml {}", yamlName);
1499 createResourcesFromYamlNodeTypesList(yamlName, resource, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
1501 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1502 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1503 resource = handleComplexVfc(resource, nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
1508 protected Resource handleComplexVfc(Resource resource,
1509 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1510 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1511 String nodeName, String yamlName) {
1512 Resource oldComplexVfc = null;
1513 Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(resource, csarInfo, nodeName, nodesInfo);
1514 Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
1515 .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
1516 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
1517 oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
1518 serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), nodeName).getRight());
1520 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
1521 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1522 } else if (oldComplexVfcRes.isLeft()) {
1523 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
1524 Either<Boolean, ResponseFormat> eitherValidation = serviceImportParseLogic
1525 .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc,
1526 ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
1527 if (eitherValidation.isLeft()) {
1528 oldComplexVfc = oldComplexVfcRes.left().value();
1531 newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc,
1533 csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
1534 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
1535 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR);
1536 log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
1537 final Resource result = serviceImportParseLogic
1538 .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true);
1539 csarInfo.getCreatedNodes().put(nodeName, result);
1540 csarInfo.removeNodeFromQueue();
1544 private Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Resource resource, Map<String, Object> mappedToscaTemplate,
1546 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1547 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1548 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
1549 Either<String, ImportUtils.ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
1550 TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
1551 if (toscaVersion.isRight()) {
1552 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
1554 Map<String, Object> mapToConvert = new HashMap<>();
1555 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value());
1556 Map<String, Object> nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate);
1557 createNodeTypes(yamlName, resource, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert,
1559 return csarInfo.getCreatedNodes();
1562 protected void createNodeTypes(String yamlName, Resource resource, boolean needLock,
1563 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1564 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1565 Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
1566 Iterator<Map.Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet().iterator();
1567 Resource vfcCreated = null;
1568 while (nodesNameValueIter.hasNext()) {
1569 Map.Entry<String, Object> nodeType = nodesNameValueIter.next();
1570 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle =
1571 nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeType.getKey());
1572 if (nodeTypesInfo.containsKey(nodeType.getKey())) {
1573 log.trace("************* Going to handle nested vfc {}", nodeType.getKey());
1574 vfcCreated = handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1576 log.trace("************* Finished to handle nested vfc {}", nodeType.getKey());
1577 } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames()
1578 .containsKey(nodeType.getKey())) {
1579 log.trace("************* Going to create node {}", nodeType.getKey());
1580 ImmutablePair<Resource, ActionStatus> resourceCreated = createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(),
1581 mapToConvert, resource, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true);
1582 log.debug("************* Finished to create node {}", nodeType.getKey());
1583 vfcCreated = resourceCreated.getLeft();
1584 csarInfo.getCreatedNodesToscaResourceNames().put(nodeType.getKey(), vfcCreated.getToscaResourceName());
1586 if (vfcCreated != null) {
1587 csarInfo.getCreatedNodes().put(nodeType.getKey(), vfcCreated);
1589 mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());
1593 protected ImmutablePair<Resource, ActionStatus> createNodeTypeResourceFromYaml(String yamlName, Map.Entry<String, Object> nodeNameValue,
1594 User user, Map<String, Object> mapToConvert, Resource resourceVf,
1596 Map<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
1597 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1598 boolean forceCertificationAllowed, CsarInfo csarInfo,
1600 final var validatedUser = serviceBusinessLogic.validateUser(user, "CheckIn Resource", resourceVf, AuditingActionEnum.CHECKIN_RESOURCE,
1602 UploadResourceInfo resourceMetaData = serviceImportParseLogic.fillResourceMetadata(yamlName, resourceVf, nodeNameValue.getKey(),
1604 String singleVfcYaml = serviceImportParseLogic.buildNodeTypeYaml(nodeNameValue, mapToConvert, resourceMetaData.getResourceType(), csarInfo);
1605 return serviceImportParseLogic.createResourceFromNodeType(singleVfcYaml, resourceMetaData, validatedUser, true, needLock,
1606 nodeTypeArtifactsToHandle,
1607 nodeTypesNewCreatedArtifacts, forceCertificationAllowed, csarInfo, nodeNameValue.getKey(), isNested);
1610 protected Service createRIAndRelationsFromYaml(String yamlName, Service service,
1611 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap,
1612 String topologyTemplateYaml, List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1613 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1614 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
1616 log.debug("************* Going to create all nodes {}", yamlName);
1617 handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts,
1618 nodeTypesInfo, csarInfo, nodeName);
1619 if (MapUtils.isNotEmpty(uploadComponentInstanceInfoMap)) {
1620 log.debug("************* Going to create all resource instances {}", yamlName);
1621 service = createServiceInstances(yamlName, service, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes());
1622 log.debug("************* Going to create all relations {}", yamlName);
1623 service = createServiceInstancesRelations(csarInfo.getModifier(), yamlName, service, uploadComponentInstanceInfoMap);
1624 log.debug("************* Going to create positions {}", yamlName);
1625 compositionBusinessLogic.setPositionsForComponentInstances(service, csarInfo.getModifier().getUserId());
1626 log.debug("************* Finished to set positions {}", yamlName);
1631 protected Service createServiceInstancesRelations(User user, String yamlName, Service service,
1632 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1633 log.debug("#createResourceInstancesRelations - Going to create relations ");
1634 List<ComponentInstance> componentInstancesList = service.getComponentInstances();
1635 if (MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)) { // PNF can have no resource instances
1636 log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
1637 service.getUniqueId(), yamlName);
1638 BeEcompErrorManager.getInstance()
1639 .logInternalDataError("createResourceInstancesRelations", "No instances found in a component or nn yaml template. ",
1640 BeEcompErrorManager.ErrorSeverity.ERROR);
1641 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName));
1643 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1644 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1645 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1646 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1647 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1648 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1649 Map<String, Resource> originCompMap = new HashMap<>();
1650 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1651 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1652 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1653 Map<String, Map<String, InterfaceDefinition>> instInterfaces = new HashMap<>();
1654 log.debug("enter ServiceImportBusinessLogic createServiceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. ");
1655 final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache;
1656 if (applicationDataTypeCache != null) {
1657 final Map<String, DataTypeDefinition> allDataTypesMap =
1658 componentsUtils.getAllDataTypes(applicationDataTypeCache, service.getModel());
1659 final Service service1 = service;
1660 uploadResInstancesMap.values().forEach(
1661 i -> processComponentInstance(yamlName, service1, componentInstancesList,
1662 allDataTypesMap, instProperties,
1663 instCapabilities, instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs,
1664 instNodeFilter, instInterfaces, i)
1667 updatePropertyToscaFunctionData(service, instProperties, instAttributes);
1668 serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, service, instProperties);
1669 serviceImportParseLogic.associateComponentInstanceInterfacesToComponent(
1674 serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, service, instInputs);
1675 serviceImportParseLogic.associateCINodeFilterToComponent(yamlName, service, instNodeFilter);
1676 serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, service, instDeploymentArtifacts);
1677 serviceImportParseLogic.associateArtifactsToInstances(yamlName, service, instArtifacts);
1678 serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, service, instCapabilities, instRequirements);
1679 log.debug("enter createServiceInstancesRelations test,instRequirements:{},instCapabilities:{}", instRequirements, instCapabilities);
1680 serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, service, instAttributes);
1681 ToscaElement serviceTemplate = ModelConverter.convertToToscaElement(service);
1682 Map<String, ListCapabilityDataDefinition> capabilities = serviceTemplate.getCapabilities();
1683 Map<String, ListRequirementDataDefinition> requirements = serviceTemplate.getRequirements();
1684 serviceImportParseLogic.associateCapabilitiesToService(yamlName, service, capabilities);
1685 serviceImportParseLogic.associateRequirementsToService(yamlName, service, requirements);
1686 service = getResourceAfterCreateRelations(service);
1687 addRelationsToRI(yamlName, service, uploadResInstancesMap, componentInstancesList, relations);
1688 serviceImportParseLogic.associateResourceInstances(yamlName, service, relations);
1689 log.debug("************* in create relations, getResource start");
1690 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
1691 log.debug("************* in create relations, getResource end");
1692 if (eitherGetResource.isRight()) {
1693 throw new ComponentException(componentsUtils
1694 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service,
1695 service.getComponentType()));
1697 return eitherGetResource.left().value();
1700 private void updatePropertyToscaFunctionData(final Component service,
1701 final Map<String, List<ComponentInstanceProperty>> instancePropertyMap,
1702 final Map<String, List<AttributeDefinition>> instanceAttributeMap) {
1703 final Component updatedService =
1704 toscaOperationFacade.getToscaElement(service.getUniqueId()).left()
1705 .on(storageOperationStatus -> {
1706 final ActionStatus status = componentsUtils.convertFromStorageResponse(storageOperationStatus);
1707 final ResponseFormat responseFormat =
1708 componentsUtils.getResponseFormatByComponent(status, service, service.getComponentType());
1709 throw new ComponentException(responseFormat);
1712 instancePropertyMap.values().forEach(instancePropertyList ->
1713 instancePropertyList.stream()
1714 .filter(PropertyDataDefinition::isToscaFunction)
1715 .forEach(instanceProperty -> {
1716 toscaFunctionService.updateFunctionWithDataFromSelfComponent(instanceProperty.getToscaFunction(),
1717 updatedService, instancePropertyMap, instanceAttributeMap);
1718 instanceProperty.setValue(instanceProperty.getToscaFunction().getValue());
1723 protected void processComponentInstance(String yamlName, Component component, List<ComponentInstance> componentInstancesList,
1724 Map<String, DataTypeDefinition> allDataTypes,
1725 Map<String, List<ComponentInstanceProperty>> instProperties,
1726 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
1727 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements,
1728 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts,
1729 Map<String, Map<String, ArtifactDefinition>> instArtifacts,
1730 Map<String, List<AttributeDefinition>> instAttributes, Map<String, Resource> originCompMap,
1731 Map<String, List<ComponentInstanceInput>> instInputs,
1732 Map<String, UploadNodeFilterInfo> instNodeFilter,
1733 Map<String, Map<String, InterfaceDefinition>> instInterfaces,
1734 UploadComponentInstanceInfo uploadComponentInstanceInfo) {
1735 log.debug("enter ServiceImportBusinessLogic processComponentInstance");
1736 Optional<ComponentInstance> currentCompInstanceOpt = componentInstancesList.stream()
1737 .filter(i -> i.getName().equals(uploadComponentInstanceInfo.getName())).findFirst();
1738 if (currentCompInstanceOpt.isEmpty()) {
1739 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), component.getUniqueId());
1740 BeEcompErrorManager.getInstance()
1741 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, component.getUniqueId(),
1742 BeEcompErrorManager.ErrorSeverity.ERROR);
1743 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1744 throw new ComponentException(responseFormat);
1746 ComponentInstance currentCompInstance = currentCompInstanceOpt.get();
1747 String resourceInstanceId = currentCompInstance.getUniqueId();
1748 Resource originResource = getOriginResource(yamlName, originCompMap, currentCompInstance);
1749 if (MapUtils.isNotEmpty(originResource.getRequirements())) {
1750 instRequirements.put(currentCompInstance, originResource.getRequirements());
1752 if (MapUtils.isNotEmpty(originResource.getCapabilities())) {
1753 processComponentInstanceCapabilities(allDataTypes, instCapabilties, uploadComponentInstanceInfo, currentCompInstance, originResource);
1755 if (originResource.getDeploymentArtifacts() != null && !originResource.getDeploymentArtifacts().isEmpty()) {
1756 instDeploymentArtifacts.put(resourceInstanceId, originResource.getDeploymentArtifacts());
1758 if (originResource.getArtifacts() != null && !originResource.getArtifacts().isEmpty()) {
1759 instArtifacts.put(resourceInstanceId, originResource.getArtifacts());
1761 if (originResource.getAttributes() != null && !originResource.getAttributes().isEmpty()) {
1762 instAttributes.put(resourceInstanceId, originResource.getAttributes());
1763 addAttributeValueToResourceInstance(instAttributes, uploadComponentInstanceInfo.getAttributes());
1765 if (uploadComponentInstanceInfo.getUploadNodeFilterInfo() != null) {
1766 instNodeFilter.put(resourceInstanceId, uploadComponentInstanceInfo.getUploadNodeFilterInfo());
1768 if (MapUtils.isNotEmpty(uploadComponentInstanceInfo.getInterfaces())) {
1770 ResponseFormat addInterfacesToRiRes = addInterfaceValuesToRi(
1771 uploadComponentInstanceInfo,
1774 currentCompInstance,
1777 if (addInterfacesToRiRes.getStatus() != 200) {
1778 throw new ComponentException(addInterfacesToRiRes);
1781 if (originResource.getResourceType() != ResourceTypeEnum.VF) {
1782 ResponseFormat addPropertiesValueToRiRes = addPropertyValuesToRi(uploadComponentInstanceInfo, component, originResource,
1783 currentCompInstance, instProperties, allDataTypes);
1784 if (addPropertiesValueToRiRes.getStatus() != 200) {
1785 throw new ComponentException(addPropertiesValueToRiRes);
1788 addInputsValuesToRi(uploadComponentInstanceInfo, component, originResource, currentCompInstance, instInputs, allDataTypes);
1792 protected void addInputsValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component, Resource originResource,
1793 ComponentInstance currentCompInstance, Map<String, List<ComponentInstanceInput>> instInputs,
1794 Map<String, DataTypeDefinition> allDataTypes) {
1795 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
1797 if (MapUtils.isNotEmpty(propMap)) {
1798 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
1799 List<ComponentInstanceInput> instPropList = new ArrayList<>();
1800 if (CollectionUtils.isEmpty(originResource.getInputs())) {
1801 log.debug("failed to find properties ");
1802 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND));
1804 originResource.getInputs().forEach(p -> serviceImportParseLogic.addInput(currPropertiesMap, p));
1805 for (List<UploadPropInfo> propertyList : propMap.values()) {
1806 processProperty(component, allDataTypes, currPropertiesMap, instPropList, propertyList);
1808 currPropertiesMap.values().forEach(p -> instPropList.add(new ComponentInstanceInput(p)));
1809 instInputs.put(currentCompInstance.getUniqueId(), instPropList);
1811 } catch (Exception e) {
1812 log.debug("failed to add Inputs Values To Ri");
1813 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1817 protected void processProperty(Component component, Map<String, DataTypeDefinition> allDataTypes,
1818 Map<String, InputDefinition> currPropertiesMap, List<ComponentInstanceInput> instPropList,
1819 List<UploadPropInfo> propertyList) {
1820 UploadPropInfo propertyInfo = propertyList.get(0);
1821 String propName = propertyInfo.getName();
1822 if (!currPropertiesMap.containsKey(propName)) {
1823 log.debug("failed to find property {} ", propName);
1824 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName));
1826 processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, component.getInputs());
1829 protected void processGetInput(List<GetInputValueDataDefinition> getInputValues, List<InputDefinition> inputs,
1830 GetInputValueDataDefinition getInputIndex) {
1831 Optional<InputDefinition> optional;
1832 if (getInputIndex != null) {
1833 optional = inputs.stream().filter(p -> p.getName().equals(getInputIndex.getInputName())).findAny();
1834 if (!optional.isPresent()) {
1835 log.debug("Failed to find input {} ", getInputIndex.getInputName());
1836 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1838 InputDefinition inputIndex = optional.get();
1839 getInputIndex.setInputId(inputIndex.getUniqueId());
1840 getInputValues.add(getInputIndex);
1844 private void addAttributeValueToResourceInstance(Map<String, List<AttributeDefinition>> instAttributes,
1845 Map<String, UploadAttributeInfo> attributeMap) {
1846 if (attributeMap == null) {
1849 attributeMap.forEach((attributeName, attributeValue) -> instAttributes.values()
1850 .forEach(value -> value.stream().filter(attr -> attr.getName().equals(attributeName)).forEach(attr -> {
1851 if (attributeValue.getValue() instanceof Collection<?> || attributeValue.getValue() instanceof Map<?, ?>) {
1852 Gson gson = new Gson();
1853 String json = gson.toJson(attributeValue.getValue());
1854 attr.setValue(json);
1856 attr.setValue(String.valueOf(attributeValue.getValue()));
1861 protected ResponseFormat addPropertyValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component,
1862 Resource originResource, ComponentInstance currentCompInstance,
1863 Map<String, List<ComponentInstanceProperty>> instProperties,
1864 Map<String, DataTypeDefinition> allDataTypes) {
1865 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
1866 Map<String, PropertyDefinition> currPropertiesMap = new HashMap<>();
1867 List<PropertyDefinition> originalPropertyList = originResource.getProperties();
1868 if (MapUtils.isNotEmpty(propMap) && CollectionUtils.isEmpty(originalPropertyList)) {
1869 log.debug("failed to find properties ");
1870 return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND);
1872 if (CollectionUtils.isEmpty(originalPropertyList)) {
1873 return componentsUtils.getResponseFormat(ActionStatus.OK);
1875 originalPropertyList.stream()
1876 .filter(property -> !currPropertiesMap.containsKey(property.getName()))
1877 .forEach(property -> currPropertiesMap.put(property.getName(), property));
1878 List<ComponentInstanceProperty> instPropList = new ArrayList<>();
1879 if (MapUtils.isNotEmpty(propMap)) {
1880 for (final List<UploadPropInfo> propertyList : propMap.values()) {
1881 UploadPropInfo propertyInfo = propertyList.get(0);
1882 String propName = propertyInfo.getName();
1883 if (!currPropertiesMap.containsKey(propName)) {
1884 log.debug("failed to find property {} ", propName);
1885 return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName);
1887 PropertyDefinition curPropertyDef = currPropertiesMap.get(propName);
1888 String value = null;
1889 final List<GetInputValueDataDefinition> getInputs = new ArrayList<>();
1890 boolean isValidate = true;
1891 if (propertyInfo.getValue() != null) {
1892 getInputs.addAll(propertyInfo.getGet_input());
1893 isValidate = getInputs.isEmpty();
1895 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
1897 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
1900 final var property = new ComponentInstanceProperty(curPropertyDef, value, null);
1901 String validatedPropValue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, true, allDataTypes);
1903 addSubPropertyYamlToscaFunctions(validatedPropValue, value, property.getType(), propertyInfo, allDataTypes);
1905 if (CollectionUtils.isNotEmpty(propertyInfo.getSubPropertyToscaFunctions())) {
1906 validatedPropValue = value;
1909 property.setValue(validatedPropValue);
1911 if (tryHandlingAsYamlToscaFunction(validatedPropValue, value, propertyInfo)) {
1913 final Object yamlValue = new Yaml().loadAs(value, Object.class);
1914 CustomYamlFunction toscaFunction = new CustomYamlFunction();
1915 toscaFunction.setYamlValue(yamlValue);
1916 property.setToscaFunction(toscaFunction);
1917 } catch (Exception exception) {
1918 log.info("Cannot create YAML value for {}", propName);
1921 property.setToscaFunction(propertyInfo.getToscaFunction());
1923 property.setSubPropertyToscaFunctions(propertyInfo.getSubPropertyToscaFunctions());
1924 if (!getInputs.isEmpty() && CollectionUtils.isEmpty(property.getSubPropertyToscaFunctions())) {
1925 final List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1926 for (final GetInputValueDataDefinition getInput : getInputs) {
1927 final List<InputDefinition> inputs = component.getInputs();
1928 if (inputs == null || inputs.isEmpty()) {
1929 log.debug("Failed to add property {} to instance. Inputs list is empty ", property);
1930 serviceBusinessLogic.rollbackWithException(ActionStatus.INPUTS_NOT_FOUND,
1931 property.getGetInputValues().stream().map(GetInputValueDataDefinition::getInputName).collect(toList()).toString());
1933 InputDefinition input = serviceImportParseLogic.findInputByName(inputs, getInput);
1934 getInput.setInputId(input.getUniqueId());
1935 getInputValues.add(getInput);
1936 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
1937 if (getInputIndex != null) {
1938 input = serviceImportParseLogic.findInputByName(inputs, getInputIndex);
1939 getInputIndex.setInputId(input.getUniqueId());
1940 getInputValues.add(getInputIndex);
1943 property.setGetInputValues(getInputValues);
1945 instPropList.add(property);
1946 currPropertiesMap.remove(property.getName());
1949 if (!currPropertiesMap.isEmpty()) {
1950 for (PropertyDefinition value : currPropertiesMap.values()) {
1951 instPropList.add(new ComponentInstanceProperty(value));
1954 instProperties.put(currentCompInstance.getUniqueId(), instPropList);
1955 return componentsUtils.getResponseFormat(ActionStatus.OK);
1958 private boolean tryHandlingAsYamlToscaFunction(String validatedPropValue, String value, UploadPropInfo propertyInfo) {
1959 return StringUtils.isEmpty(validatedPropValue) && StringUtils.isNotEmpty(value) && propertyInfo.getToscaFunction() == null && CollectionUtils.isEmpty(propertyInfo.getSubPropertyToscaFunctions());
1962 private void addSubPropertyYamlToscaFunctions(final String validatedPropValue, final String value, final String propertyType, final UploadPropInfo propertyInfo, final Map<String, DataTypeDefinition> allDataTypes) {
1963 if (StringUtils.isNotEmpty(validatedPropValue) || StringUtils.isEmpty(value) || ToscaPropertyType.isValidType(propertyType) != null) {
1967 final JsonObject jsonObject = JsonParser.parseString(value).getAsJsonObject();
1969 final DataTypeDefinition dataTypeDefinition = allDataTypes.get(propertyType);
1970 final List<String> propertyNames =
1971 dataTypeDefinition.getProperties().stream().map(PropertyDataDefinition::getName).collect(Collectors.toList());
1973 boolean hasSubPropertyValues = jsonObject.entrySet().stream().allMatch(entry -> propertyNames.contains(entry.getKey()));
1975 if (hasSubPropertyValues) {
1976 for (final PropertyDefinition prop : dataTypeDefinition.getProperties()) {
1977 if (propertyInfo.getSubPropertyToscaFunctions().stream()
1978 .anyMatch(subPropertyToscaFunction -> subPropertyToscaFunction.getSubPropertyPath().get(0).equals(prop.getName()))) {
1981 Optional<SubPropertyToscaFunction> subPropertyToscaFunction = createSubPropertyYamlToscaFunction(jsonObject, prop, allDataTypes);
1982 if (subPropertyToscaFunction.isPresent()) {
1983 propertyInfo.getSubPropertyToscaFunctions().add(subPropertyToscaFunction.get());
1987 } catch (Exception exception) {
1988 log.info("Cannot create YAML value for {}", value);
1992 private Optional<SubPropertyToscaFunction> createSubPropertyYamlToscaFunction(final JsonObject jsonObject, final PropertyDefinition prop, final Map<String, DataTypeDefinition> allDataTypes) {
1993 JsonElement propJsonElement = jsonObject.get(prop.getName());
1994 if (propJsonElement != null) {
1995 final String subPropValue = propJsonElement.toString();
1996 final ComponentInstanceProperty subProperty = new ComponentInstanceProperty(prop, subPropValue, null);
1997 final String validateSubPropValue =
1998 serviceBusinessLogic.validatePropValueBeforeCreate(subProperty, subPropValue, true, allDataTypes);
2000 if (StringUtils.isEmpty(validateSubPropValue) && StringUtils.isNotEmpty(subPropValue)) {
2002 Object yamlValue = new Yaml().loadAs(subPropValue, Object.class);
2003 SubPropertyToscaFunction subPropertyToscaFunction = new SubPropertyToscaFunction();
2004 CustomYamlFunction toscaFunction = new CustomYamlFunction();
2005 toscaFunction.setYamlValue(yamlValue);
2006 subPropertyToscaFunction.setToscaFunction(toscaFunction);
2007 subPropertyToscaFunction.setSubPropertyPath(Collections.singletonList(prop.getName()));
2008 return Optional.of(subPropertyToscaFunction);
2009 } catch (Exception exception) {
2010 log.info("Cannot create YAML value for {}", subPropValue);
2014 return Optional.empty();
2017 protected ResponseFormat addInterfaceValuesToRi(
2018 UploadComponentInstanceInfo uploadComponentInstanceInfo,
2019 Component component,
2020 Resource originResource, ComponentInstance currentCompInstance,
2021 Map<String, Map<String, InterfaceDefinition>> instInterfaces
2023 Map<String, UploadInterfaceInfo> instanceInterfacesMap = uploadComponentInstanceInfo.getInterfaces();
2024 Map<String, InterfaceDefinition> currInterfacesMap = new HashMap<>();
2025 Map<String, InterfaceDefinition> interfacesFromNodeType = originResource.getInterfaces();
2026 if ((MapUtils.isNotEmpty(instanceInterfacesMap)) && (MapUtils.isEmpty(interfacesFromNodeType))) {
2027 log.debug("failed to find interfaces ");
2028 return componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT);
2030 if (interfacesFromNodeType == null || interfacesFromNodeType.isEmpty()) {
2031 return componentsUtils.getResponseFormat(ActionStatus.OK);
2033 for (Map.Entry<String, InterfaceDefinition> entryInstances : interfacesFromNodeType.entrySet()) {
2034 String interfaceName = entryInstances.getKey().substring(entryInstances.getKey().lastIndexOf(".") + 1);
2035 if (!currInterfacesMap.containsKey(interfaceName)) {
2036 currInterfacesMap.put(interfaceName, entryInstances.getValue());
2040 Map<String, InterfaceDefinition> instInterfacesMap = new HashMap<>();
2041 if (MapUtils.isNotEmpty(instanceInterfacesMap)) {
2042 for (UploadInterfaceInfo uploadInterfaceInfo : instanceInterfacesMap.values()) {
2043 String interfaceName = uploadInterfaceInfo.getName();
2044 if (!currInterfacesMap.containsKey(interfaceName)) {
2045 log.debug("failed to find interface {} ", interfaceName);
2046 return componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT, interfaceName);
2048 InterfaceDefinition currentInterfaceDef = currInterfacesMap.get(interfaceName);
2049 Map<String, OperationDataDefinition> operationsToAdd = new HashMap<>();
2051 Map<String, OperationDataDefinition> operations = uploadInterfaceInfo.getOperations();
2052 for (Map.Entry<String, OperationDataDefinition> operation : operations.entrySet()) {
2053 OperationDataDefinition templateOperation = currentInterfaceDef.getOperationsMap().get(operation.getKey());
2054 OperationDataDefinition instanceOperation = operation.getValue();
2056 ListDataDefinition<OperationInputDefinition> instanceInputs = instanceOperation.getInputs();
2057 mergeOperationInputDefinitions(templateOperation.getInputs(), instanceInputs);
2058 templateOperation.setInputs(instanceInputs);
2060 templateOperation.setImplementation(instanceOperation.getImplementation());
2062 templateOperation.setDescription(instanceOperation.getDescription());
2063 operationsToAdd.put(operation.getKey(), templateOperation);
2065 InterfaceDefinition interfaceDef = new InterfaceDefinition();
2066 interfaceDef.setModel(component.getModel());
2067 interfaceDef.setType(currentInterfaceDef.getType());
2068 interfaceDef.setUniqueId(currentInterfaceDef.getType());
2069 interfaceDef.setDescription(uploadInterfaceInfo.getDescription());
2070 interfaceDef.setOperations(operationsToAdd);
2071 instInterfacesMap.put(interfaceName, interfaceDef);
2072 currInterfacesMap.remove(interfaceName);
2075 if (!currInterfacesMap.isEmpty()) {
2076 for (InterfaceDefinition value : currInterfacesMap.values()) {
2077 instInterfacesMap.put(value.getUniqueId(), value);
2080 instInterfaces.put(currentCompInstance.getUniqueId(), instInterfacesMap);
2081 return componentsUtils.getResponseFormat(ActionStatus.OK);
2084 private void mergeOperationInputDefinitions(ListDataDefinition<OperationInputDefinition> inputsFromNodeType,
2085 ListDataDefinition<OperationInputDefinition> instanceInputs) {
2086 if (inputsFromNodeType == null || CollectionUtils.isEmpty(inputsFromNodeType.getListToscaDataDefinition()) || instanceInputs == null
2087 || CollectionUtils.isEmpty(instanceInputs.getListToscaDataDefinition())) {
2090 instanceInputs.getListToscaDataDefinition().forEach(
2091 instanceInput -> inputsFromNodeType.getListToscaDataDefinition().stream().filter(
2092 templateInput -> templateInput.getName().equals(instanceInput.getName())
2094 newInstanceInput -> {
2095 instanceInput.setSourceProperty(newInstanceInput.getSourceProperty());
2096 instanceInput.setSource(newInstanceInput.getSource());
2097 instanceInput.setType(newInstanceInput.getType());
2101 instanceInputs.getListToscaDataDefinition().stream()
2102 .filter(instanceInput -> inputsFromNodeType.getListToscaDataDefinition().stream().noneMatch(
2103 inputFromNodeType -> inputFromNodeType.getName().equals(instanceInput.getName())
2105 .forEach(oldInput -> oldInput.setType("string"));
2108 protected void processComponentInstanceCapabilities(Map<String, DataTypeDefinition> allDataTypes,
2109 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
2110 UploadComponentInstanceInfo uploadComponentInstanceInfo,
2111 ComponentInstance currentCompInstance, Resource originResource) {
2112 log.debug("enter processComponentInstanceCapabilities");
2113 Map<String, List<CapabilityDefinition>> originCapabilities;
2114 if (MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities())) {
2115 originCapabilities = new HashMap<>();
2116 Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
2117 originResource.getCapabilities().forEach((k, v) -> serviceImportParseLogic.addCapabilities(originCapabilities, k, v));
2118 uploadComponentInstanceInfo.getCapabilities().values()
2119 .forEach(l -> serviceImportParseLogic.addCapabilitiesProperties(newPropertiesMap, l));
2120 updateCapabilityPropertiesValues(allDataTypes, originCapabilities, newPropertiesMap);
2122 originCapabilities = originResource.getCapabilities();
2124 instCapabilties.put(currentCompInstance, originCapabilities);
2127 protected void updateCapabilityPropertiesValues(Map<String, DataTypeDefinition> allDataTypes,
2128 Map<String, List<CapabilityDefinition>> originCapabilities,
2129 Map<String, Map<String, UploadPropInfo>> newPropertiesMap) {
2130 originCapabilities.values().stream().flatMap(Collection::stream).filter(c -> newPropertiesMap.containsKey(c.getName()))
2131 .forEach(c -> updatePropertyValues(c.getProperties(), newPropertiesMap.get(c.getName()), allDataTypes));
2134 protected void updatePropertyValues(List<ComponentInstanceProperty> properties, Map<String, UploadPropInfo> newProperties,
2135 Map<String, DataTypeDefinition> allDataTypes) {
2136 properties.forEach(p -> updatePropertyValue(p, newProperties.get(p.getName()), allDataTypes));
2139 protected String updatePropertyValue(ComponentInstanceProperty property, UploadPropInfo propertyInfo,
2140 Map<String, DataTypeDefinition> allDataTypes) {
2141 String value = null;
2142 List<GetInputValueDataDefinition> getInputs = null;
2143 boolean isValidate = true;
2144 if (null != propertyInfo && propertyInfo.getValue() != null) {
2145 getInputs = propertyInfo.getGet_input();
2146 isValidate = getInputs == null || getInputs.isEmpty();
2148 value = getPropertyJsonStringValue(propertyInfo.getValue(), property.getType());
2150 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
2153 property.setValue(value);
2154 return serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
2157 protected Resource getOriginResource(String yamlName, Map<String, Resource> originCompMap, ComponentInstance currentCompInstance) {
2158 Resource originResource;
2159 log.debug("after enter ServiceImportBusinessLogic processComponentInstance, enter getOriginResource");
2160 if (!originCompMap.containsKey(currentCompInstance.getComponentUid())) {
2161 Either<Resource, StorageOperationStatus> getOriginResourceRes = toscaOperationFacade
2162 .getToscaFullElement(currentCompInstance.getComponentUid());
2163 if (getOriginResourceRes.isRight()) {
2164 ResponseFormat responseFormat = componentsUtils
2165 .getResponseFormat(componentsUtils.convertFromStorageResponse(getOriginResourceRes.right().value()), yamlName);
2166 throw new ComponentException(responseFormat);
2168 originResource = getOriginResourceRes.left().value();
2169 originCompMap.put(originResource.getUniqueId(), originResource);
2171 originResource = originCompMap.get(currentCompInstance.getComponentUid());
2173 return originResource;
2176 protected Either<Resource, StorageOperationStatus> updateCalculatedCapReqWithSubstitutionMappings(Resource resource,
2177 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
2178 Either<Resource, StorageOperationStatus> updateRes = null;
2179 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities = new HashMap<>();
2180 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements = new HashMap<>();
2181 StorageOperationStatus status = toscaOperationFacade.deleteAllCalculatedCapabilitiesRequirements(resource.getUniqueId());
2182 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
2183 log.debug("Failed to delete all calculated capabilities and requirements of resource {} upon update. Status is {}",
2184 resource.getUniqueId(), status);
2185 updateRes = Either.right(status);
2187 if (updateRes == null) {
2188 fillUpdatedInstCapabilitiesRequirements(resource.getComponentInstances(), uploadResInstancesMap, updatedInstCapabilities,
2189 updatedInstRequirements);
2190 status = toscaOperationFacade.associateOrAddCalculatedCapReq(updatedInstCapabilities, updatedInstRequirements, resource);
2191 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
2192 updateRes = Either.right(status);
2195 if (updateRes == null) {
2196 updateRes = Either.left(resource);
2201 protected void fillUpdatedInstCapabilitiesRequirements(List<ComponentInstance> componentInstances,
2202 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
2203 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities,
2204 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements) {
2205 componentInstances.stream().forEach(i -> {
2206 fillUpdatedInstCapabilities(updatedInstCapabilities, i, uploadResInstancesMap.get(i.getName()).getCapabilitiesNamesToUpdate());
2207 fillUpdatedInstRequirements(updatedInstRequirements, i, uploadResInstancesMap.get(i.getName()).getRequirementsNamesToUpdate());
2211 protected void fillUpdatedInstCapabilities(Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilties,
2212 ComponentInstance instance, Map<String, String> capabilitiesNamesToUpdate) {
2213 Map<String, List<CapabilityDefinition>> updatedCapabilities = new HashMap<>();
2214 Set<String> updatedCapNames = new HashSet<>();
2215 if (MapUtils.isNotEmpty(capabilitiesNamesToUpdate)) {
2216 for (Map.Entry<String, List<CapabilityDefinition>> requirements : instance.getCapabilities().entrySet()) {
2217 updatedCapabilities.put(requirements.getKey(), requirements.getValue().stream().filter(
2218 c -> capabilitiesNamesToUpdate.containsKey(c.getName()) && !updatedCapNames.contains(capabilitiesNamesToUpdate.get(c.getName())))
2220 c.setParentName(c.getName());
2221 c.setName(capabilitiesNamesToUpdate.get(c.getName()));
2222 updatedCapNames.add(c.getName());
2224 }).collect(toList()));
2227 if (MapUtils.isNotEmpty(updatedCapabilities)) {
2228 updatedInstCapabilties.put(instance, updatedCapabilities);
2232 protected void fillUpdatedInstRequirements(Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements,
2233 ComponentInstance instance, Map<String, String> requirementsNamesToUpdate) {
2234 Map<String, List<RequirementDefinition>> updatedRequirements = new HashMap<>();
2235 Set<String> updatedReqNames = new HashSet<>();
2236 if (MapUtils.isNotEmpty(requirementsNamesToUpdate)) {
2237 for (Map.Entry<String, List<RequirementDefinition>> requirements : instance.getRequirements().entrySet()) {
2238 updatedRequirements.put(requirements.getKey(), requirements.getValue().stream().filter(
2239 r -> requirementsNamesToUpdate.containsKey(r.getName()) && !updatedReqNames.contains(requirementsNamesToUpdate.get(r.getName())))
2241 r.setParentName(r.getName());
2242 r.setName(requirementsNamesToUpdate.get(r.getName()));
2243 updatedReqNames.add(r.getName());
2245 }).collect(toList()));
2248 if (MapUtils.isNotEmpty(updatedRequirements)) {
2249 updatedInstRequirements.put(instance, updatedRequirements);
2253 protected void addRelationsToRI(String yamlName, Service service, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
2254 List<ComponentInstance> componentInstancesList, List<RequirementCapabilityRelDef> relations) {
2255 for (Map.Entry<String, UploadComponentInstanceInfo> entry : uploadResInstancesMap.entrySet()) {
2256 UploadComponentInstanceInfo uploadComponentInstanceInfo = entry.getValue();
2257 ComponentInstance currentCompInstance = null;
2258 for (ComponentInstance compInstance : componentInstancesList) {
2259 if (compInstance.getName().equals(uploadComponentInstanceInfo.getName())) {
2260 currentCompInstance = compInstance;
2264 if (currentCompInstance == null) {
2265 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), service.getUniqueId());
2266 BeEcompErrorManager.getInstance()
2267 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, service.getUniqueId(),
2268 BeEcompErrorManager.ErrorSeverity.ERROR);
2269 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2270 throw new ComponentException(responseFormat);
2272 ResponseFormat addRelationToRiRes = addRelationToRI(yamlName, service, entry.getValue(), relations);
2273 if (addRelationToRiRes.getStatus() != 200) {
2274 throw new ComponentException(addRelationToRiRes);
2279 protected ResponseFormat addRelationToRI(String yamlName, Service service, UploadComponentInstanceInfo nodesInfoValue,
2280 List<RequirementCapabilityRelDef> relations) {
2281 List<ComponentInstance> componentInstancesList = service.getComponentInstances();
2282 ComponentInstance currentCompInstance = null;
2283 for (ComponentInstance compInstance : componentInstancesList) {
2284 if (compInstance.getName().equals(nodesInfoValue.getName())) {
2285 currentCompInstance = compInstance;
2289 if (currentCompInstance == null) {
2290 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, nodesInfoValue.getName(), service.getUniqueId());
2291 BeEcompErrorManager.getInstance()
2292 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + nodesInfoValue.getName() + IN_RESOURCE, service.getUniqueId(),
2293 BeEcompErrorManager.ErrorSeverity.ERROR);
2294 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2296 String resourceInstanceId = currentCompInstance.getUniqueId();
2297 Map<String, List<UploadReqInfo>> regMap = nodesInfoValue.getRequirements();
2298 if (regMap != null) {
2299 Iterator<Map.Entry<String, List<UploadReqInfo>>> nodesRegValue = regMap.entrySet().iterator();
2300 while (nodesRegValue.hasNext()) {
2301 Map.Entry<String, List<UploadReqInfo>> nodesRegInfoEntry = nodesRegValue.next();
2302 List<UploadReqInfo> uploadRegInfoList = nodesRegInfoEntry.getValue();
2303 for (UploadReqInfo uploadRegInfo : uploadRegInfoList) {
2304 log.debug("Going to create relation {}", uploadRegInfo.getName());
2305 String regName = uploadRegInfo.getName();
2306 RequirementCapabilityRelDef regCapRelDef = new RequirementCapabilityRelDef();
2307 regCapRelDef.setFromNode(resourceInstanceId);
2308 log.debug("try to find available requirement {} ", regName);
2309 Either<RequirementDefinition, ResponseFormat> eitherReqStatus = serviceImportParseLogic
2310 .findAvailableRequirement(regName, yamlName, nodesInfoValue, currentCompInstance, uploadRegInfo.getCapabilityName());
2311 if (eitherReqStatus.isRight()) {
2312 log.debug("failed to find available requirement {} status is {}", regName, eitherReqStatus.right().value());
2313 return eitherReqStatus.right().value();
2315 RequirementDefinition validReq = eitherReqStatus.left().value();
2316 List<CapabilityRequirementRelationship> reqAndRelationshipPairList = regCapRelDef.getRelationships();
2317 if (reqAndRelationshipPairList == null) {
2318 reqAndRelationshipPairList = new ArrayList<>();
2320 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
2321 reqAndRelationshipPair.setRequirement(regName);
2322 reqAndRelationshipPair.setRequirementOwnerId(validReq.getOwnerId());
2323 reqAndRelationshipPair.setRequirementUid(validReq.getUniqueId());
2324 RelationshipImpl relationship = new RelationshipImpl();
2325 relationship.setType(validReq.getCapability());
2326 reqAndRelationshipPair.setRelationships(relationship);
2327 ComponentInstance currentCapCompInstance = null;
2328 for (ComponentInstance compInstance : componentInstancesList) {
2329 if (compInstance.getName().equals(uploadRegInfo.getNode())) {
2330 currentCapCompInstance = compInstance;
2334 if (currentCapCompInstance == null) {
2335 log.debug("The component instance with name {} not found on resource {} ", uploadRegInfo.getNode(), service.getUniqueId());
2336 BeEcompErrorManager.getInstance()
2337 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadRegInfo.getNode() + IN_RESOURCE, service.getUniqueId(),
2338 BeEcompErrorManager.ErrorSeverity.ERROR);
2339 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2341 regCapRelDef.setToNode(currentCapCompInstance.getUniqueId());
2342 log.debug("try to find aviable Capability req name is {} ", validReq.getName());
2343 CapabilityDefinition aviableCapForRel = serviceImportParseLogic
2344 .findAvailableCapabilityByTypeOrName(validReq, currentCapCompInstance, uploadRegInfo);
2345 if (aviableCapForRel == null) {
2346 BeEcompErrorManager.getInstance().logInternalDataError(
2347 "aviable capability was not found. req name is " + validReq.getName() + " component instance is " + currentCapCompInstance
2348 .getUniqueId(), service.getUniqueId(), BeEcompErrorManager.ErrorSeverity.ERROR);
2349 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2351 reqAndRelationshipPair.setCapability(aviableCapForRel.getName());
2352 reqAndRelationshipPair.setCapabilityUid(aviableCapForRel.getUniqueId());
2353 reqAndRelationshipPair.setCapabilityOwnerId(aviableCapForRel.getOwnerId());
2354 CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship();
2355 capReqRel.setRelation(reqAndRelationshipPair);
2356 if (StringUtils.isNotEmpty(uploadRegInfo.getRelationshipTemplate())) {
2357 capReqRel.setOperations(getOperations(nodesInfoValue.getOperations(), uploadRegInfo.getRelationshipTemplate()));
2359 reqAndRelationshipPairList.add(capReqRel);
2360 regCapRelDef.setRelationships(reqAndRelationshipPairList);
2361 relations.add(regCapRelDef);
2365 return componentsUtils.getResponseFormat(ActionStatus.OK, yamlName);
2368 private List<OperationUi> getOperations(final Map<String, List<OperationUi>> operations, final String relationshipTemplate) {
2369 final List<OperationUi> operationUiList = new ArrayList<>();
2370 operations.forEach((operationKey, operationValues) -> {
2371 if (operationKey.equals(relationshipTemplate)) {
2372 operationUiList.addAll(operationValues);
2375 return operationUiList;
2378 protected Service getResourceAfterCreateRelations(Service service) {
2379 ComponentParametersView parametersView = serviceImportParseLogic.getComponentFilterAfterCreateRelations();
2380 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId(), parametersView);
2381 if (eitherGetResource.isRight()) {
2382 serviceImportParseLogic.throwComponentExceptionByResource(eitherGetResource.right().value(), service);
2384 return eitherGetResource.left().value();
2387 protected Service createServiceInstances(String yamlName, Service service, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
2388 Map<String, Resource> nodeNamespaceMap) {
2389 Either<Resource, ResponseFormat> eitherResource = null;
2390 log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
2391 if (MapUtils.isEmpty(uploadResInstancesMap)) { // PNF can have no resource instances
2392 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
2393 throw new ComponentException(responseFormat);
2395 Map<String, Resource> existingNodeTypeMap = new HashMap<>();
2396 if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
2397 nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v));
2399 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
2400 uploadResInstancesMap.values()
2401 .forEach(i -> createAndAddResourceInstance(i, yamlName, service, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap));
2402 if (MapUtils.isNotEmpty(resourcesInstancesMap)) {
2404 toscaOperationFacade.associateComponentInstancesToComponent(service, resourcesInstancesMap, false, false);
2405 } catch (StorageException exp) {
2406 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
2407 log.debug("Failed to add component instances to container component {}", service.getName());
2408 ResponseFormat responseFormat = componentsUtils
2409 .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
2410 eitherResource = Either.right(responseFormat);
2411 throw new ComponentException(eitherResource.right().value());
2415 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade
2416 .getToscaElement(service.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter());
2417 log.debug("*************finished to get resource {}", service.getUniqueId());
2418 if (eitherGetResource.isRight()) {
2419 ResponseFormat responseFormat = componentsUtils
2420 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service,
2421 ComponentTypeEnum.SERVICE);
2422 throw new ComponentException(responseFormat);
2424 if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances())) { // PNF can have no resource instances
2425 log.debug("Error when create resource instance from csar. ComponentInstances list empty");
2426 BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty");
2427 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
2429 return eitherGetResource.left().value();
2432 protected void createAndAddResourceInstance(UploadComponentInstanceInfo uploadComponentInstanceInfo, String yamlName, Component component,
2433 Map<String, Resource> nodeNamespaceMap, Map<String, Resource> existingnodeTypeMap,
2434 Map<ComponentInstance, Resource> resourcesInstancesMap) {
2435 log.debug("*************Going to create resource instances {}", uploadComponentInstanceInfo.getName());
2437 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
2438 uploadComponentInstanceInfo.setType(nodeNamespaceMap.get(uploadComponentInstanceInfo.getType()).getToscaResourceName());
2440 Resource refResource = validateResourceInstanceBeforeCreate(yamlName, uploadComponentInstanceInfo, existingnodeTypeMap);
2441 ComponentInstance componentInstance = new ComponentInstance();
2442 componentInstance.setComponentUid(refResource.getUniqueId());
2443 Collection<String> directives = uploadComponentInstanceInfo.getDirectives();
2444 if (directives != null && !directives.isEmpty()) {
2445 componentInstance.setDirectives(new ArrayList<>(directives));
2447 UploadNodeFilterInfo uploadNodeFilterInfo = uploadComponentInstanceInfo.getUploadNodeFilterInfo();
2448 if (uploadNodeFilterInfo != null) {
2450 .setNodeFilter(new CINodeFilterUtils().getNodeFilterDataDefinition(uploadNodeFilterInfo, componentInstance.getUniqueId()));
2452 ComponentTypeEnum containerComponentType = component.getComponentType();
2453 NodeTypeEnum containerNodeType = containerComponentType.getNodeType();
2454 if (containerNodeType.equals(NodeTypeEnum.Resource) && MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities()) && MapUtils
2455 .isNotEmpty(refResource.getCapabilities())) {
2456 serviceImportParseLogic.setCapabilityNamesTypes(refResource.getCapabilities(), uploadComponentInstanceInfo.getCapabilities());
2457 Map<String, List<CapabilityDefinition>> validComponentInstanceCapabilities = serviceImportParseLogic
2458 .getValidComponentInstanceCapabilities(refResource.getUniqueId(), refResource.getCapabilities(),
2459 uploadComponentInstanceInfo.getCapabilities());
2460 componentInstance.setCapabilities(validComponentInstanceCapabilities);
2462 if (!existingnodeTypeMap.containsKey(uploadComponentInstanceInfo.getType())) {
2463 ResponseFormat responseFormat = componentsUtils
2464 .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(),
2465 uploadComponentInstanceInfo.getType());
2466 throw new ComponentException(responseFormat);
2468 Resource origResource = existingnodeTypeMap.get(uploadComponentInstanceInfo.getType());
2469 componentInstance.setName(uploadComponentInstanceInfo.getName());
2470 componentInstance.setIcon(origResource.getIcon());
2471 resourcesInstancesMap.put(componentInstance, origResource);
2472 } catch (Exception e) {
2473 throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
2477 protected Resource validateResourceInstanceBeforeCreate(String yamlName, UploadComponentInstanceInfo uploadComponentInstanceInfo,
2478 Map<String, Resource> nodeNamespaceMap) {
2479 Resource refResource;
2481 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
2482 refResource = nodeNamespaceMap.get(uploadComponentInstanceInfo.getType());
2484 Either<Resource, StorageOperationStatus> findResourceEither = toscaOperationFacade
2485 .getLatestResourceByToscaResourceName(uploadComponentInstanceInfo.getType());
2486 if (findResourceEither.isRight()) {
2487 ResponseFormat responseFormat = componentsUtils
2488 .getResponseFormat(componentsUtils.convertFromStorageResponse(findResourceEither.right().value()));
2489 throw new ComponentException(responseFormat);
2491 refResource = findResourceEither.left().value();
2492 nodeNamespaceMap.put(refResource.getToscaResourceName(), refResource);
2494 String componentState = refResource.getComponentMetadataDefinition().getMetadataDataDefinition().getState();
2495 if (componentState.equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
2496 ResponseFormat responseFormat = componentsUtils
2497 .getResponseFormat(ActionStatus.ILLEGAL_COMPONENT_STATE, refResource.getComponentType().getValue(), refResource.getName(),
2499 throw new ComponentException(responseFormat);
2501 if (!ModelConverter.isAtomicComponent(refResource) && refResource.getResourceType() != ResourceTypeEnum.VF) {
2502 log.debug("validateResourceInstanceBeforeCreate - ref resource type is ", refResource.getResourceType());
2503 ResponseFormat responseFormat = componentsUtils
2504 .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(),
2505 uploadComponentInstanceInfo.getType());
2506 throw new ComponentException(responseFormat);
2509 } catch (Exception e) {
2510 throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
2514 protected void handleServiceNodeTypes(String yamlName, Service service, String topologyTemplateYaml, boolean needLock,
2515 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2516 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo,
2517 CsarInfo csarInfo, String nodeName) {
2519 for (Map.Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
2520 boolean isResourceNotExisted = validateResourceNotExisted(nodeTypeEntry.getKey());
2521 if (nodeTypeEntry.getValue().isNested() && isResourceNotExisted) {
2522 handleNestedVF(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
2523 nodeTypeEntry.getKey());
2524 log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
2527 Map<String, Object> mappedToscaTemplate = null;
2528 if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo
2529 .containsKey(nodeName)) {
2530 mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
2532 if (MapUtils.isEmpty(mappedToscaTemplate)) {
2533 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
2535 createResourcesFromYamlNodeTypesList(yamlName, service, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle,
2536 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
2537 } catch (ComponentException | StorageException e) {
2539 } catch (Exception e) {
2540 log.debug("Exception occured when handleServiceNodeTypes, error is:{}", e.getMessage(), e);
2541 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2545 protected boolean validateResourceNotExisted(String type) {
2547 Either<Resource, StorageOperationStatus> latestResource = toscaOperationFacade.getLatestResourceByToscaResourceName(type);
2548 return latestResource.isRight();
2549 } catch (Exception e) {
2550 log.debug("Exception occured when validateResourceNotExisted, error is:{}", e.getMessage(), e);
2551 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2555 protected Resource handleNestedVF(Service service,
2556 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2557 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
2560 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
2561 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
2562 createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
2564 log.debug("************* Finished to create node types from yaml {}", yamlName);
2565 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
2566 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
2567 return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
2569 return new Resource();
2570 } catch (Exception e) {
2571 log.debug("Exception occured when handleNestedVF, error is:{}", e.getMessage(), e);
2572 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2576 protected Resource handleComplexVfc(
2577 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2578 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName) {
2580 Resource oldComplexVfc = null;
2581 Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(csarInfo, nodeName, nodesInfo);
2582 Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
2583 .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
2584 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
2585 oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
2586 serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), nodeName)
2589 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
2590 log.debug("Failed to fetch previous complex VFC by tosca resource name {}. Status is {}. ", newComplexVfc.getToscaResourceName(),
2591 oldComplexVfcRes.right().value());
2592 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2593 } else if (oldComplexVfcRes.isLeft()) {
2594 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
2595 Either<Boolean, ResponseFormat> eitherValidation = serviceImportParseLogic
2596 .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc,
2597 ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
2598 if (eitherValidation.isLeft()) {
2599 oldComplexVfc = oldComplexVfcRes.left().value();
2602 newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc,
2604 csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
2605 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
2606 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR);
2607 log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
2608 final Resource result = serviceImportParseLogic
2609 .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true);
2610 csarInfo.getCreatedNodes().put(nodeName, result);
2611 csarInfo.removeNodeFromQueue();
2613 } catch (Exception e) {
2614 log.debug("Exception occured when handleComplexVfc, error is:{}", e.getMessage(), e);
2615 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2619 protected Resource handleComplexVfc(
2620 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2621 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName,
2622 Resource oldComplexVfc, Resource newComplexVfc) {
2623 Resource handleComplexVfcRes;
2625 Map<String, Object> mappedToscaTemplate = nodesInfo.get(nodeName).getMappedToscaTemplate();
2626 String yamlContent = new String(csarInfo.getCsar().get(yamlName));
2627 Map<String, NodeTypeInfo> newNodeTypesInfo = nodesInfo.entrySet().stream()
2628 .collect(toMap(Map.Entry::getKey, e -> e.getValue().getUnmarkedCopy()));
2629 CsarInfo.markNestedVfc(mappedToscaTemplate, newNodeTypesInfo);
2630 if (oldComplexVfc == null) {
2631 handleComplexVfcRes = createResourceFromYaml(newComplexVfc, yamlContent, yamlName, newNodeTypesInfo, csarInfo, nodesArtifactsToHandle,
2632 false, true, nodeName);
2634 handleComplexVfcRes = updateResourceFromYaml(oldComplexVfc, newComplexVfc, AuditingActionEnum.UPDATE_RESOURCE_METADATA,
2635 createdArtifacts, yamlContent, yamlName, csarInfo, newNodeTypesInfo, nodesArtifactsToHandle, nodeName, true);
2637 return handleComplexVfcRes;
2638 } catch (Exception e) {
2639 log.debug("Exception occured when handleComplexVfc, error is:{}", e.getMessage(), e);
2640 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2644 protected Resource updateResourceFromYaml(Resource oldRresource, Resource newRresource, AuditingActionEnum actionEnum,
2645 List<ArtifactDefinition> createdArtifacts, String yamlFileName, String yamlFileContent,
2646 CsarInfo csarInfo, Map<String, NodeTypeInfo> nodeTypesInfo,
2647 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2648 String nodeName, boolean isNested) {
2649 boolean inTransaction = true;
2650 boolean shouldLock = false;
2651 Resource preparedResource = null;
2652 ParsedToscaYamlInfo uploadComponentInstanceInfoMap = null;
2654 uploadComponentInstanceInfoMap = csarBusinessLogic
2655 .getParsedToscaYamlInfo(yamlFileContent, yamlFileName, nodeTypesInfo, csarInfo, nodeName, oldRresource);
2656 Map<String, UploadComponentInstanceInfo> instances = uploadComponentInstanceInfoMap.getInstances();
2657 if (MapUtils.isEmpty(instances) && newRresource.getResourceType() != ResourceTypeEnum.PNF) {
2658 throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlFileName);
2660 preparedResource = updateExistingResourceByImport(newRresource, oldRresource, csarInfo.getModifier(), inTransaction, shouldLock,
2662 log.trace("YAML topology file found in CSAR, file name: {}, contents: {}", yamlFileName, yamlFileContent);
2663 serviceImportParseLogic.handleResourceGenericType(preparedResource);
2664 handleNodeTypes(yamlFileName, preparedResource, yamlFileContent, shouldLock, nodeTypesArtifactsToHandle, createdArtifacts, nodeTypesInfo,
2665 csarInfo, nodeName);
2666 preparedResource = serviceImportParseLogic.createInputsOnResource(preparedResource, uploadComponentInstanceInfoMap.getInputs());
2667 preparedResource = createResourceInstances(yamlFileName, preparedResource, instances, csarInfo.getCreatedNodes());
2668 preparedResource = createResourceInstancesRelations(csarInfo.getModifier(), yamlFileName, preparedResource, instances);
2669 } catch (ComponentException e) {
2670 ResponseFormat responseFormat =
2671 e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
2672 log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat);
2674 .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum);
2676 } catch (StorageException e) {
2677 ResponseFormat responseFormat = componentsUtils
2678 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
2679 log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat);
2681 .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum);
2684 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic.validateUpdateVfGroupNames(
2685 uploadComponentInstanceInfoMap.getGroups(), preparedResource.getSystemName());
2686 if (validateUpdateVfGroupNamesRes.isRight()) {
2687 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
2689 Map<String, GroupDefinition> groups;
2690 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
2691 groups = validateUpdateVfGroupNamesRes.left().value();
2693 groups = uploadComponentInstanceInfoMap.getGroups();
2695 serviceImportParseLogic.handleGroupsProperties(preparedResource, groups);
2696 preparedResource = serviceImportParseLogic.updateGroupsOnResource(preparedResource, groups);
2697 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToHandle);
2698 Either<Resource, ResponseFormat> updateArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE,
2699 createdArtifacts, yamlFileName, csarInfo, preparedResource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
2700 if (updateArtifactsEither.isRight()) {
2701 log.debug("failed to update artifacts {}", updateArtifactsEither.right().value());
2702 throw new ComponentException(updateArtifactsEither.right().value());
2704 preparedResource = serviceImportParseLogic.getResourceWithGroups(updateArtifactsEither.left().value().getUniqueId());
2705 ActionStatus mergingPropsAndInputsStatus = resourceDataMergeBusinessLogic.mergeResourceEntities(oldRresource, preparedResource);
2706 if (mergingPropsAndInputsStatus != ActionStatus.OK) {
2707 ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(mergingPropsAndInputsStatus, preparedResource);
2708 throw new ComponentException(responseFormat);
2710 compositionBusinessLogic.setPositionsForComponentInstances(preparedResource, csarInfo.getModifier().getUserId());
2711 return preparedResource;
2714 protected Resource createResourceFromYaml(Resource resource, String topologyTemplateYaml, String yamlName,
2715 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
2716 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
2717 boolean shouldLock, boolean inTransaction, String nodeName) {
2718 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
2719 Resource createdResource;
2721 ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic
2722 .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, resource);
2723 if (MapUtils.isEmpty(parsedToscaYamlInfo.getInstances()) && resource.getResourceType() != ResourceTypeEnum.PNF) {
2724 throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2726 log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", resource.getName());
2727 createdResource = createResourceAndRIsFromYaml(yamlName, resource, parsedToscaYamlInfo, AuditingActionEnum.IMPORT_RESOURCE, false,
2728 createdArtifacts, topologyTemplateYaml, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName);
2729 log.debug("#createResourceFromYaml - The resource {} has been created ", resource.getName());
2730 } catch (ComponentException e) {
2731 ResponseFormat responseFormat =
2732 e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
2733 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
2735 } catch (StorageException e) {
2736 ResponseFormat responseFormat = componentsUtils
2737 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
2738 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
2741 return createdResource;
2744 protected Resource createResourceAndRIsFromYaml(String yamlName, Resource resource, ParsedToscaYamlInfo parsedToscaYamlInfo,
2745 AuditingActionEnum actionEnum, boolean isNormative, List<ArtifactDefinition> createdArtifacts,
2746 String topologyTemplateYaml, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
2747 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
2748 boolean shouldLock, boolean inTransaction, String nodeName) {
2749 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2751 Either<Boolean, ResponseFormat> lockResult = serviceBusinessLogic
2752 .lockComponentByName(resource.getSystemName(), resource, CREATE_RESOURCE);
2753 if (lockResult.isRight()) {
2754 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2755 throw new ComponentException(lockResult.right().value());
2757 log.debug("name is locked {} status = {}", resource.getSystemName(), lockResult);
2760 log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
2761 Resource genericResource = serviceBusinessLogic.fetchAndSetDerivedFromGenericType(resource);
2762 resource = createResourceTransaction(resource, csarInfo.getModifier(), isNormative);
2763 log.trace("************* Going to add inputs from yaml {}", yamlName);
2764 Map<String, Object> yamlMap = ImportUtils.loadYamlAsStrictMap(csarInfo.getMainTemplateContent());
2765 Map<String, Object> metadata = (Map<String, Object>) yamlMap.get("metadata");
2766 String type = (String) metadata.get("type");
2767 if (resource.shouldGenerateInputs() && !"Service".equalsIgnoreCase(type)) {
2768 serviceBusinessLogic.generateAndAddInputsFromGenericTypeProperties(resource, genericResource);
2770 Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
2771 resource = serviceImportParseLogic.createInputsOnResource(resource, inputs);
2772 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances();
2773 resource = createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap, topologyTemplateYaml,
2774 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName);
2775 log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName);
2776 // validate update vf module group names
2777 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic.validateUpdateVfGroupNames(
2778 parsedToscaYamlInfo.getGroups(), resource.getSystemName());
2779 if (validateUpdateVfGroupNamesRes.isRight()) {
2780 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2781 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
2783 Map<String, GroupDefinition> groups;
2784 log.trace("************* Going to add groups from yaml {}", yamlName);
2785 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
2786 groups = validateUpdateVfGroupNamesRes.left().value();
2788 groups = parsedToscaYamlInfo.getGroups();
2790 Either<Resource, ResponseFormat> createGroupsOnResource = createGroupsOnResource(resource, groups);
2791 if (createGroupsOnResource.isRight()) {
2792 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2793 throw new ComponentException(createGroupsOnResource.right().value());
2795 resource = createGroupsOnResource.left().value();
2796 log.trace("************* Going to add artifacts from yaml {}", yamlName);
2797 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
2798 Either<Resource, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
2799 createdArtifacts, yamlName, csarInfo, resource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
2800 if (createArtifactsEither.isRight()) {
2801 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2802 throw new ComponentException(createArtifactsEither.right().value());
2804 resource = serviceImportParseLogic.getResourceWithGroups(createArtifactsEither.left().value().getUniqueId());
2805 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.CREATED);
2806 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, actionEnum);
2807 ASDCKpiApi.countCreatedResourcesKPI();
2809 } catch (ComponentException | StorageException e) {
2810 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2813 if (!inTransaction) {
2814 janusGraphDao.commit();
2817 graphLockOperation.unlockComponentByName(resource.getSystemName(), resource.getUniqueId(), NodeTypeEnum.Resource);
2822 protected Either<Resource, ResponseFormat> createGroupsOnResource(Resource resource, Map<String, GroupDefinition> groups) {
2823 if (groups != null && !groups.isEmpty()) {
2824 List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, resource);
2825 serviceImportParseLogic.handleGroupsProperties(resource, groups);
2826 serviceImportParseLogic.fillGroupsFinalFields(groupsAsList);
2827 Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic.createGroups(resource, groupsAsList, true);
2828 if (createGroups.isRight()) {
2829 return Either.right(createGroups.right().value());
2832 return Either.left(resource);
2834 Either<Resource, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
2835 if (updatedResource.isRight()) {
2836 ResponseFormat responseFormat = componentsUtils
2837 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), resource);
2838 return Either.right(responseFormat);
2840 return Either.left(updatedResource.left().value());
2843 protected List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups, Resource component) {
2844 List<GroupDefinition> result = new ArrayList<>();
2845 List<ComponentInstance> componentInstances = component.getComponentInstances();
2846 if (groups != null) {
2847 for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
2848 String groupName = entry.getKey();
2849 GroupDefinition groupDefinition = entry.getValue();
2850 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
2851 updatedGroupDefinition.setMembers(null);
2852 Map<String, String> members = groupDefinition.getMembers();
2853 if (members != null) {
2854 updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
2856 result.add(updatedGroupDefinition);
2862 protected void updateGroupMembers(Map<String, GroupDefinition> groups, GroupDefinition updatedGroupDefinition, Resource component,
2863 List<ComponentInstance> componentInstances, String groupName, Map<String, String> members) {
2864 Set<String> compInstancesNames = members.keySet();
2865 if (CollectionUtils.isEmpty(componentInstances)) {
2866 String membersAstString = compInstancesNames.stream().collect(joining(","));
2867 log.debug("The members: {}, in group: {}, cannot be found in component {}. There are no component instances.", membersAstString,
2868 groupName, component.getNormalizedName());
2869 throw new ComponentException(componentsUtils
2870 .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(),
2871 serviceImportParseLogic.getComponentTypeForResponse(component)));
2873 Map<String, String> memberNames = componentInstances.stream().collect(toMap(ComponentInstance::getName, ComponentInstance::getUniqueId));
2874 memberNames.putAll(groups.keySet().stream().collect(toMap(g -> g, g -> "")));
2875 Map<String, String> relevantInstances = memberNames.entrySet().stream().filter(n -> compInstancesNames.contains(n.getKey()))
2876 .collect(toMap(Map.Entry::getKey, Map.Entry::getValue));
2877 if (relevantInstances == null || relevantInstances.size() != compInstancesNames.size()) {
2878 List<String> foundMembers = new ArrayList<>();
2879 if (relevantInstances != null) {
2880 foundMembers = relevantInstances.keySet().stream().collect(toList());
2882 compInstancesNames.removeAll(foundMembers);
2883 String membersAstString = compInstancesNames.stream().collect(joining(","));
2884 throw new ComponentException(componentsUtils
2885 .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(),
2886 serviceImportParseLogic.getComponentTypeForResponse(component)));
2888 updatedGroupDefinition.setMembers(relevantInstances);
2891 protected Resource createResourceTransaction(Resource resource, User user, boolean isNormative) {
2892 Either<Boolean, StorageOperationStatus> eitherValidation = toscaOperationFacade
2893 .validateComponentNameExists(resource.getName(), resource.getResourceType(), resource.getComponentType());
2894 if (eitherValidation.isRight()) {
2895 ResponseFormat errorResponse = componentsUtils
2896 .getResponseFormat(componentsUtils.convertFromStorageResponse(eitherValidation.right().value()));
2897 throw new ComponentException(errorResponse);
2899 if (Boolean.TRUE.equals(eitherValidation.left().value())) {
2900 log.debug("resource with name: {}, already exists", resource.getName());
2901 ResponseFormat errorResponse = componentsUtils
2902 .getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resource.getName());
2903 throw new ComponentException(errorResponse);
2905 log.debug("send resource {} to dao for create", resource.getName());
2906 serviceImportParseLogic.createArtifactsPlaceHolderData(resource, user);
2908 log.debug("enrich resource with creator, version and state");
2909 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2910 resource.setVersion(INITIAL_VERSION);
2911 resource.setHighestVersion(true);
2912 if (resource.getResourceType() != null && resource.getResourceType() != ResourceTypeEnum.VF) {
2913 resource.setAbstract(false);
2916 return toscaOperationFacade.createToscaComponent(resource).left()
2917 .on(r -> serviceImportParseLogic.throwComponentExceptionByResource(r, resource));
2920 protected ImmutablePair<Resource, ActionStatus> updateExistingResourceByImport(Resource newResource, Resource oldResource, User user,
2921 boolean inTransaction, boolean needLock, boolean isNested) {
2922 String lockedResourceId = oldResource.getUniqueId();
2923 log.debug("found resource: name={}, id={}, version={}, state={}", oldResource.getName(), lockedResourceId, oldResource.getVersion(),
2924 oldResource.getLifecycleState());
2925 ImmutablePair<Resource, ActionStatus> resourcePair = null;
2927 serviceBusinessLogic.lockComponent(lockedResourceId, oldResource, needLock, "Update Resource by Import");
2928 oldResource = serviceImportParseLogic.prepareResourceForUpdate(oldResource, newResource, user, inTransaction, false);
2929 serviceImportParseLogic.mergeOldResourceMetadataWithNew(oldResource, newResource);
2930 serviceImportParseLogic.validateResourceFieldsBeforeUpdate(oldResource, newResource, inTransaction, isNested);
2931 serviceImportParseLogic.validateCapabilityTypesCreate(user, serviceImportParseLogic.getCapabilityTypeOperation(), newResource,
2932 AuditingActionEnum.IMPORT_RESOURCE, inTransaction);
2933 createNewResourceToOldResource(newResource, oldResource, user);
2934 Either<Resource, StorageOperationStatus> overrideResource = toscaOperationFacade.overrideComponent(newResource, oldResource);
2935 if (overrideResource.isRight()) {
2936 ResponseFormat responseFormat = new ResponseFormat();
2937 serviceBusinessLogic.throwComponentException(responseFormat);
2939 log.debug("Resource updated successfully!!!");
2940 resourcePair = new ImmutablePair<>(overrideResource.left().value(), ActionStatus.OK);
2941 return resourcePair;
2943 if (resourcePair == null) {
2944 BeEcompErrorManager.getInstance().logBeSystemError("Change LifecycleState - Certify");
2945 janusGraphDao.rollback();
2946 } else if (!inTransaction) {
2947 janusGraphDao.commit();
2950 log.debug("unlock resource {}", lockedResourceId);
2951 graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource);
2956 protected void createNewResourceToOldResource(Resource newResource, Resource oldResource, User user) {
2957 newResource.setContactId(newResource.getContactId().toLowerCase());
2958 newResource.setCreatorUserId(user.getUserId());
2959 newResource.setCreatorFullName(user.getFullName());
2960 newResource.setLastUpdaterUserId(user.getUserId());
2961 newResource.setLastUpdaterFullName(user.getFullName());
2962 newResource.setUniqueId(oldResource.getUniqueId());
2963 newResource.setVersion(oldResource.getVersion());
2964 newResource.setInvariantUUID(oldResource.getInvariantUUID());
2965 newResource.setLifecycleState(oldResource.getLifecycleState());
2966 newResource.setUUID(oldResource.getUUID());
2967 newResource.setNormalizedName(oldResource.getNormalizedName());
2968 newResource.setSystemName(oldResource.getSystemName());
2969 if (oldResource.getCsarUUID() != null) {
2970 newResource.setCsarUUID(oldResource.getCsarUUID());
2972 if (oldResource.getCsarVersionId() != null) {
2973 newResource.setCsarVersionId(oldResource.getCsarVersionId());
2975 if (oldResource.getImportedToscaChecksum() != null) {
2976 newResource.setImportedToscaChecksum(oldResource.getImportedToscaChecksum());
2978 if (newResource.getDerivedFromGenericType() == null || newResource.getDerivedFromGenericType().isEmpty()) {
2979 newResource.setDerivedFromGenericType(oldResource.getDerivedFromGenericType());
2981 if (newResource.getDerivedFromGenericVersion() == null || newResource.getDerivedFromGenericVersion().isEmpty()) {
2982 newResource.setDerivedFromGenericVersion(oldResource.getDerivedFromGenericVersion());
2984 if (newResource.getToscaArtifacts() == null || newResource.getToscaArtifacts().isEmpty()) {
2985 serviceBusinessLogic.setToscaArtifactsPlaceHolders(newResource, user);
2987 if (newResource.getInterfaces() == null || newResource.getInterfaces().isEmpty()) {
2988 newResource.setInterfaces(oldResource.getInterfaces());
2990 if (CollectionUtils.isEmpty(newResource.getProperties())) {
2991 newResource.setProperties(oldResource.getProperties());
2993 if (newResource.getModel() == null) {
2994 newResource.setModel(oldResource.getModel());
2998 protected Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Service service, Map<String, Object> mappedToscaTemplate,
3000 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
3001 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
3002 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
3004 Either<String, ImportUtils.ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
3005 TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
3006 if (toscaVersion.isRight()) {
3007 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
3009 Map<String, Object> mapToConvert = new HashMap<>();
3010 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value());
3011 Map<String, Object> nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate);
3012 createNodeTypes(yamlName, service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
3013 mapToConvert, nodeTypes);
3014 return csarInfo.getCreatedNodes();
3015 } catch (Exception e) {
3016 log.debug("Exception occured when createResourcesFromYamlNodeTypesList,error is:{}", e.getMessage(), e);
3017 throw new ComponentException(ActionStatus.GENERAL_ERROR);
3021 protected void createNodeTypes(String yamlName, Service service, boolean needLock,
3022 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
3023 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
3024 Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
3025 Iterator<Map.Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet().iterator();
3026 Resource vfcCreated = null;
3027 while (nodesNameValueIter.hasNext()) {
3028 Map.Entry<String, Object> nodeType = nodesNameValueIter.next();
3029 String nodeTypeKey = nodeType.getKey();
3030 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle =
3031 nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeTypeKey);
3032 if (nodeTypesInfo.containsKey(nodeTypeKey)) {
3033 vfcCreated = handleNestedVfc(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
3035 log.trace("************* Finished to handle nested vfc {}", nodeTypeKey);
3036 } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames()
3037 .containsKey(nodeTypeKey)) {
3038 ImmutablePair<Resource, ActionStatus> resourceCreated = serviceImportParseLogic
3039 .createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(), mapToConvert, service, needLock,
3040 nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true);
3041 log.debug("************* Finished to create node {}", nodeTypeKey);
3042 vfcCreated = resourceCreated.getLeft();
3043 csarInfo.getCreatedNodesToscaResourceNames().put(nodeTypeKey, vfcCreated.getName());
3045 if (vfcCreated != null) {
3046 csarInfo.getCreatedNodes().put(nodeTypeKey, vfcCreated);
3048 mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());