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.findFirstToscaStringElement;
23 import static org.openecomp.sdc.be.components.impl.ImportUtils.getPropertyJsonStringValue;
24 import static org.openecomp.sdc.be.tosca.CsarUtils.VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN;
26 import fj.data.Either;
27 import java.util.ArrayList;
28 import java.util.Collection;
29 import java.util.EnumMap;
30 import java.util.HashMap;
31 import java.util.HashSet;
32 import java.util.Iterator;
33 import java.util.List;
35 import java.util.Optional;
37 import java.util.regex.Pattern;
40 import org.apache.commons.collections.CollectionUtils;
41 import org.apache.commons.collections.MapUtils;
42 import org.apache.commons.lang3.tuple.ImmutablePair;
43 import org.openecomp.sdc.be.components.csar.CsarArtifactsAndGroupsBusinessLogic;
44 import org.openecomp.sdc.be.components.csar.CsarBusinessLogic;
45 import org.openecomp.sdc.be.components.csar.CsarInfo;
46 import org.openecomp.sdc.be.components.distribution.engine.IDistributionEngine;
47 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
48 import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
49 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
50 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
51 import org.openecomp.sdc.be.components.impl.utils.CINodeFilterUtils;
52 import org.openecomp.sdc.be.components.impl.utils.CreateServiceFromYamlParameter;
53 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
54 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
55 import org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic;
56 import org.openecomp.sdc.be.components.path.ForwardingPathValidator;
57 import org.openecomp.sdc.be.components.validation.NodeFilterValidator;
58 import org.openecomp.sdc.be.components.validation.ServiceDistributionValidation;
59 import org.openecomp.sdc.be.components.validation.component.ComponentContactIdValidator;
60 import org.openecomp.sdc.be.components.validation.component.ComponentDescriptionValidator;
61 import org.openecomp.sdc.be.components.validation.component.ComponentIconValidator;
62 import org.openecomp.sdc.be.components.validation.component.ComponentNameValidator;
63 import org.openecomp.sdc.be.components.validation.component.ComponentProjectCodeValidator;
64 import org.openecomp.sdc.be.components.validation.component.ComponentTagsValidator;
65 import org.openecomp.sdc.be.components.validation.component.ComponentValidator;
66 import org.openecomp.sdc.be.config.BeEcompErrorManager;
67 import org.openecomp.sdc.be.config.ConfigurationManager;
68 import org.openecomp.sdc.be.dao.api.ActionStatus;
69 import org.openecomp.sdc.be.datamodel.utils.ArtifactUtils;
70 import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter;
71 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
72 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
73 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
74 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
75 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
76 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
77 import org.openecomp.sdc.be.impl.ComponentsUtils;
78 import org.openecomp.sdc.be.info.NodeTypeInfoToUpdateArtifacts;
79 import org.openecomp.sdc.be.model.ArtifactDefinition;
80 import org.openecomp.sdc.be.model.AttributeDefinition;
81 import org.openecomp.sdc.be.model.CapabilityDefinition;
82 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
83 import org.openecomp.sdc.be.model.Component;
84 import org.openecomp.sdc.be.model.ComponentInstance;
85 import org.openecomp.sdc.be.model.ComponentInstanceInput;
86 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
87 import org.openecomp.sdc.be.model.ComponentParametersView;
88 import org.openecomp.sdc.be.model.DataTypeDefinition;
89 import org.openecomp.sdc.be.model.DistributionStatusEnum;
90 import org.openecomp.sdc.be.model.GroupDefinition;
91 import org.openecomp.sdc.be.model.InputDefinition;
92 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
93 import org.openecomp.sdc.be.model.LifecycleStateEnum;
94 import org.openecomp.sdc.be.model.NodeTypeInfo;
95 import org.openecomp.sdc.be.model.Operation;
96 import org.openecomp.sdc.be.model.ParsedToscaYamlInfo;
97 import org.openecomp.sdc.be.model.PropertyDefinition;
98 import org.openecomp.sdc.be.model.RelationshipImpl;
99 import org.openecomp.sdc.be.model.RelationshipInfo;
100 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
101 import org.openecomp.sdc.be.model.RequirementDefinition;
102 import org.openecomp.sdc.be.model.Resource;
103 import org.openecomp.sdc.be.model.Service;
104 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
105 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
106 import org.openecomp.sdc.be.model.UploadPropInfo;
107 import org.openecomp.sdc.be.model.UploadReqInfo;
108 import org.openecomp.sdc.be.model.UploadResourceInfo;
109 import org.openecomp.sdc.be.model.User;
110 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
111 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
112 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
113 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
114 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation;
115 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
116 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
117 import org.openecomp.sdc.be.model.operations.StorageException;
118 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
119 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
120 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
121 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
122 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
123 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
124 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
125 import org.openecomp.sdc.be.tosca.CsarUtils;
126 import org.openecomp.sdc.be.utils.TypeUtils;
127 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
128 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
129 import org.openecomp.sdc.common.api.Constants;
130 import org.openecomp.sdc.common.datastructure.Wrapper;
131 import org.openecomp.sdc.common.kpi.api.ASDCKpiApi;
132 import org.openecomp.sdc.common.log.wrappers.Logger;
133 import org.openecomp.sdc.common.util.ValidationUtils;
134 import org.openecomp.sdc.exception.ResponseFormat;
135 import org.springframework.beans.factory.annotation.Autowired;
136 import org.yaml.snakeyaml.Yaml;
140 @org.springframework.stereotype.Component("serviceImportBusinessLogic")
141 public class ServiceImportBusinessLogic {
143 private static final String INITIAL_VERSION = "0.1";
144 private static final String CREATE_RESOURCE = "Create Resource";
145 private static final String IN_RESOURCE = " in resource {} ";
146 private static final String COMPONENT_INSTANCE_WITH_NAME = "component instance with name ";
147 private static final String COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE = "component instance with name {} in resource {} ";
148 private static final String CERTIFICATION_ON_IMPORT = "certification on import";
149 private static final String VALIDATE_DERIVED_BEFORE_UPDATE = "validate derived before update";
150 private static final String PLACE_HOLDER_RESOURCE_TYPES = "validForResourceTypes";
151 private static final String CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES = "Create Resource - validateCapabilityTypesCreate";
152 private static final String CATEGORY_IS_EMPTY = "Resource category is empty";
153 private static final Logger log = Logger.getLogger(ServiceImportBusinessLogic.class);
154 private final UiComponentDataConverter uiComponentDataConverter;
155 private final ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
157 protected ComponentsUtils componentsUtils;
159 protected ToscaOperationFacade toscaOperationFacade;
161 private ServiceBusinessLogic serviceBusinessLogic;
163 private CsarBusinessLogic csarBusinessLogic;
165 private CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic;
167 private LifecycleBusinessLogic lifecycleBusinessLogic;
169 private CompositionBusinessLogic compositionBusinessLogic;
171 private ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic;
173 private ServiceImportParseLogic serviceImportParseLogic;
176 public ServiceImportBusinessLogic(IElementOperation elementDao, IGroupOperation groupOperation, IGroupInstanceOperation groupInstanceOperation,
177 IGroupTypeOperation groupTypeOperation, GroupBusinessLogic groupBusinessLogic,
178 InterfaceOperation interfaceOperation, InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
179 ArtifactsBusinessLogic artifactsBusinessLogic, IDistributionEngine distributionEngine,
180 ComponentInstanceBusinessLogic componentInstanceBusinessLogic,
181 ServiceDistributionValidation serviceDistributionValidation, ForwardingPathValidator forwardingPathValidator,
182 UiComponentDataConverter uiComponentDataConverter, NodeFilterOperation serviceFilterOperation,
183 NodeFilterValidator serviceFilterValidator, ArtifactsOperations artifactToscaOperation,
184 ComponentContactIdValidator componentContactIdValidator, ComponentNameValidator componentNameValidator,
185 ComponentTagsValidator componentTagsValidator, ComponentValidator componentValidator,
186 ComponentIconValidator componentIconValidator, ComponentProjectCodeValidator componentProjectCodeValidator,
187 ComponentDescriptionValidator componentDescriptionValidator) {
188 this.componentInstanceBusinessLogic = componentInstanceBusinessLogic;
189 this.uiComponentDataConverter = uiComponentDataConverter;
192 public ServiceBusinessLogic getServiceBusinessLogic() {
193 return serviceBusinessLogic;
196 public void setServiceBusinessLogic(ServiceBusinessLogic serviceBusinessLogic) {
197 this.serviceBusinessLogic = serviceBusinessLogic;
200 public Service createService(Service service, AuditingActionEnum auditingAction, User user, Map<String, byte[]> csarUIPayload,
201 String payloadName) {
202 log.debug("enter createService");
203 service.setCreatorUserId(user.getUserId());
204 service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
205 service.setVersion(INITIAL_VERSION);
206 service.setConformanceLevel(ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel());
207 service.setDistributionStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
208 service.setInstantiationType("A-la-carte");
209 service.setEnvironmentContext("General_Revenue-Bearing");
210 service.setEcompGeneratedNaming(true);
212 serviceBusinessLogic.validateServiceBeforeCreate(service, user, auditingAction);
213 log.debug("enter createService,validateServiceBeforeCreate success");
214 String csarUUID = payloadName == null ? service.getCsarUUID() : payloadName;
215 log.debug("enter createService,get csarUUID:{}", csarUUID);
216 csarBusinessLogic.validateCsarBeforeCreate(service, csarUUID);
217 log.debug("CsarUUID is {} - going to create resource from CSAR", csarUUID);
218 return createServiceFromCsar(service, user, csarUIPayload, csarUUID);
219 } catch (Exception e) {
220 log.debug("Exception occured when createService,error is:{}", e.getMessage(), e);
221 throw new ComponentException(ActionStatus.GENERAL_ERROR);
225 protected Service createServiceFromCsar(Service service, User user, Map<String, byte[]> csarUIPayload, String csarUUID) {
226 log.trace("************* created successfully from YAML, resource TOSCA ");
228 CsarInfo csarInfo = csarBusinessLogic.getCsarInfo(service, null, user, csarUIPayload, csarUUID);
229 Map<String, NodeTypeInfo> nodeTypesInfo = csarInfo.extractNodeTypesInfo();
230 Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandleRes = serviceImportParseLogic
231 .findNodeTypesArtifactsToHandle(nodeTypesInfo, csarInfo, service);
232 if (findNodeTypesArtifactsToHandleRes.isRight()) {
233 log.debug("failed to find node types for update with artifacts during import csar {}. ", csarInfo.getCsarUUID());
234 throw new ComponentException(findNodeTypesArtifactsToHandleRes.right().value());
236 return createServiceFromYaml(service, csarInfo.getMainTemplateContent(), csarInfo.getMainTemplateName(), nodeTypesInfo, csarInfo,
237 findNodeTypesArtifactsToHandleRes.left().value(), true, false, null);
238 } catch (Exception e) {
239 log.debug("Exception occured when createServiceFromCsar,error is:{}", e.getMessage(), e);
240 throw new ComponentException(ActionStatus.GENERAL_ERROR);
244 protected Service createServiceFromYaml(Service service, String topologyTemplateYaml, String yamlName, Map<String, NodeTypeInfo> nodeTypesInfo,
246 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
247 boolean shouldLock, boolean inTransaction, String nodeName) {
248 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
249 Service createdService;
250 CreateServiceFromYamlParameter csfyp = new CreateServiceFromYamlParameter();
252 ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic
253 .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, service);
254 if (MapUtils.isEmpty(parsedToscaYamlInfo.getInstances())) {
255 throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
257 log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", service.getName());
258 csfyp.setYamlName(yamlName);
259 csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
260 csfyp.setCreatedArtifacts(createdArtifacts);
261 csfyp.setTopologyTemplateYaml(topologyTemplateYaml);
262 csfyp.setNodeTypesInfo(nodeTypesInfo);
263 csfyp.setCsarInfo(csarInfo);
264 csfyp.setNodeName(nodeName);
265 createdService = createServiceAndRIsFromYaml(service, false, nodeTypesArtifactsToCreate, shouldLock, inTransaction, csfyp);
266 log.debug("#createResourceFromYaml - The resource {} has been created ", service.getName());
267 } catch (ComponentException e) {
268 log.debug("create Service From Yaml failed,get ComponentException:{}", e);
270 } catch (StorageException e) {
271 log.debug("create Service From Yaml failed,get StorageException:{}", e);
274 return createdService;
277 protected Service createServiceAndRIsFromYaml(Service service, boolean isNormative,
278 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
279 boolean shouldLock, boolean inTransaction, CreateServiceFromYamlParameter csfyp) {
280 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
281 String yamlName = csfyp.getYamlName();
282 ParsedToscaYamlInfo parsedToscaYamlInfo = csfyp.getParsedToscaYamlInfo();
283 List<ArtifactDefinition> createdArtifacts = csfyp.getCreatedArtifacts();
284 String topologyTemplateYaml = csfyp.getTopologyTemplateYaml();
285 Map<String, NodeTypeInfo> nodeTypesInfo = csfyp.getNodeTypesInfo();
286 CsarInfo csarInfo = csfyp.getCsarInfo();
287 String nodeName = csfyp.getNodeName();
289 Either<Boolean, ResponseFormat> lockResult = serviceBusinessLogic.lockComponentByName(service.getSystemName(), service, CREATE_RESOURCE);
290 if (lockResult.isRight()) {
291 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
292 throw new ComponentException(lockResult.right().value());
294 log.debug("name is locked {} status = {}", service.getSystemName(), lockResult);
297 log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
298 service = serviceImportParseLogic.createServiceTransaction(service, csarInfo.getModifier(), isNormative);
299 log.trace("************* Going to add inputs from yaml {}", yamlName);
300 Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
301 service = serviceImportParseLogic.createInputsOnService(service, inputs);
302 log.trace("************* Finish to add inputs from yaml {}", yamlName);
303 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances();
304 log.trace("************* Going to create nodes, RI's and Relations from yaml {}", yamlName);
305 service = createRIAndRelationsFromYaml(yamlName, service, uploadComponentInstanceInfoMap, topologyTemplateYaml,
306 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName);
307 log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName);
308 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = serviceBusinessLogic.groupBusinessLogic
309 .validateUpdateVfGroupNames(parsedToscaYamlInfo.getGroups(), service.getSystemName());
310 if (validateUpdateVfGroupNamesRes.isRight()) {
311 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
312 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
314 Map<String, GroupDefinition> groups;
315 log.trace("************* Going to add groups from yaml {}", yamlName);
316 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
317 groups = validateUpdateVfGroupNamesRes.left().value();
319 groups = parsedToscaYamlInfo.getGroups();
321 Either<Service, ResponseFormat> createGroupsOnResource = createGroupsOnResource(service, groups);
322 if (createGroupsOnResource.isRight()) {
323 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
324 throw new ComponentException(createGroupsOnResource.right().value());
326 service = createGroupsOnResource.left().value();
327 log.trace("************* Going to add artifacts from yaml {}", yamlName);
328 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
329 Either<Service, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
330 createdArtifacts, yamlName, csarInfo, service, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
331 if (createArtifactsEither.isRight()) {
332 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
333 throw new ComponentException(createArtifactsEither.right().value());
335 service = serviceImportParseLogic.getServiceWithGroups(createArtifactsEither.left().value().getUniqueId());
336 ASDCKpiApi.countCreatedResourcesKPI();
338 } catch (ComponentException | StorageException e) {
339 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
342 if (!inTransaction) {
343 serviceBusinessLogic.janusGraphDao.commit();
346 serviceBusinessLogic.graphLockOperation.unlockComponentByName(service.getSystemName(), service.getUniqueId(), NodeTypeEnum.Resource);
351 protected Either<Resource, ResponseFormat> createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum operation,
352 List<ArtifactDefinition> createdArtifacts, String yamlFileName,
353 CsarInfo csarInfo, Resource preparedResource,
354 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
355 boolean inTransaction, boolean shouldLock) {
356 String nodeName = nodeTypeInfoToUpdateArtifacts.getNodeName();
357 Resource resource = preparedResource;
358 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = nodeTypeInfoToUpdateArtifacts
359 .getNodeTypesArtifactsToHandle();
360 if (preparedResource.getResourceType() == ResourceTypeEnum.VF) {
361 if (nodeName != null && nodeTypesArtifactsToHandle.get(nodeName) != null && !nodeTypesArtifactsToHandle.get(nodeName).isEmpty()) {
362 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = handleNodeTypeArtifacts(preparedResource,
363 nodeTypesArtifactsToHandle.get(nodeName), createdArtifacts, csarInfo.getModifier(), inTransaction, true);
364 if (handleNodeTypeArtifactsRes.isRight()) {
365 return Either.right(handleNodeTypeArtifactsRes.right().value());
369 Either<Resource, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedResource, csarInfo, createdArtifacts,
370 new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction);
371 log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
372 if (createdCsarArtifactsEither.isRight()) {
373 return createdCsarArtifactsEither;
375 resource = createdCsarArtifactsEither.left().value();
377 return Either.left(resource);
380 protected Either<Resource, ResponseFormat> handleVfCsarArtifacts(Resource resource, CsarInfo csarInfo, List<ArtifactDefinition> createdArtifacts,
381 ArtifactOperationInfo artifactOperation, boolean shouldLock,
382 boolean inTransaction) {
383 if (csarInfo.getCsar() != null) {
384 createOrUpdateSingleNonMetaArtifactToComstants(resource, csarInfo, artifactOperation, shouldLock, inTransaction);
385 Either<Resource, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, resource, createdArtifacts, shouldLock,
386 inTransaction, artifactOperation);
387 if (eitherCreateResult.isRight()) {
388 return Either.right(eitherCreateResult.right().value());
390 Either<Resource, StorageOperationStatus> eitherGerResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
391 if (eitherGerResource.isRight()) {
392 ResponseFormat responseFormat = componentsUtils
393 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), resource);
394 return Either.right(responseFormat);
396 resource = eitherGerResource.left().value();
397 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
398 .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
399 if (artifacsMetaCsarStatus.isLeft()) {
400 return getResourceResponseFormatEither(resource, csarInfo, createdArtifacts, artifactOperation, shouldLock, inTransaction,
401 artifacsMetaCsarStatus);
403 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(resource, csarInfo, shouldLock, inTransaction);
406 return Either.left(resource);
409 protected void createOrUpdateSingleNonMetaArtifactToComstants(Resource resource, CsarInfo csarInfo, ArtifactOperationInfo artifactOperation,
410 boolean shouldLock, boolean inTransaction) {
411 String vendorLicenseModelId = null;
412 String vfLicenseModelId = null;
413 if (artifactOperation.getArtifactOperationEnum() == ArtifactOperationEnum.UPDATE) {
414 Map<String, ArtifactDefinition> deploymentArtifactsMap = resource.getDeploymentArtifacts();
415 if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
416 for (Map.Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
417 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
418 vendorLicenseModelId = artifactEntry.getValue().getUniqueId();
420 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
421 vfLicenseModelId = artifactEntry.getValue().getUniqueId();
426 createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL,
427 Constants.VENDOR_LICENSE_MODEL, ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
428 Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME, Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId,
429 artifactOperation, null, true, shouldLock, inTransaction);
430 createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
431 ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL, Constants.VF_LICENSE_DISPLAY_NAME,
432 Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId, artifactOperation, null, true, shouldLock, inTransaction);
435 protected Either<Resource, ResponseFormat> getResourceResponseFormatEither(Resource resource, CsarInfo csarInfo,
436 List<ArtifactDefinition> createdArtifacts,
437 ArtifactOperationInfo artifactOperation, boolean shouldLock,
438 boolean inTransaction,
439 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus) {
441 String artifactsFileName = artifacsMetaCsarStatus.left().value().getKey();
442 String artifactsContents = artifacsMetaCsarStatus.left().value().getValue();
443 Either<Resource, ResponseFormat> createArtifactsFromCsar;
444 if (ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
445 createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic
446 .createResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts);
448 Either<Component, ResponseFormat> result = csarArtifactsAndGroupsBusinessLogic
449 .updateResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
451 if ((result.left().value() instanceof Resource) && result.isLeft()) {
452 Resource service1 = (Resource) result.left().value();
453 createArtifactsFromCsar = Either.left(service1);
455 createArtifactsFromCsar = Either.right(result.right().value());
458 if (createArtifactsFromCsar.isRight()) {
459 log.debug("Couldn't create artifacts from artifacts.meta");
460 return Either.right(createArtifactsFromCsar.right().value());
462 return Either.left(createArtifactsFromCsar.left().value());
463 } catch (Exception e) {
464 log.debug("Exception occured in getResourceResponseFormatEither, message:{}", e.getMessage(), e);
465 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
469 private <T extends Component> Either<T, ResponseFormat> createOrUpdateNonMetaArtifactsComp(CsarInfo csarInfo, T component,
470 List<ArtifactDefinition> createdArtifacts,
471 boolean shouldLock, boolean inTransaction,
472 ArtifactOperationInfo artifactOperation) {
473 Either<T, ResponseFormat> resStatus = null;
474 Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
476 Either<List<CsarUtils.NonMetaArtifactInfo>, String> artifactPathAndNameList = getValidArtifactNames(csarInfo, collectedWarningMessages);
477 if (artifactPathAndNameList.isRight()) {
479 getComponentsUtils().getResponseFormatByArtifactId(ActionStatus.ARTIFACT_NAME_INVALID, artifactPathAndNameList.right().value()));
481 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = null;
482 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
483 vfCsarArtifactsToHandle = new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
484 vfCsarArtifactsToHandle.put(artifactOperation.getArtifactOperationEnum(), artifactPathAndNameList.left().value());
486 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandleRes = findVfCsarArtifactsToHandle(
487 component, artifactPathAndNameList.left().value(), csarInfo.getModifier());
488 if (findVfCsarArtifactsToHandleRes.isRight()) {
489 resStatus = Either.right(findVfCsarArtifactsToHandleRes.right().value());
491 if (resStatus == null) {
492 vfCsarArtifactsToHandle = findVfCsarArtifactsToHandleRes.left().value();
495 if (resStatus == null && vfCsarArtifactsToHandle != null) {
496 resStatus = processCsarArtifacts(csarInfo, component, createdArtifacts, shouldLock, inTransaction, resStatus,
497 vfCsarArtifactsToHandle);
499 if (resStatus == null) {
500 resStatus = Either.left(component);
502 } catch (Exception e) {
503 resStatus = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
504 log.debug("Exception occured in createNonMetaArtifacts, message:{}", e.getMessage(), e);
506 CsarUtils.handleWarningMessages(collectedWarningMessages);
511 protected Either<Resource, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Resource resource,
512 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
513 boolean inTransaction, ArtifactOperationInfo artifactOperation) {
514 return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation);
517 protected <T extends Component> Either<T, ResponseFormat> processCsarArtifacts(CsarInfo csarInfo, Component comp,
518 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
519 boolean inTransaction, Either<T, ResponseFormat> resStatus,
520 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle) {
521 for (Map.Entry<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> currArtifactOperationPair : vfCsarArtifactsToHandle
523 Optional<ResponseFormat> optionalCreateInDBError = currArtifactOperationPair.getValue().stream().map(
524 e -> createOrUpdateSingleNonMetaArtifact(comp, csarInfo, e.getPath(), e.getArtifactName(), e.getArtifactType(),
525 e.getArtifactGroupType(), e.getArtifactLabel(), e.getDisplayName(), CsarUtils.ARTIFACT_CREATED_FROM_CSAR, e.getArtifactUniqueId(),
526 new ArtifactOperationInfo(false, false, currArtifactOperationPair.getKey()), createdArtifacts, e.isFromCsar(), shouldLock,
527 inTransaction)).filter(Either::isRight).map(e -> e.right().value()).findAny();
528 if (optionalCreateInDBError.isPresent()) {
529 resStatus = Either.right(optionalCreateInDBError.get());
536 protected Either<Boolean, ResponseFormat> createOrUpdateSingleNonMetaArtifact(Component component, CsarInfo csarInfo, String artifactPath,
537 String artifactFileName, String artifactType,
538 ArtifactGroupTypeEnum artifactGroupType, String artifactLabel,
539 String artifactDisplayName, String artifactDescription,
540 String artifactId, ArtifactOperationInfo operation,
541 List<ArtifactDefinition> createdArtifacts, boolean isFromCsar,
542 boolean shouldLock, boolean inTransaction) {
543 byte[] artifactFileBytes = null;
544 if (csarInfo.getCsar().containsKey(artifactPath)) {
545 artifactFileBytes = csarInfo.getCsar().get(artifactPath);
547 Either<Boolean, ResponseFormat> result = Either.left(true);
548 if (operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE
549 || operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE) {
550 if (serviceImportParseLogic.isArtifactDeletionRequired(artifactId, artifactFileBytes, isFromCsar)) {
551 Either<ArtifactDefinition, ResponseFormat> handleDelete = serviceBusinessLogic.artifactsBusinessLogic
552 .handleDelete(component.getUniqueId(), artifactId, csarInfo.getModifier(), component, shouldLock, inTransaction);
553 if (handleDelete.isRight()) {
554 result = Either.right(handleDelete.right().value());
558 if (org.apache.commons.lang.StringUtils.isEmpty(artifactId) && artifactFileBytes != null) {
559 operation = new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
562 if (artifactFileBytes != null) {
563 Map<String, Object> vendorLicenseModelJson = ArtifactUtils
564 .buildJsonForUpdateArtifact(artifactId, artifactFileName, artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
565 artifactDescription, artifactFileBytes, null, isFromCsar);
566 Either<Either<ArtifactDefinition, Operation>, ResponseFormat> eitherNonMetaArtifacts = csarArtifactsAndGroupsBusinessLogic
567 .createOrUpdateCsarArtifactFromJson(component, csarInfo.getModifier(), vendorLicenseModelJson, operation);
568 serviceImportParseLogic.addNonMetaCreatedArtifactsToSupportRollback(operation, createdArtifacts, eitherNonMetaArtifacts);
569 if (eitherNonMetaArtifacts.isRight()) {
570 BeEcompErrorManager.getInstance().logInternalFlowError("UploadLicenseArtifact",
571 "Failed to upload license artifact: " + artifactFileName + "With csar uuid: " + csarInfo.getCsarUUID(),
572 BeEcompErrorManager.ErrorSeverity.WARNING);
573 return Either.right(eitherNonMetaArtifacts.right().value());
579 public Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifacts(Resource nodeTypeResource,
580 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
581 List<ArtifactDefinition> createdArtifacts, User user,
582 boolean inTransaction, boolean ignoreLifecycleState) {
583 List<ArtifactDefinition> handleNodeTypeArtifactsRequestRes;
584 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = null;
585 Either<Resource, ResponseFormat> changeStateResponse;
587 changeStateResponse = checkoutResource(nodeTypeResource, user, inTransaction);
588 if (changeStateResponse.isRight()) {
589 return Either.right(changeStateResponse.right().value());
591 nodeTypeResource = changeStateResponse.left().value();
592 List<ArtifactDefinition> handledNodeTypeArtifacts = new ArrayList<>();
593 log.debug("************* Going to handle artifacts of node type resource {}. ", nodeTypeResource.getName());
594 for (Map.Entry<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> curOperationEntry : nodeTypeArtifactsToHandle
596 ArtifactsBusinessLogic.ArtifactOperationEnum curOperation = curOperationEntry.getKey();
597 List<ArtifactDefinition> curArtifactsToHandle = curOperationEntry.getValue();
598 if (curArtifactsToHandle != null && !curArtifactsToHandle.isEmpty()) {
599 log.debug("************* Going to {} artifact to vfc {}", curOperation.name(), nodeTypeResource.getName());
600 handleNodeTypeArtifactsRequestRes = serviceBusinessLogic.artifactsBusinessLogic
601 .handleArtifactsRequestForInnerVfcComponent(curArtifactsToHandle, nodeTypeResource, user, createdArtifacts,
602 new ArtifactOperationInfo(false, ignoreLifecycleState, curOperation), false, inTransaction);
603 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(curOperation)) {
604 createdArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
606 handledNodeTypeArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
609 if (handleNodeTypeArtifactsRes == null) {
610 handleNodeTypeArtifactsRes = Either.left(handledNodeTypeArtifacts);
612 } catch (Exception e) {
613 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
614 handleNodeTypeArtifactsRes = Either.right(responseFormat);
615 log.debug("Exception occured when handleVfcArtifacts, error is:{}", e.getMessage(), e);
617 return handleNodeTypeArtifactsRes;
620 protected Either<Resource, ResponseFormat> checkoutResource(Resource resource, User user, boolean inTransaction) {
621 Either<Resource, ResponseFormat> checkoutResourceRes;
623 if (!resource.getComponentMetadataDefinition().getMetadataDataDefinition().getState()
624 .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
625 Either<? extends Component, ResponseFormat> checkoutRes = lifecycleBusinessLogic
626 .changeComponentState(resource.getComponentType(), resource.getUniqueId(), user, LifeCycleTransitionEnum.CHECKOUT,
627 new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
628 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR), inTransaction, true);
629 if (checkoutRes.isRight()) {
630 checkoutResourceRes = Either.right(checkoutRes.right().value());
632 checkoutResourceRes = Either.left((Resource) checkoutRes.left().value());
635 checkoutResourceRes = Either.left(resource);
637 } catch (Exception e) {
638 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
639 checkoutResourceRes = Either.right(responseFormat);
640 log.debug("Exception occured when checkoutResource {} , error is:{}", resource.getName(), e.getMessage(), e);
642 return checkoutResourceRes;
645 protected Either<Service, ResponseFormat> createOrUpdateArtifacts(ArtifactOperationEnum operation, List<ArtifactDefinition> createdArtifacts,
646 String yamlFileName, CsarInfo csarInfo, Service preparedService,
647 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
648 boolean inTransaction, boolean shouldLock) {
649 Either<Service, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedService, csarInfo, createdArtifacts,
650 new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction);
651 log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
652 if (createdCsarArtifactsEither.isRight()) {
653 return createdCsarArtifactsEither;
655 return Either.left(createdCsarArtifactsEither.left().value());
658 protected Either<Service, ResponseFormat> handleVfCsarArtifacts(Service service, CsarInfo csarInfo, List<ArtifactDefinition> createdArtifacts,
659 ArtifactOperationInfo artifactOperation, boolean shouldLock,
660 boolean inTransaction) {
661 if (csarInfo.getCsar() != null) {
662 String vendorLicenseModelId = null;
663 String vfLicenseModelId = null;
664 if (artifactOperation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE) {
665 Map<String, ArtifactDefinition> deploymentArtifactsMap = service.getDeploymentArtifacts();
666 if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
667 for (Map.Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
668 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
669 vendorLicenseModelId = artifactEntry.getValue().getUniqueId();
671 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
672 vfLicenseModelId = artifactEntry.getValue().getUniqueId();
677 createOrUpdateSingleNonMetaArtifact(service, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL,
678 Constants.VENDOR_LICENSE_MODEL, ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
679 Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME, Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId,
680 artifactOperation, null, true, shouldLock, inTransaction);
681 createOrUpdateSingleNonMetaArtifact(service, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
682 ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL,
683 Constants.VF_LICENSE_DISPLAY_NAME, Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId, artifactOperation, null, true, shouldLock,
685 Either<Service, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, service, createdArtifacts, shouldLock,
686 inTransaction, artifactOperation);
687 if (eitherCreateResult.isRight()) {
688 return Either.right(eitherCreateResult.right().value());
690 Either<Service, StorageOperationStatus> eitherGerResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
691 if (eitherGerResource.isRight()) {
692 ResponseFormat responseFormat = componentsUtils
693 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), service,
694 ComponentTypeEnum.SERVICE);
695 return Either.right(responseFormat);
697 service = eitherGerResource.left().value();
698 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
699 .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
700 if (artifacsMetaCsarStatus.isLeft()) {
701 String artifactsFileName = artifacsMetaCsarStatus.left().value().getKey();
702 String artifactsContents = artifacsMetaCsarStatus.left().value().getValue();
703 Either<Service, ResponseFormat> createArtifactsFromCsar;
704 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
705 createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic
706 .createResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts);
708 Either<Component, ResponseFormat> result = csarArtifactsAndGroupsBusinessLogic
709 .updateResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
711 if ((result.left().value() instanceof Service) && result.isLeft()) {
712 Service service1 = (Service) result.left().value();
713 createArtifactsFromCsar = Either.left(service1);
715 createArtifactsFromCsar = Either.right(result.right().value());
718 if (createArtifactsFromCsar.isRight()) {
719 log.debug("Couldn't create artifacts from artifacts.meta");
720 return Either.right(createArtifactsFromCsar.right().value());
722 return Either.left(createArtifactsFromCsar.left().value());
724 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(service, csarInfo, shouldLock, inTransaction);
727 return Either.left(service);
730 protected Either<Service, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Service resource,
731 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
732 boolean inTransaction, ArtifactOperationInfo artifactOperation) {
733 return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation);
736 protected Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandle(
737 Component component, List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList, User user) {
738 List<ArtifactDefinition> existingArtifacts = new ArrayList<>();
739 if (component.getDeploymentArtifacts() != null && !component.getDeploymentArtifacts().isEmpty()) {
740 existingArtifacts.addAll(component.getDeploymentArtifacts().values());
742 if (component.getArtifacts() != null && !component.getArtifacts().isEmpty()) {
743 existingArtifacts.addAll(component.getArtifacts().values());
745 existingArtifacts = existingArtifacts.stream().filter(this::isNonMetaArtifact).collect(toList());
746 List<String> artifactsToIgnore = new ArrayList<>();
747 if (component.getGroups() != null) {
748 component.getGroups().forEach(g -> {
749 if (g.getArtifacts() != null && !g.getArtifacts().isEmpty()) {
750 artifactsToIgnore.addAll(g.getArtifacts());
754 existingArtifacts = existingArtifacts.stream().filter(a -> !artifactsToIgnore.contains(a.getUniqueId())).collect(toList());
755 return organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifacts, component, user);
758 protected boolean isNonMetaArtifact(ArtifactDefinition artifact) {
759 boolean result = true;
760 if (artifact.getMandatory() || artifact.getArtifactName() == null || !isValidArtifactType(artifact)) {
766 private boolean isValidArtifactType(ArtifactDefinition artifact) {
767 boolean result = true;
768 if (artifact.getArtifactType() == null || ArtifactTypeEnum.findType(artifact.getArtifactType()).equals(ArtifactTypeEnum.VENDOR_LICENSE)
769 || ArtifactTypeEnum.findType(artifact.getArtifactType()).equals(ArtifactTypeEnum.VF_LICENSE)) {
775 protected Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> organizeVfCsarArtifactsByArtifactOperation(
776 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList, List<ArtifactDefinition> existingArtifactsToHandle, Component component,
778 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> nodeTypeArtifactsToHandle = new EnumMap<>(
779 ArtifactsBusinessLogic.ArtifactOperationEnum.class);
780 Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
781 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> nodeTypeArtifactsToHandleRes = Either
782 .left(nodeTypeArtifactsToHandle);
784 List<CsarUtils.NonMetaArtifactInfo> artifactsToUpload = new ArrayList<>(artifactPathAndNameList);
785 List<CsarUtils.NonMetaArtifactInfo> artifactsToUpdate = new ArrayList<>();
786 List<CsarUtils.NonMetaArtifactInfo> artifactsToDelete = new ArrayList<>();
787 for (CsarUtils.NonMetaArtifactInfo currNewArtifact : artifactPathAndNameList) {
788 ArtifactDefinition foundArtifact;
789 if (!existingArtifactsToHandle.isEmpty()) {
790 foundArtifact = existingArtifactsToHandle.stream().filter(a -> a.getArtifactName().equals(currNewArtifact.getArtifactName()))
791 .findFirst().orElse(null);
792 if (foundArtifact != null) {
793 if (ArtifactTypeEnum.findType(foundArtifact.getArtifactType()).equals(currNewArtifact.getArtifactType())) {
794 if (!foundArtifact.getArtifactChecksum().equals(currNewArtifact.getArtifactChecksum())) {
795 currNewArtifact.setArtifactUniqueId(foundArtifact.getUniqueId());
796 artifactsToUpdate.add(currNewArtifact);
798 existingArtifactsToHandle.remove(foundArtifact);
799 artifactsToUpload.remove(currNewArtifact);
801 log.debug("Can't upload two artifact with the same name {}.", currNewArtifact.getArtifactName());
802 ResponseFormat responseFormat = ResponseFormatManager.getInstance()
803 .getResponseFormat(ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, currNewArtifact.getArtifactName(),
804 currNewArtifact.getArtifactType(), foundArtifact.getArtifactType());
805 AuditingActionEnum auditingAction = serviceBusinessLogic.artifactsBusinessLogic
806 .detectAuditingType(new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE),
807 foundArtifact.getArtifactChecksum());
808 serviceBusinessLogic.artifactsBusinessLogic
809 .handleAuditing(auditingAction, component, component.getUniqueId(), user, null, null, foundArtifact.getUniqueId(),
810 responseFormat, component.getComponentType(), null);
811 responseWrapper.setInnerElement(responseFormat);
817 if (responseWrapper.isEmpty()) {
818 for (ArtifactDefinition currArtifact : existingArtifactsToHandle) {
819 if (currArtifact.getIsFromCsar()) {
820 artifactsToDelete.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
821 ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null,
822 currArtifact.getUniqueId(), currArtifact.getIsFromCsar()));
824 artifactsToUpdate.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
825 ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null,
826 currArtifact.getUniqueId(), currArtifact.getIsFromCsar()));
830 if (responseWrapper.isEmpty()) {
831 if (!artifactsToUpload.isEmpty()) {
832 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, artifactsToUpload);
834 if (!artifactsToUpdate.isEmpty()) {
835 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE, artifactsToUpdate);
837 if (!artifactsToDelete.isEmpty()) {
838 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE, artifactsToDelete);
841 if (!responseWrapper.isEmpty()) {
842 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
844 } catch (Exception e) {
845 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
846 responseWrapper.setInnerElement(responseFormat);
847 log.debug("Exception occured when findNodeTypeArtifactsToHandle, error is:{}", e.getMessage(), e);
848 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
850 return nodeTypeArtifactsToHandleRes;
853 public ComponentsUtils getComponentsUtils() {
854 return this.componentsUtils;
857 public void setComponentsUtils(ComponentsUtils componentsUtils) {
858 this.componentsUtils = componentsUtils;
861 protected Either<List<CsarUtils.NonMetaArtifactInfo>, String> getValidArtifactNames(CsarInfo csarInfo,
862 Map<String, Set<List<String>>> collectedWarningMessages) {
863 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = csarInfo.getCsar().entrySet().stream()
864 .filter(e -> Pattern.compile(VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN).matcher(e.getKey()).matches())
865 .map(e -> CsarUtils.validateNonMetaArtifact(e.getKey(), e.getValue(), collectedWarningMessages)).filter(Either::isLeft)
866 .map(e -> e.left().value()).collect(toList());
867 Pattern englishNumbersAndUnderScoresOnly = Pattern.compile(CsarUtils.VALID_ENGLISH_ARTIFACT_NAME);
868 for (CsarUtils.NonMetaArtifactInfo nonMetaArtifactInfo : artifactPathAndNameList) {
869 if (!englishNumbersAndUnderScoresOnly.matcher(nonMetaArtifactInfo.getDisplayName()).matches()) {
870 return Either.right(nonMetaArtifactInfo.getArtifactName());
873 return Either.left(artifactPathAndNameList);
876 protected Either<Service, ResponseFormat> createGroupsOnResource(Service service, Map<String, GroupDefinition> groups) {
877 if (groups != null && !groups.isEmpty()) {
878 List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, service);
879 serviceImportParseLogic.handleGroupsProperties(service, groups);
880 serviceImportParseLogic.fillGroupsFinalFields(groupsAsList);
881 Either<List<GroupDefinition>, ResponseFormat> createGroups = serviceBusinessLogic.groupBusinessLogic
882 .createGroups(service, groupsAsList, true);
883 if (createGroups.isRight()) {
884 return Either.right(createGroups.right().value());
887 return Either.left(service);
889 Either<Service, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
890 if (updatedResource.isRight()) {
891 ResponseFormat responseFormat = componentsUtils
892 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), service,
893 ComponentTypeEnum.SERVICE);
894 return Either.right(responseFormat);
896 return Either.left(updatedResource.left().value());
899 protected List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups, Service component) {
900 List<GroupDefinition> result = new ArrayList<>();
901 List<ComponentInstance> componentInstances = component.getComponentInstances();
902 if (groups != null) {
903 Either<Boolean, ResponseFormat> validateCyclicGroupsDependencies = serviceImportParseLogic.validateCyclicGroupsDependencies(groups);
904 if (validateCyclicGroupsDependencies.isRight()) {
905 throw new ComponentException(validateCyclicGroupsDependencies.right().value());
907 for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
908 String groupName = entry.getKey();
909 GroupDefinition groupDefinition = entry.getValue();
910 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
911 updatedGroupDefinition.setMembers(null);
912 Map<String, String> members = groupDefinition.getMembers();
913 if (members != null) {
914 serviceImportParseLogic.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
916 result.add(updatedGroupDefinition);
922 protected Resource createRIAndRelationsFromYaml(String yamlName, Resource resource,
923 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap,
924 String topologyTemplateYaml, List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
925 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
926 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
929 log.debug("************* Going to create all nodes {}", yamlName);
930 handleNodeTypes(yamlName, resource, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
932 log.debug("************* Going to create all resource instances {}", yamlName);
933 resource = createResourceInstances(yamlName, resource, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes());
934 log.debug("************* Finished to create all resource instances {}", yamlName);
935 resource = createResourceInstancesRelations(csarInfo.getModifier(), yamlName, resource, uploadComponentInstanceInfoMap);
936 log.debug("************* Going to create positions {}", yamlName);
937 compositionBusinessLogic.setPositionsForComponentInstances(resource, csarInfo.getModifier().getUserId());
938 log.debug("************* Finished to set positions {}", yamlName);
940 } catch (Exception e) {
941 throw new ComponentException(ActionStatus.GENERAL_ERROR);
945 protected Resource createResourceInstancesRelations(User user, String yamlName, Resource resource,
946 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
947 log.debug("#createResourceInstancesRelations - Going to create relations ");
948 List<ComponentInstance> componentInstancesList = resource.getComponentInstances();
949 if (((MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)) &&
950 resource.getResourceType() != ResourceTypeEnum.PNF)) { // PNF can have no resource instances
951 log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
952 resource.getUniqueId(), yamlName);
953 BeEcompErrorManager.getInstance()
954 .logInternalDataError("createResourceInstancesRelations", "No instances found in a resource or nn yaml template. ",
955 BeEcompErrorManager.ErrorSeverity.ERROR);
956 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName));
958 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
959 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
960 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
961 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
962 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
963 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
964 Map<String, Resource> originCompMap = new HashMap<>();
965 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
966 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
968 log.debug("enter ServiceImportBusinessLogic createResourceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. ");
969 final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache;
970 if (applicationDataTypeCache != null) {
971 Resource finalResource = resource;
972 uploadResInstancesMap.values().forEach(
973 i -> processComponentInstance(yamlName, finalResource, componentInstancesList,
974 componentsUtils.getAllDataTypes(applicationDataTypeCache, finalResource.getModel()), instProperties, instCapabilities,
975 instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs, i));
977 serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, resource, instProperties);
978 serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, resource, instInputs);
979 serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts);
980 serviceImportParseLogic.associateArtifactsToInstances(yamlName, resource, instArtifacts);
981 serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements);
982 serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes);
983 resource = serviceImportParseLogic.getResourceAfterCreateRelations(resource);
984 serviceImportParseLogic.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList, relations);
985 serviceImportParseLogic.associateResourceInstances(yamlName, resource, relations);
986 handleSubstitutionMappings(resource, uploadResInstancesMap);
987 log.debug("************* in create relations, getResource start");
988 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
989 log.debug("************* in create relations, getResource end");
990 if (eitherGetResource.isRight()) {
991 throw new ComponentException(
992 componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource));
994 return eitherGetResource.left().value();
997 protected void processProperty(Resource resource, ComponentInstance currentCompInstance, Map<String, DataTypeDefinition> allDataTypes,
998 Map<String, InputDefinition> currPropertiesMap, List<ComponentInstanceInput> instPropList,
999 List<UploadPropInfo> propertyList) {
1000 UploadPropInfo propertyInfo = propertyList.get(0);
1001 String propName = propertyInfo.getName();
1002 if (!currPropertiesMap.containsKey(propName)) {
1003 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName));
1005 processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, resource.getInputs());
1008 private void processProperty(Map<String, DataTypeDefinition> allDataTypes, Map<String, InputDefinition> currPropertiesMap,
1009 List<ComponentInstanceInput> instPropList, UploadPropInfo propertyInfo, String propName,
1010 List<InputDefinition> inputs2) {
1011 InputDefinition curPropertyDef = currPropertiesMap.get(propName);
1012 ComponentInstanceInput property = null;
1013 String value = null;
1014 List<GetInputValueDataDefinition> getInputs = null;
1015 boolean isValidate = true;
1016 if (propertyInfo.getValue() != null) {
1017 getInputs = propertyInfo.getGet_input();
1018 isValidate = getInputs == null || getInputs.isEmpty();
1020 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
1022 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
1025 property = new ComponentInstanceInput(curPropertyDef, value, null);
1026 String validPropertyVAlue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
1027 property.setValue(validPropertyVAlue);
1028 if (isNotEmpty(getInputs)) {
1029 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1030 for (GetInputValueDataDefinition getInput : getInputs) {
1031 List<InputDefinition> inputs = inputs2;
1032 if (CollectionUtils.isEmpty(inputs)) {
1033 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1035 Optional<InputDefinition> optional = inputs.stream().filter(p -> p.getName().equals(getInput.getInputName())).findAny();
1036 if (!optional.isPresent()) {
1037 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1039 InputDefinition input = optional.get();
1040 getInput.setInputId(input.getUniqueId());
1041 getInputValues.add(getInput);
1042 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
1043 processGetInput(getInputValues, inputs, getInputIndex);
1045 property.setGetInputValues(getInputValues);
1047 instPropList.add(property);
1048 currPropertiesMap.remove(property.getName());
1051 protected void handleSubstitutionMappings(Resource resource, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1052 if (resource.getResourceType() == ResourceTypeEnum.VF) {
1053 Either<Resource, StorageOperationStatus> getResourceRes = toscaOperationFacade.getToscaFullElement(resource.getUniqueId());
1054 if (getResourceRes.isRight()) {
1055 ResponseFormat responseFormat = componentsUtils
1056 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource);
1057 throw new ComponentException(responseFormat);
1059 getResourceRes = updateCalculatedCapReqWithSubstitutionMappings(getResourceRes.left().value(), uploadResInstancesMap);
1060 if (getResourceRes.isRight()) {
1061 ResponseFormat responseFormat = componentsUtils
1062 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource);
1063 throw new ComponentException(responseFormat);
1068 protected Resource createResourceInstances(String yamlName, Resource resource, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1069 Map<String, Resource> nodeNamespaceMap) {
1070 Either<Resource, ResponseFormat> eitherResource = null;
1071 log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
1072 if (MapUtils.isEmpty(uploadResInstancesMap) && resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
1073 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
1074 throw new ComponentException(responseFormat);
1076 Map<String, Resource> existingNodeTypeMap = new HashMap<>();
1077 if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
1078 nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v));
1080 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1081 uploadResInstancesMap.values()
1082 .forEach(i -> createAndAddResourceInstance(i, yamlName, resource, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap));
1083 if (MapUtils.isNotEmpty(resourcesInstancesMap)) {
1085 toscaOperationFacade.associateComponentInstancesToComponent(resource, resourcesInstancesMap, false, false);
1086 } catch (StorageException exp) {
1087 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
1088 log.debug("Failed to add component instances to container component {}", resource.getName());
1089 ResponseFormat responseFormat = componentsUtils
1090 .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
1091 eitherResource = Either.right(responseFormat);
1092 throw new ByResponseFormatComponentException(eitherResource.right().value());
1096 log.debug("*************Going to get resource {}", resource.getUniqueId());
1097 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade
1098 .getToscaElement(resource.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter());
1099 log.debug("*************finished to get resource {}", resource.getUniqueId());
1100 if (eitherGetResource.isRight()) {
1101 ResponseFormat responseFormat = componentsUtils
1102 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource);
1103 throw new ComponentException(responseFormat);
1105 if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances()) &&
1106 resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
1107 log.debug("Error when create resource instance from csar. ComponentInstances list empty");
1108 BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty");
1109 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
1111 return eitherGetResource.left().value();
1114 protected void handleNodeTypes(String yamlName, Resource resource, String topologyTemplateYaml, boolean needLock,
1115 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1116 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1119 for (Map.Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
1120 if (nodeTypeEntry.getValue().isNested()) {
1121 handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1122 nodeTypeEntry.getKey());
1123 log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
1126 Map<String, Object> mappedToscaTemplate = null;
1127 if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo
1128 .containsKey(nodeName)) {
1129 mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
1131 if (MapUtils.isEmpty(mappedToscaTemplate)) {
1132 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
1134 createResourcesFromYamlNodeTypesList(yamlName, resource, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle,
1135 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
1136 } catch (ComponentException e) {
1137 ResponseFormat responseFormat =
1138 e.getResponseFormat() != null ? e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
1139 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
1141 } catch (StorageException e) {
1142 ResponseFormat responseFormat = componentsUtils
1143 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
1144 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
1146 } catch (Exception e) {
1147 log.debug("Exception occured when handleNodeTypes, error is:{}", e.getMessage(), e);
1148 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1152 protected Resource handleNestedVfc(Service service,
1153 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1154 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1157 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
1158 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
1159 createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
1161 log.debug("************* Finished to create node types from yaml {}", yamlName);
1162 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1163 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1164 return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
1166 return new Resource();
1167 } catch (Exception e) {
1168 log.debug("Exception occured when handleNestedVFc, error is:{}", e.getMessage(), e);
1169 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1173 protected Resource handleNestedVfc(Resource resource,
1174 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1175 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1177 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
1178 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
1179 log.debug("************* Going to create node types from yaml {}", yamlName);
1180 createResourcesFromYamlNodeTypesList(yamlName, resource, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
1182 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1183 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1184 resource = handleComplexVfc(resource, nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
1189 protected Resource handleComplexVfc(Resource resource,
1190 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1191 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1192 String nodeName, String yamlName) {
1193 Resource oldComplexVfc = null;
1194 Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(resource, csarInfo, nodeName, nodesInfo);
1195 Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
1196 .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
1197 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
1198 oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
1199 serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), nodeName).getRight());
1201 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
1202 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1203 } else if (oldComplexVfcRes.isLeft()) {
1204 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
1205 Either<Boolean, ResponseFormat> eitherValidation = serviceImportParseLogic
1206 .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc,
1207 ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
1208 if (eitherValidation.isLeft()) {
1209 oldComplexVfc = oldComplexVfcRes.left().value();
1212 newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc,
1214 csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
1215 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
1216 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR);
1217 log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
1218 final Resource result = serviceImportParseLogic
1219 .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true);
1220 csarInfo.getCreatedNodes().put(nodeName, result);
1221 csarInfo.removeNodeFromQueue();
1225 public Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Resource resource, Map<String, Object> mappedToscaTemplate,
1227 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1228 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1229 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
1230 Either<String, ImportUtils.ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
1231 TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
1232 if (toscaVersion.isRight()) {
1233 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
1235 Map<String, Object> mapToConvert = new HashMap<>();
1236 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value());
1237 Map<String, Object> nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate);
1238 createNodeTypes(yamlName, resource, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert,
1240 return csarInfo.getCreatedNodes();
1243 protected void createNodeTypes(String yamlName, Resource resource, boolean needLock,
1244 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1245 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1246 Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
1247 Iterator<Map.Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet().iterator();
1248 Resource vfcCreated = null;
1249 while (nodesNameValueIter.hasNext()) {
1250 Map.Entry<String, Object> nodeType = nodesNameValueIter.next();
1251 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle =
1252 nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeType.getKey());
1253 if (nodeTypesInfo.containsKey(nodeType.getKey())) {
1254 log.trace("************* Going to handle nested vfc {}", nodeType.getKey());
1255 vfcCreated = handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1257 log.trace("************* Finished to handle nested vfc {}", nodeType.getKey());
1258 } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames()
1259 .containsKey(nodeType.getKey())) {
1260 log.trace("************* Going to create node {}", nodeType.getKey());
1261 ImmutablePair<Resource, ActionStatus> resourceCreated = createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(),
1262 mapToConvert, resource, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true);
1263 log.debug("************* Finished to create node {}", nodeType.getKey());
1264 vfcCreated = resourceCreated.getLeft();
1265 csarInfo.getCreatedNodesToscaResourceNames().put(nodeType.getKey(), vfcCreated.getToscaResourceName());
1267 if (vfcCreated != null) {
1268 csarInfo.getCreatedNodes().put(nodeType.getKey(), vfcCreated);
1270 mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());
1274 protected ImmutablePair<Resource, ActionStatus> createNodeTypeResourceFromYaml(String yamlName, Map.Entry<String, Object> nodeNameValue,
1275 User user, Map<String, Object> mapToConvert, Resource resourceVf,
1277 Map<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
1278 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1279 boolean forceCertificationAllowed, CsarInfo csarInfo,
1281 UploadResourceInfo resourceMetaData = serviceImportParseLogic.fillResourceMetadata(yamlName, resourceVf, nodeNameValue.getKey(), user);
1282 String singleVfcYaml = serviceImportParseLogic.buildNodeTypeYaml(nodeNameValue, mapToConvert, resourceMetaData.getResourceType(), csarInfo);
1283 user = serviceBusinessLogic.validateUser(user, "CheckIn Resource", resourceVf, AuditingActionEnum.CHECKIN_RESOURCE, true);
1284 return serviceImportParseLogic.createResourceFromNodeType(singleVfcYaml, resourceMetaData, user, true, needLock, nodeTypeArtifactsToHandle,
1285 nodeTypesNewCreatedArtifacts, forceCertificationAllowed, csarInfo, nodeNameValue.getKey(), isNested);
1288 protected Service createRIAndRelationsFromYaml(String yamlName, Service service,
1289 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap,
1290 String topologyTemplateYaml, List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1291 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1292 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
1294 log.debug("************* Going to create all nodes {}", yamlName);
1295 handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts,
1296 nodeTypesInfo, csarInfo, nodeName);
1297 log.debug("************* Going to create all resource instances {}", yamlName);
1298 service = createServiceInstances(yamlName, service, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes());
1299 log.debug("************* Going to create all relations {}", yamlName);
1300 service = createServiceInstancesRelations(csarInfo.getModifier(), yamlName, service, uploadComponentInstanceInfoMap);
1301 log.debug("************* Going to create positions {}", yamlName);
1302 compositionBusinessLogic.setPositionsForComponentInstances(service, csarInfo.getModifier().getUserId());
1303 log.debug("************* Finished to set positions {}", yamlName);
1307 protected Service createServiceInstancesRelations(User user, String yamlName, Service service,
1308 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1309 log.debug("#createResourceInstancesRelations - Going to create relations ");
1310 List<ComponentInstance> componentInstancesList = service.getComponentInstances();
1311 if (((MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)))) { // PNF can have no resource instances
1312 log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
1313 service.getUniqueId(), yamlName);
1314 BeEcompErrorManager.getInstance()
1315 .logInternalDataError("createResourceInstancesRelations", "No instances found in a component or nn yaml template. ",
1316 BeEcompErrorManager.ErrorSeverity.ERROR);
1317 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName));
1319 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1320 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1321 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1322 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1323 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1324 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1325 Map<String, Resource> originCompMap = new HashMap<>();
1326 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1327 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1328 log.debug("enter ServiceImportBusinessLogic createServiceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. ");
1329 final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache;
1330 if (applicationDataTypeCache != null) {
1331 Service finalResource = service;
1332 uploadResInstancesMap.values().forEach(
1333 i -> processComponentInstance(yamlName, finalResource, componentInstancesList,
1334 componentsUtils.getAllDataTypes(applicationDataTypeCache, finalResource.getModel()), instProperties,
1335 instCapabilities, instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs, i));
1337 serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, service, instProperties);
1338 serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, service, instInputs);
1339 serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, service, instDeploymentArtifacts);
1340 serviceImportParseLogic.associateArtifactsToInstances(yamlName, service, instArtifacts);
1341 serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, service, instCapabilities, instRequirements);
1342 log.debug("enter createServiceInstancesRelations test,instRequirements:{},instCapabilities:{}", instRequirements, instCapabilities);
1343 serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, service, instAttributes);
1344 ToscaElement serviceTemplate = ModelConverter.convertToToscaElement(service);
1345 Map<String, ListCapabilityDataDefinition> capabilities = serviceTemplate.getCapabilities();
1346 Map<String, ListRequirementDataDefinition> requirements = serviceTemplate.getRequirements();
1347 serviceImportParseLogic.associateCapabilitiesToService(yamlName, service, capabilities);
1348 serviceImportParseLogic.associateRequirementsToService(yamlName, service, requirements);
1349 service = getResourceAfterCreateRelations(service);
1350 addRelationsToRI(yamlName, service, uploadResInstancesMap, componentInstancesList, relations);
1351 serviceImportParseLogic.associateResourceInstances(yamlName, service, relations);
1352 handleSubstitutionMappings(service, uploadResInstancesMap);
1353 log.debug("************* in create relations, getResource start");
1354 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
1355 log.debug("************* in create relations, getResource end");
1356 if (eitherGetResource.isRight()) {
1357 throw new ComponentException(componentsUtils
1358 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service,
1359 service.getComponentType()));
1361 return eitherGetResource.left().value();
1364 protected void processComponentInstance(String yamlName, Component component, List<ComponentInstance> componentInstancesList,
1365 Map<String, DataTypeDefinition> allDataTypes,
1366 Map<String, List<ComponentInstanceProperty>> instProperties,
1367 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
1368 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements,
1369 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts,
1370 Map<String, Map<String, ArtifactDefinition>> instArtifacts,
1371 Map<String, List<AttributeDefinition>> instAttributes, Map<String, Resource> originCompMap,
1372 Map<String, List<ComponentInstanceInput>> instInputs,
1373 UploadComponentInstanceInfo uploadComponentInstanceInfo) {
1374 log.debug("enter ServiceImportBusinessLogic processComponentInstance");
1375 Optional<ComponentInstance> currentCompInstanceOpt = componentInstancesList.stream()
1376 .filter(i -> i.getName().equals(uploadComponentInstanceInfo.getName())).findFirst();
1377 if (!currentCompInstanceOpt.isPresent()) {
1378 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), component.getUniqueId());
1379 BeEcompErrorManager.getInstance()
1380 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, component.getUniqueId(),
1381 BeEcompErrorManager.ErrorSeverity.ERROR);
1382 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1383 throw new ComponentException(responseFormat);
1385 ComponentInstance currentCompInstance = currentCompInstanceOpt.get();
1386 String resourceInstanceId = currentCompInstance.getUniqueId();
1387 Resource originResource = getOriginResource(yamlName, originCompMap, currentCompInstance);
1388 if (MapUtils.isNotEmpty(originResource.getRequirements())) {
1389 instRequirements.put(currentCompInstance, originResource.getRequirements());
1391 if (MapUtils.isNotEmpty(originResource.getCapabilities())) {
1392 processComponentInstanceCapabilities(allDataTypes, instCapabilties, uploadComponentInstanceInfo, currentCompInstance, originResource);
1394 if (originResource.getDeploymentArtifacts() != null && !originResource.getDeploymentArtifacts().isEmpty()) {
1395 instDeploymentArtifacts.put(resourceInstanceId, originResource.getDeploymentArtifacts());
1397 if (originResource.getArtifacts() != null && !originResource.getArtifacts().isEmpty()) {
1398 instArtifacts.put(resourceInstanceId, originResource.getArtifacts());
1400 if (originResource.getAttributes() != null && !originResource.getAttributes().isEmpty()) {
1401 instAttributes.put(resourceInstanceId, originResource.getAttributes());
1403 if (originResource.getResourceType() != ResourceTypeEnum.VF) {
1404 ResponseFormat addPropertiesValueToRiRes = addPropertyValuesToRi(uploadComponentInstanceInfo, component, originResource,
1405 currentCompInstance, instProperties, allDataTypes);
1406 if (addPropertiesValueToRiRes.getStatus() != 200) {
1407 throw new ComponentException(addPropertiesValueToRiRes);
1410 addInputsValuesToRi(uploadComponentInstanceInfo, component, originResource, currentCompInstance, instInputs, allDataTypes);
1414 protected void addInputsValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component, Resource originResource,
1415 ComponentInstance currentCompInstance, Map<String, List<ComponentInstanceInput>> instInputs,
1416 Map<String, DataTypeDefinition> allDataTypes) {
1417 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
1419 if (MapUtils.isNotEmpty(propMap)) {
1420 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
1421 List<ComponentInstanceInput> instPropList = new ArrayList<>();
1422 if (CollectionUtils.isEmpty(originResource.getInputs())) {
1423 log.debug("failed to find properties ");
1424 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND));
1426 originResource.getInputs().forEach(p -> serviceImportParseLogic.addInput(currPropertiesMap, p));
1427 for (List<UploadPropInfo> propertyList : propMap.values()) {
1428 processProperty(component, currentCompInstance, allDataTypes, currPropertiesMap, instPropList, propertyList);
1430 currPropertiesMap.values().forEach(p -> instPropList.add(new ComponentInstanceInput(p)));
1431 instInputs.put(currentCompInstance.getUniqueId(), instPropList);
1433 } catch (Exception e) {
1434 log.debug("failed to add Inputs Values To Ri");
1435 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1439 protected void processProperty(Component component, ComponentInstance currentCompInstance, Map<String, DataTypeDefinition> allDataTypes,
1440 Map<String, InputDefinition> currPropertiesMap, List<ComponentInstanceInput> instPropList,
1441 List<UploadPropInfo> propertyList) {
1442 UploadPropInfo propertyInfo = propertyList.get(0);
1443 String propName = propertyInfo.getName();
1444 if (!currPropertiesMap.containsKey(propName)) {
1445 log.debug("failed to find property {} ", propName);
1446 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName));
1448 processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, component.getInputs());
1451 protected void processGetInput(List<GetInputValueDataDefinition> getInputValues, List<InputDefinition> inputs,
1452 GetInputValueDataDefinition getInputIndex) {
1453 Optional<InputDefinition> optional;
1454 if (getInputIndex != null) {
1455 optional = inputs.stream().filter(p -> p.getName().equals(getInputIndex.getInputName())).findAny();
1456 if (!optional.isPresent()) {
1457 log.debug("Failed to find input {} ", getInputIndex.getInputName());
1458 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1460 InputDefinition inputIndex = optional.get();
1461 getInputIndex.setInputId(inputIndex.getUniqueId());
1462 getInputValues.add(getInputIndex);
1466 protected ResponseFormat addPropertyValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component,
1467 Resource originResource, ComponentInstance currentCompInstance,
1468 Map<String, List<ComponentInstanceProperty>> instProperties,
1469 Map<String, DataTypeDefinition> allDataTypes) {
1470 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
1471 Map<String, PropertyDefinition> currPropertiesMap = new HashMap<>();
1472 List<PropertyDefinition> listFromMap = originResource.getProperties();
1473 if ((propMap != null && !propMap.isEmpty()) && (listFromMap == null || listFromMap.isEmpty())) {
1474 log.debug("failed to find properties ");
1475 return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND);
1477 if (listFromMap == null || listFromMap.isEmpty()) {
1478 return componentsUtils.getResponseFormat(ActionStatus.OK);
1480 for (PropertyDefinition prop : listFromMap) {
1481 String propName = prop.getName();
1482 if (!currPropertiesMap.containsKey(propName)) {
1483 currPropertiesMap.put(propName, prop);
1486 List<ComponentInstanceProperty> instPropList = new ArrayList<>();
1487 if (propMap != null && propMap.size() > 0) {
1488 for (List<UploadPropInfo> propertyList : propMap.values()) {
1489 UploadPropInfo propertyInfo = propertyList.get(0);
1490 String propName = propertyInfo.getName();
1491 if (!currPropertiesMap.containsKey(propName)) {
1492 log.debug("failed to find property {} ", propName);
1493 return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName);
1495 PropertyDefinition curPropertyDef = currPropertiesMap.get(propName);
1496 ComponentInstanceProperty property = null;
1497 String value = null;
1498 List<GetInputValueDataDefinition> getInputs = null;
1499 boolean isValidate = true;
1500 if (propertyInfo.getValue() != null) {
1501 getInputs = propertyInfo.getGet_input();
1502 isValidate = getInputs == null || getInputs.isEmpty();
1504 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
1506 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
1509 property = new ComponentInstanceProperty(curPropertyDef, value, null);
1510 String validatePropValue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
1511 property.setValue(validatePropValue);
1512 if (getInputs != null && !getInputs.isEmpty()) {
1513 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1514 for (GetInputValueDataDefinition getInput : getInputs) {
1515 List<InputDefinition> inputs = component.getInputs();
1516 if (inputs == null || inputs.isEmpty()) {
1517 log.debug("Failed to add property {} to instance. Inputs list is empty ", property);
1518 serviceBusinessLogic.rollbackWithException(ActionStatus.INPUTS_NOT_FOUND,
1519 property.getGetInputValues().stream().map(GetInputValueDataDefinition::getInputName).collect(toList()).toString());
1521 InputDefinition input = serviceImportParseLogic.findInputByName(inputs, getInput);
1522 getInput.setInputId(input.getUniqueId());
1523 getInputValues.add(getInput);
1524 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
1525 if (getInputIndex != null) {
1526 input = serviceImportParseLogic.findInputByName(inputs, getInputIndex);
1527 getInputIndex.setInputId(input.getUniqueId());
1528 getInputValues.add(getInputIndex);
1531 property.setGetInputValues(getInputValues);
1533 instPropList.add(property);
1534 currPropertiesMap.remove(property.getName());
1537 if (!currPropertiesMap.isEmpty()) {
1538 for (PropertyDefinition value : currPropertiesMap.values()) {
1539 instPropList.add(new ComponentInstanceProperty(value));
1542 instProperties.put(currentCompInstance.getUniqueId(), instPropList);
1543 return componentsUtils.getResponseFormat(ActionStatus.OK);
1546 protected void processComponentInstanceCapabilities(Map<String, DataTypeDefinition> allDataTypes,
1547 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
1548 UploadComponentInstanceInfo uploadComponentInstanceInfo,
1549 ComponentInstance currentCompInstance, Resource originResource) {
1550 log.debug("enter processComponentInstanceCapabilities");
1551 Map<String, List<CapabilityDefinition>> originCapabilities;
1552 if (MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities())) {
1553 originCapabilities = new HashMap<>();
1554 Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
1555 originResource.getCapabilities().forEach((k, v) -> serviceImportParseLogic.addCapabilities(originCapabilities, k, v));
1556 uploadComponentInstanceInfo.getCapabilities().values()
1557 .forEach(l -> serviceImportParseLogic.addCapabilitiesProperties(newPropertiesMap, l));
1558 updateCapabilityPropertiesValues(allDataTypes, originCapabilities, newPropertiesMap, originResource.getModel());
1560 originCapabilities = originResource.getCapabilities();
1562 instCapabilties.put(currentCompInstance, originCapabilities);
1565 protected void updateCapabilityPropertiesValues(Map<String, DataTypeDefinition> allDataTypes,
1566 Map<String, List<CapabilityDefinition>> originCapabilities,
1567 Map<String, Map<String, UploadPropInfo>> newPropertiesMap, String model) {
1568 originCapabilities.values().stream().flatMap(Collection::stream).filter(c -> newPropertiesMap.containsKey(c.getName()))
1569 .forEach(c -> updatePropertyValues(c.getProperties(), newPropertiesMap.get(c.getName()), allDataTypes));
1572 protected void updatePropertyValues(List<ComponentInstanceProperty> properties, Map<String, UploadPropInfo> newProperties,
1573 Map<String, DataTypeDefinition> allDataTypes) {
1574 properties.forEach(p -> updatePropertyValue(p, newProperties.get(p.getName()), allDataTypes));
1577 protected String updatePropertyValue(ComponentInstanceProperty property, UploadPropInfo propertyInfo,
1578 Map<String, DataTypeDefinition> allDataTypes) {
1579 String value = null;
1580 List<GetInputValueDataDefinition> getInputs = null;
1581 boolean isValidate = true;
1582 if (null != propertyInfo && propertyInfo.getValue() != null) {
1583 getInputs = propertyInfo.getGet_input();
1584 isValidate = getInputs == null || getInputs.isEmpty();
1586 value = getPropertyJsonStringValue(propertyInfo.getValue(), property.getType());
1588 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
1591 property.setValue(value);
1592 return serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
1595 protected Resource getOriginResource(String yamlName, Map<String, Resource> originCompMap, ComponentInstance currentCompInstance) {
1596 Resource originResource;
1597 log.debug("after enter ServiceImportBusinessLogic processComponentInstance, enter getOriginResource");
1598 if (!originCompMap.containsKey(currentCompInstance.getComponentUid())) {
1599 Either<Resource, StorageOperationStatus> getOriginResourceRes = toscaOperationFacade
1600 .getToscaFullElement(currentCompInstance.getComponentUid());
1601 if (getOriginResourceRes.isRight()) {
1602 ResponseFormat responseFormat = componentsUtils
1603 .getResponseFormat(componentsUtils.convertFromStorageResponse(getOriginResourceRes.right().value()), yamlName);
1604 throw new ComponentException(responseFormat);
1606 originResource = getOriginResourceRes.left().value();
1607 originCompMap.put(originResource.getUniqueId(), originResource);
1609 originResource = originCompMap.get(currentCompInstance.getComponentUid());
1611 return originResource;
1614 protected void handleSubstitutionMappings(Service service, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1616 Either<Resource, StorageOperationStatus> getResourceRes = toscaOperationFacade.getToscaFullElement(service.getUniqueId());
1617 if (getResourceRes.isRight()) {
1618 ResponseFormat responseFormat = componentsUtils
1619 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), service,
1620 ComponentTypeEnum.SERVICE);
1621 throw new ComponentException(responseFormat);
1623 getResourceRes = updateCalculatedCapReqWithSubstitutionMappings(getResourceRes.left().value(), uploadResInstancesMap);
1624 if (getResourceRes.isRight()) {
1625 ResponseFormat responseFormat = componentsUtils
1626 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), service,
1627 ComponentTypeEnum.SERVICE);
1628 throw new ComponentException(responseFormat);
1633 protected Either<Resource, StorageOperationStatus> updateCalculatedCapReqWithSubstitutionMappings(Resource resource,
1634 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1635 Either<Resource, StorageOperationStatus> updateRes = null;
1636 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities = new HashMap<>();
1637 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements = new HashMap<>();
1638 StorageOperationStatus status = toscaOperationFacade.deleteAllCalculatedCapabilitiesRequirements(resource.getUniqueId());
1639 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
1640 log.debug("Failed to delete all calculated capabilities and requirements of resource {} upon update. Status is {}",
1641 resource.getUniqueId(), status);
1642 updateRes = Either.right(status);
1644 if (updateRes == null) {
1645 fillUpdatedInstCapabilitiesRequirements(resource.getComponentInstances(), uploadResInstancesMap, updatedInstCapabilities,
1646 updatedInstRequirements);
1647 status = toscaOperationFacade.associateOrAddCalculatedCapReq(updatedInstCapabilities, updatedInstRequirements, resource);
1648 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
1649 updateRes = Either.right(status);
1652 if (updateRes == null) {
1653 updateRes = Either.left(resource);
1658 protected void fillUpdatedInstCapabilitiesRequirements(List<ComponentInstance> componentInstances,
1659 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1660 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities,
1661 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements) {
1662 componentInstances.stream().forEach(i -> {
1663 fillUpdatedInstCapabilities(updatedInstCapabilities, i, uploadResInstancesMap.get(i.getName()).getCapabilitiesNamesToUpdate());
1664 fillUpdatedInstRequirements(updatedInstRequirements, i, uploadResInstancesMap.get(i.getName()).getRequirementsNamesToUpdate());
1668 protected void fillUpdatedInstCapabilities(Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilties,
1669 ComponentInstance instance, Map<String, String> capabilitiesNamesToUpdate) {
1670 Map<String, List<CapabilityDefinition>> updatedCapabilities = new HashMap<>();
1671 Set<String> updatedCapNames = new HashSet<>();
1672 if (MapUtils.isNotEmpty(capabilitiesNamesToUpdate)) {
1673 for (Map.Entry<String, List<CapabilityDefinition>> requirements : instance.getCapabilities().entrySet()) {
1674 updatedCapabilities.put(requirements.getKey(), requirements.getValue().stream().filter(
1675 c -> capabilitiesNamesToUpdate.containsKey(c.getName()) && !updatedCapNames.contains(capabilitiesNamesToUpdate.get(c.getName())))
1677 c.setParentName(c.getName());
1678 c.setName(capabilitiesNamesToUpdate.get(c.getName()));
1679 updatedCapNames.add(c.getName());
1681 }).collect(toList()));
1684 if (MapUtils.isNotEmpty(updatedCapabilities)) {
1685 updatedInstCapabilties.put(instance, updatedCapabilities);
1689 protected void fillUpdatedInstRequirements(Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements,
1690 ComponentInstance instance, Map<String, String> requirementsNamesToUpdate) {
1691 Map<String, List<RequirementDefinition>> updatedRequirements = new HashMap<>();
1692 Set<String> updatedReqNames = new HashSet<>();
1693 if (MapUtils.isNotEmpty(requirementsNamesToUpdate)) {
1694 for (Map.Entry<String, List<RequirementDefinition>> requirements : instance.getRequirements().entrySet()) {
1695 updatedRequirements.put(requirements.getKey(), requirements.getValue().stream().filter(
1696 r -> requirementsNamesToUpdate.containsKey(r.getName()) && !updatedReqNames.contains(requirementsNamesToUpdate.get(r.getName())))
1698 r.setParentName(r.getName());
1699 r.setName(requirementsNamesToUpdate.get(r.getName()));
1700 updatedReqNames.add(r.getName());
1702 }).collect(toList()));
1705 if (MapUtils.isNotEmpty(updatedRequirements)) {
1706 updatedInstRequirements.put(instance, updatedRequirements);
1710 protected void addRelationsToRI(String yamlName, Service service, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1711 List<ComponentInstance> componentInstancesList, List<RequirementCapabilityRelDef> relations) {
1712 for (Map.Entry<String, UploadComponentInstanceInfo> entry : uploadResInstancesMap.entrySet()) {
1713 UploadComponentInstanceInfo uploadComponentInstanceInfo = entry.getValue();
1714 ComponentInstance currentCompInstance = null;
1715 for (ComponentInstance compInstance : componentInstancesList) {
1716 if (compInstance.getName().equals(uploadComponentInstanceInfo.getName())) {
1717 currentCompInstance = compInstance;
1721 if (currentCompInstance == null) {
1722 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), service.getUniqueId());
1723 BeEcompErrorManager.getInstance()
1724 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, service.getUniqueId(),
1725 BeEcompErrorManager.ErrorSeverity.ERROR);
1726 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1727 throw new ComponentException(responseFormat);
1729 ResponseFormat addRelationToRiRes = addRelationToRI(yamlName, service, entry.getValue(), relations);
1730 if (addRelationToRiRes.getStatus() != 200) {
1731 throw new ComponentException(addRelationToRiRes);
1736 protected ResponseFormat addRelationToRI(String yamlName, Service service, UploadComponentInstanceInfo nodesInfoValue,
1737 List<RequirementCapabilityRelDef> relations) {
1738 List<ComponentInstance> componentInstancesList = service.getComponentInstances();
1739 ComponentInstance currentCompInstance = null;
1740 for (ComponentInstance compInstance : componentInstancesList) {
1741 if (compInstance.getName().equals(nodesInfoValue.getName())) {
1742 currentCompInstance = compInstance;
1746 if (currentCompInstance == null) {
1747 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, nodesInfoValue.getName(), service.getUniqueId());
1748 BeEcompErrorManager.getInstance()
1749 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + nodesInfoValue.getName() + IN_RESOURCE, service.getUniqueId(),
1750 BeEcompErrorManager.ErrorSeverity.ERROR);
1751 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1753 String resourceInstanceId = currentCompInstance.getUniqueId();
1754 Map<String, List<UploadReqInfo>> regMap = nodesInfoValue.getRequirements();
1755 if (regMap != null) {
1756 Iterator<Map.Entry<String, List<UploadReqInfo>>> nodesRegValue = regMap.entrySet().iterator();
1757 while (nodesRegValue.hasNext()) {
1758 Map.Entry<String, List<UploadReqInfo>> nodesRegInfoEntry = nodesRegValue.next();
1759 List<UploadReqInfo> uploadRegInfoList = nodesRegInfoEntry.getValue();
1760 for (UploadReqInfo uploadRegInfo : uploadRegInfoList) {
1761 log.debug("Going to create relation {}", uploadRegInfo.getName());
1762 String regName = uploadRegInfo.getName();
1763 RequirementCapabilityRelDef regCapRelDef = new RequirementCapabilityRelDef();
1764 regCapRelDef.setFromNode(resourceInstanceId);
1765 log.debug("try to find available requirement {} ", regName);
1766 Either<RequirementDefinition, ResponseFormat> eitherReqStatus = serviceImportParseLogic
1767 .findAviableRequiremen(regName, yamlName, nodesInfoValue, currentCompInstance, uploadRegInfo.getCapabilityName());
1768 if (eitherReqStatus.isRight()) {
1769 log.debug("failed to find available requirement {} status is {}", regName, eitherReqStatus.right().value());
1770 return eitherReqStatus.right().value();
1772 RequirementDefinition validReq = eitherReqStatus.left().value();
1773 List<CapabilityRequirementRelationship> reqAndRelationshipPairList = regCapRelDef.getRelationships();
1774 if (reqAndRelationshipPairList == null) {
1775 reqAndRelationshipPairList = new ArrayList<>();
1777 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1778 reqAndRelationshipPair.setRequirement(regName);
1779 reqAndRelationshipPair.setRequirementOwnerId(validReq.getOwnerId());
1780 reqAndRelationshipPair.setRequirementUid(validReq.getUniqueId());
1781 RelationshipImpl relationship = new RelationshipImpl();
1782 relationship.setType(validReq.getCapability());
1783 reqAndRelationshipPair.setRelationships(relationship);
1784 ComponentInstance currentCapCompInstance = null;
1785 for (ComponentInstance compInstance : componentInstancesList) {
1786 if (compInstance.getName().equals(uploadRegInfo.getNode())) {
1787 currentCapCompInstance = compInstance;
1791 if (currentCapCompInstance == null) {
1792 log.debug("The component instance with name {} not found on resource {} ", uploadRegInfo.getNode(), service.getUniqueId());
1793 BeEcompErrorManager.getInstance()
1794 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadRegInfo.getNode() + IN_RESOURCE, service.getUniqueId(),
1795 BeEcompErrorManager.ErrorSeverity.ERROR);
1796 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1798 regCapRelDef.setToNode(currentCapCompInstance.getUniqueId());
1799 log.debug("try to find aviable Capability req name is {} ", validReq.getName());
1800 CapabilityDefinition aviableCapForRel = serviceImportParseLogic
1801 .findAvailableCapabilityByTypeOrName(validReq, currentCapCompInstance, uploadRegInfo);
1802 reqAndRelationshipPair.setCapability(aviableCapForRel.getName());
1803 reqAndRelationshipPair.setCapabilityUid(aviableCapForRel.getUniqueId());
1804 reqAndRelationshipPair.setCapabilityOwnerId(aviableCapForRel.getOwnerId());
1805 if (aviableCapForRel == null) {
1806 BeEcompErrorManager.getInstance().logInternalDataError(
1807 "aviable capability was not found. req name is " + validReq.getName() + " component instance is " + currentCapCompInstance
1808 .getUniqueId(), service.getUniqueId(), BeEcompErrorManager.ErrorSeverity.ERROR);
1809 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1811 CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship();
1812 capReqRel.setRelation(reqAndRelationshipPair);
1813 reqAndRelationshipPairList.add(capReqRel);
1814 regCapRelDef.setRelationships(reqAndRelationshipPairList);
1815 relations.add(regCapRelDef);
1819 return componentsUtils.getResponseFormat(ActionStatus.OK, yamlName);
1822 protected Service getResourceAfterCreateRelations(Service service) {
1823 ComponentParametersView parametersView = serviceImportParseLogic.getComponentFilterAfterCreateRelations();
1824 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId(), parametersView);
1825 if (eitherGetResource.isRight()) {
1826 serviceImportParseLogic.throwComponentExceptionByResource(eitherGetResource.right().value(), service);
1828 return eitherGetResource.left().value();
1831 protected Service createServiceInstances(String yamlName, Service service, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1832 Map<String, Resource> nodeNamespaceMap) {
1833 Either<Resource, ResponseFormat> eitherResource = null;
1834 log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
1835 if (MapUtils.isEmpty(uploadResInstancesMap)) { // PNF can have no resource instances
1836 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
1837 throw new ComponentException(responseFormat);
1839 Map<String, Resource> existingNodeTypeMap = new HashMap<>();
1840 if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
1841 nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v));
1843 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1844 uploadResInstancesMap.values()
1845 .forEach(i -> createAndAddResourceInstance(i, yamlName, service, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap));
1846 if (MapUtils.isNotEmpty(resourcesInstancesMap)) {
1848 toscaOperationFacade.associateComponentInstancesToComponent(service, resourcesInstancesMap, false, false);
1849 } catch (StorageException exp) {
1850 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
1851 log.debug("Failed to add component instances to container component {}", service.getName());
1852 ResponseFormat responseFormat = componentsUtils
1853 .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
1854 eitherResource = Either.right(responseFormat);
1855 throw new ComponentException(eitherResource.right().value());
1859 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade
1860 .getToscaElement(service.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter());
1861 log.debug("*************finished to get resource {}", service.getUniqueId());
1862 if (eitherGetResource.isRight()) {
1863 ResponseFormat responseFormat = componentsUtils
1864 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service,
1865 ComponentTypeEnum.SERVICE);
1866 throw new ComponentException(responseFormat);
1868 if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances())) { // PNF can have no resource instances
1869 log.debug("Error when create resource instance from csar. ComponentInstances list empty");
1870 BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty");
1871 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
1873 return eitherGetResource.left().value();
1876 protected void createAndAddResourceInstance(UploadComponentInstanceInfo uploadComponentInstanceInfo, String yamlName, Component component,
1877 Map<String, Resource> nodeNamespaceMap, Map<String, Resource> existingnodeTypeMap,
1878 Map<ComponentInstance, Resource> resourcesInstancesMap) {
1879 log.debug("*************Going to create resource instances {}", uploadComponentInstanceInfo.getName());
1881 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
1882 uploadComponentInstanceInfo.setType(nodeNamespaceMap.get(uploadComponentInstanceInfo.getType()).getToscaResourceName());
1884 Resource refResource = validateResourceInstanceBeforeCreate(yamlName, uploadComponentInstanceInfo, existingnodeTypeMap);
1885 ComponentInstance componentInstance = new ComponentInstance();
1886 componentInstance.setComponentUid(refResource.getUniqueId());
1887 Collection<String> directives = uploadComponentInstanceInfo.getDirectives();
1888 if (directives != null && !directives.isEmpty()) {
1889 componentInstance.setDirectives(new ArrayList<>(directives));
1891 UploadNodeFilterInfo uploadNodeFilterInfo = uploadComponentInstanceInfo.getUploadNodeFilterInfo();
1892 if (uploadNodeFilterInfo != null) {
1894 .setNodeFilter(new CINodeFilterUtils().getNodeFilterDataDefinition(uploadNodeFilterInfo, componentInstance.getUniqueId()));
1896 ComponentTypeEnum containerComponentType = component.getComponentType();
1897 NodeTypeEnum containerNodeType = containerComponentType.getNodeType();
1898 if (containerNodeType.equals(NodeTypeEnum.Resource) && MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities()) && MapUtils
1899 .isNotEmpty(refResource.getCapabilities())) {
1900 serviceImportParseLogic.setCapabilityNamesTypes(refResource.getCapabilities(), uploadComponentInstanceInfo.getCapabilities());
1901 Map<String, List<CapabilityDefinition>> validComponentInstanceCapabilities = serviceImportParseLogic
1902 .getValidComponentInstanceCapabilities(refResource.getUniqueId(), refResource.getCapabilities(),
1903 uploadComponentInstanceInfo.getCapabilities());
1904 componentInstance.setCapabilities(validComponentInstanceCapabilities);
1906 if (!existingnodeTypeMap.containsKey(uploadComponentInstanceInfo.getType())) {
1907 ResponseFormat responseFormat = componentsUtils
1908 .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(),
1909 uploadComponentInstanceInfo.getType());
1910 throw new ComponentException(responseFormat);
1912 Resource origResource = existingnodeTypeMap.get(uploadComponentInstanceInfo.getType());
1913 componentInstance.setName(uploadComponentInstanceInfo.getName());
1914 componentInstance.setIcon(origResource.getIcon());
1915 resourcesInstancesMap.put(componentInstance, origResource);
1916 } catch (Exception e) {
1917 throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
1921 protected Resource validateResourceInstanceBeforeCreate(String yamlName, UploadComponentInstanceInfo uploadComponentInstanceInfo,
1922 Map<String, Resource> nodeNamespaceMap) {
1923 Resource refResource;
1925 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
1926 refResource = nodeNamespaceMap.get(uploadComponentInstanceInfo.getType());
1928 Either<Resource, StorageOperationStatus> findResourceEither = toscaOperationFacade
1929 .getLatestResourceByToscaResourceName(uploadComponentInstanceInfo.getType());
1930 if (findResourceEither.isRight()) {
1931 ResponseFormat responseFormat = componentsUtils
1932 .getResponseFormat(componentsUtils.convertFromStorageResponse(findResourceEither.right().value()));
1933 throw new ComponentException(responseFormat);
1935 refResource = findResourceEither.left().value();
1936 nodeNamespaceMap.put(refResource.getToscaResourceName(), refResource);
1938 String componentState = refResource.getComponentMetadataDefinition().getMetadataDataDefinition().getState();
1939 if (componentState.equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
1940 ResponseFormat responseFormat = componentsUtils
1941 .getResponseFormat(ActionStatus.ILLEGAL_COMPONENT_STATE, refResource.getComponentType().getValue(), refResource.getName(),
1943 throw new ComponentException(responseFormat);
1945 if (!ModelConverter.isAtomicComponent(refResource) && refResource.getResourceType() != ResourceTypeEnum.VF) {
1946 log.debug("validateResourceInstanceBeforeCreate - ref resource type is ", refResource.getResourceType());
1947 ResponseFormat responseFormat = componentsUtils
1948 .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(),
1949 uploadComponentInstanceInfo.getType());
1950 throw new ComponentException(responseFormat);
1953 } catch (Exception e) {
1954 throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
1958 protected void handleServiceNodeTypes(String yamlName, Service service, String topologyTemplateYaml, boolean needLock,
1959 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1960 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo,
1961 CsarInfo csarInfo, String nodeName) {
1963 for (Map.Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
1964 boolean isResourceNotExisted = validateResourceNotExisted(nodeTypeEntry.getKey());
1965 if (nodeTypeEntry.getValue().isNested() && isResourceNotExisted) {
1966 handleNestedVF(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1967 nodeTypeEntry.getKey());
1968 log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
1971 Map<String, Object> mappedToscaTemplate = null;
1972 if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo
1973 .containsKey(nodeName)) {
1974 mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
1976 if (MapUtils.isEmpty(mappedToscaTemplate)) {
1977 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
1979 createResourcesFromYamlNodeTypesList(yamlName, service, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle,
1980 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
1981 } catch (ComponentException | StorageException e) {
1983 } catch (Exception e) {
1984 log.debug("Exception occured when handleServiceNodeTypes, error is:{}", e.getMessage(), e);
1985 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1989 protected boolean validateResourceNotExisted(String type) {
1991 Either<Resource, StorageOperationStatus> latestResource = toscaOperationFacade.getLatestResourceByToscaResourceName(type);
1992 return latestResource.isRight();
1993 } catch (Exception e) {
1994 log.debug("Exception occured when validateResourceNotExisted, error is:{}", e.getMessage(), e);
1995 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1999 protected Resource handleNestedVF(Service service,
2000 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2001 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
2004 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
2005 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
2006 createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
2008 log.debug("************* Finished to create node types from yaml {}", yamlName);
2009 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
2010 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
2011 return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
2013 return new Resource();
2014 } catch (Exception e) {
2015 log.debug("Exception occured when handleNestedVF, error is:{}", e.getMessage(), e);
2016 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2020 protected Resource handleComplexVfc(
2021 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2022 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName) {
2024 Resource oldComplexVfc = null;
2025 Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(csarInfo, nodeName, nodesInfo);
2026 Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
2027 .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
2028 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
2029 oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
2030 serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), nodeName)
2033 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
2034 log.debug("Failed to fetch previous complex VFC by tosca resource name {}. Status is {}. ", newComplexVfc.getToscaResourceName(),
2035 oldComplexVfcRes.right().value());
2036 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2037 } else if (oldComplexVfcRes.isLeft()) {
2038 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
2039 Either<Boolean, ResponseFormat> eitherValidation = serviceImportParseLogic
2040 .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc,
2041 ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
2042 if (eitherValidation.isLeft()) {
2043 oldComplexVfc = oldComplexVfcRes.left().value();
2046 newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc,
2048 csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
2049 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
2050 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR);
2051 log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
2052 final Resource result = serviceImportParseLogic
2053 .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true);
2054 csarInfo.getCreatedNodes().put(nodeName, result);
2055 csarInfo.removeNodeFromQueue();
2057 } catch (Exception e) {
2058 log.debug("Exception occured when handleComplexVfc, error is:{}", e.getMessage(), e);
2059 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2063 protected Resource handleComplexVfc(
2064 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2065 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName,
2066 Resource oldComplexVfc, Resource newComplexVfc) {
2067 Resource handleComplexVfcRes;
2069 Map<String, Object> mappedToscaTemplate = nodesInfo.get(nodeName).getMappedToscaTemplate();
2070 String yamlContent = new String(csarInfo.getCsar().get(yamlName));
2071 Map<String, NodeTypeInfo> newNodeTypesInfo = nodesInfo.entrySet().stream()
2072 .collect(toMap(Map.Entry::getKey, e -> e.getValue().getUnmarkedCopy()));
2073 CsarInfo.markNestedVfc(mappedToscaTemplate, newNodeTypesInfo);
2074 if (oldComplexVfc == null) {
2075 handleComplexVfcRes = createResourceFromYaml(newComplexVfc, yamlContent, yamlName, newNodeTypesInfo, csarInfo, nodesArtifactsToHandle,
2076 false, true, nodeName);
2078 handleComplexVfcRes = updateResourceFromYaml(oldComplexVfc, newComplexVfc, AuditingActionEnum.UPDATE_RESOURCE_METADATA,
2079 createdArtifacts, yamlContent, yamlName, csarInfo, newNodeTypesInfo, nodesArtifactsToHandle, nodeName, true);
2081 return handleComplexVfcRes;
2082 } catch (Exception e) {
2083 log.debug("Exception occured when handleComplexVfc, error is:{}", e.getMessage(), e);
2084 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2088 protected Resource updateResourceFromYaml(Resource oldRresource, Resource newRresource, AuditingActionEnum actionEnum,
2089 List<ArtifactDefinition> createdArtifacts, String yamlFileName, String yamlFileContent,
2090 CsarInfo csarInfo, Map<String, NodeTypeInfo> nodeTypesInfo,
2091 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2092 String nodeName, boolean isNested) {
2093 boolean inTransaction = true;
2094 boolean shouldLock = false;
2095 Resource preparedResource = null;
2096 ParsedToscaYamlInfo uploadComponentInstanceInfoMap = null;
2098 uploadComponentInstanceInfoMap = csarBusinessLogic
2099 .getParsedToscaYamlInfo(yamlFileContent, yamlFileName, nodeTypesInfo, csarInfo, nodeName, oldRresource);
2100 Map<String, UploadComponentInstanceInfo> instances = uploadComponentInstanceInfoMap.getInstances();
2101 if (MapUtils.isEmpty(instances) && newRresource.getResourceType() != ResourceTypeEnum.PNF) {
2102 throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlFileName);
2104 preparedResource = updateExistingResourceByImport(newRresource, oldRresource, csarInfo.getModifier(), inTransaction, shouldLock,
2106 log.trace("YAML topology file found in CSAR, file name: {}, contents: {}", yamlFileName, yamlFileContent);
2107 serviceImportParseLogic.handleResourceGenericType(preparedResource);
2108 handleNodeTypes(yamlFileName, preparedResource, yamlFileContent, shouldLock, nodeTypesArtifactsToHandle, createdArtifacts, nodeTypesInfo,
2109 csarInfo, nodeName);
2110 preparedResource = serviceImportParseLogic.createInputsOnResource(preparedResource, uploadComponentInstanceInfoMap.getInputs());
2111 preparedResource = createResourceInstances(yamlFileName, preparedResource, instances, csarInfo.getCreatedNodes());
2112 preparedResource = createResourceInstancesRelations(csarInfo.getModifier(), yamlFileName, preparedResource, instances);
2113 } catch (ComponentException e) {
2114 ResponseFormat responseFormat =
2115 e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
2116 log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat);
2118 .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum);
2120 } catch (StorageException e) {
2121 ResponseFormat responseFormat = componentsUtils
2122 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
2123 log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat);
2125 .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum);
2128 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = serviceBusinessLogic.groupBusinessLogic
2129 .validateUpdateVfGroupNames(uploadComponentInstanceInfoMap.getGroups(), preparedResource.getSystemName());
2130 if (validateUpdateVfGroupNamesRes.isRight()) {
2131 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
2133 Map<String, GroupDefinition> groups;
2134 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
2135 groups = validateUpdateVfGroupNamesRes.left().value();
2137 groups = uploadComponentInstanceInfoMap.getGroups();
2139 serviceImportParseLogic.handleGroupsProperties(preparedResource, groups);
2140 preparedResource = serviceImportParseLogic.updateGroupsOnResource(preparedResource, groups);
2141 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToHandle);
2142 Either<Resource, ResponseFormat> updateArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE,
2143 createdArtifacts, yamlFileName, csarInfo, preparedResource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
2144 if (updateArtifactsEither.isRight()) {
2145 log.debug("failed to update artifacts {}", updateArtifactsEither.right().value());
2146 throw new ComponentException(updateArtifactsEither.right().value());
2148 preparedResource = serviceImportParseLogic.getResourceWithGroups(updateArtifactsEither.left().value().getUniqueId());
2149 ActionStatus mergingPropsAndInputsStatus = resourceDataMergeBusinessLogic.mergeResourceEntities(oldRresource, preparedResource);
2150 if (mergingPropsAndInputsStatus != ActionStatus.OK) {
2151 ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(mergingPropsAndInputsStatus, preparedResource);
2152 throw new ComponentException(responseFormat);
2154 compositionBusinessLogic.setPositionsForComponentInstances(preparedResource, csarInfo.getModifier().getUserId());
2155 return preparedResource;
2158 protected Resource createResourceFromYaml(Resource resource, String topologyTemplateYaml, String yamlName,
2159 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
2160 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
2161 boolean shouldLock, boolean inTransaction, String nodeName) {
2162 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
2163 Resource createdResource;
2165 ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic
2166 .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, resource);
2167 if (MapUtils.isEmpty(parsedToscaYamlInfo.getInstances()) && resource.getResourceType() != ResourceTypeEnum.PNF) {
2168 throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2170 log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", resource.getName());
2171 createdResource = createResourceAndRIsFromYaml(yamlName, resource, parsedToscaYamlInfo, AuditingActionEnum.IMPORT_RESOURCE, false,
2172 createdArtifacts, topologyTemplateYaml, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName);
2173 log.debug("#createResourceFromYaml - The resource {} has been created ", resource.getName());
2174 } catch (ComponentException e) {
2175 ResponseFormat responseFormat =
2176 e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
2177 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
2179 } catch (StorageException e) {
2180 ResponseFormat responseFormat = componentsUtils
2181 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
2182 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
2185 return createdResource;
2188 protected Resource createResourceAndRIsFromYaml(String yamlName, Resource resource, ParsedToscaYamlInfo parsedToscaYamlInfo,
2189 AuditingActionEnum actionEnum, boolean isNormative, List<ArtifactDefinition> createdArtifacts,
2190 String topologyTemplateYaml, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
2191 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
2192 boolean shouldLock, boolean inTransaction, String nodeName) {
2193 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2195 Either<Boolean, ResponseFormat> lockResult = serviceBusinessLogic
2196 .lockComponentByName(resource.getSystemName(), resource, CREATE_RESOURCE);
2197 if (lockResult.isRight()) {
2198 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2199 throw new ComponentException(lockResult.right().value());
2201 log.debug("name is locked {} status = {}", resource.getSystemName(), lockResult);
2204 log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
2205 Resource genericResource = serviceBusinessLogic.fetchAndSetDerivedFromGenericType(resource);
2206 resource = createResourceTransaction(resource, csarInfo.getModifier(), isNormative);
2207 log.trace("************* Going to add inputs from yaml {}", yamlName);
2208 Map<String, Object> yamlMap = ImportUtils.loadYamlAsStrictMap(csarInfo.getMainTemplateContent());
2209 Map<String, Object> metadata = (Map<String, Object>) yamlMap.get("metadata");
2210 String type = (String) metadata.get("type");
2211 if (resource.shouldGenerateInputs() && !"Service".equalsIgnoreCase(type)) {
2212 serviceBusinessLogic.generateAndAddInputsFromGenericTypeProperties(resource, genericResource);
2214 Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
2215 resource = serviceImportParseLogic.createInputsOnResource(resource, inputs);
2216 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances();
2217 resource = createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap, topologyTemplateYaml,
2218 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName);
2219 log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName);
2220 // validate update vf module group names
2221 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = serviceBusinessLogic.groupBusinessLogic
2222 .validateUpdateVfGroupNames(parsedToscaYamlInfo.getGroups(), resource.getSystemName());
2223 if (validateUpdateVfGroupNamesRes.isRight()) {
2224 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2225 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
2227 Map<String, GroupDefinition> groups;
2228 log.trace("************* Going to add groups from yaml {}", yamlName);
2229 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
2230 groups = validateUpdateVfGroupNamesRes.left().value();
2232 groups = parsedToscaYamlInfo.getGroups();
2234 Either<Resource, ResponseFormat> createGroupsOnResource = createGroupsOnResource(resource, groups);
2235 if (createGroupsOnResource.isRight()) {
2236 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2237 throw new ComponentException(createGroupsOnResource.right().value());
2239 resource = createGroupsOnResource.left().value();
2240 log.trace("************* Going to add artifacts from yaml {}", yamlName);
2241 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
2242 Either<Resource, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
2243 createdArtifacts, yamlName, csarInfo, resource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
2244 if (createArtifactsEither.isRight()) {
2245 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2246 throw new ComponentException(createArtifactsEither.right().value());
2248 resource = serviceImportParseLogic.getResourceWithGroups(createArtifactsEither.left().value().getUniqueId());
2249 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.CREATED);
2250 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, actionEnum);
2251 ASDCKpiApi.countCreatedResourcesKPI();
2253 } catch (ComponentException | StorageException e) {
2254 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2257 if (!inTransaction) {
2258 serviceBusinessLogic.janusGraphDao.commit();
2261 serviceBusinessLogic.graphLockOperation
2262 .unlockComponentByName(resource.getSystemName(), resource.getUniqueId(), NodeTypeEnum.Resource);
2267 protected Either<Resource, ResponseFormat> createGroupsOnResource(Resource resource, Map<String, GroupDefinition> groups) {
2268 if (groups != null && !groups.isEmpty()) {
2269 List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, resource);
2270 serviceImportParseLogic.handleGroupsProperties(resource, groups);
2271 serviceImportParseLogic.fillGroupsFinalFields(groupsAsList);
2272 Either<List<GroupDefinition>, ResponseFormat> createGroups = serviceBusinessLogic.groupBusinessLogic
2273 .createGroups(resource, groupsAsList, true);
2274 if (createGroups.isRight()) {
2275 return Either.right(createGroups.right().value());
2278 return Either.left(resource);
2280 Either<Resource, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
2281 if (updatedResource.isRight()) {
2282 ResponseFormat responseFormat = componentsUtils
2283 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), resource);
2284 return Either.right(responseFormat);
2286 return Either.left(updatedResource.left().value());
2289 protected List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups, Resource component) {
2290 List<GroupDefinition> result = new ArrayList<>();
2291 List<ComponentInstance> componentInstances = component.getComponentInstances();
2292 if (groups != null) {
2293 Either<Boolean, ResponseFormat> validateCyclicGroupsDependencies = serviceImportParseLogic.validateCyclicGroupsDependencies(groups);
2294 if (validateCyclicGroupsDependencies.isRight()) {
2295 throw new ComponentException(validateCyclicGroupsDependencies.right().value());
2297 for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
2298 String groupName = entry.getKey();
2299 GroupDefinition groupDefinition = entry.getValue();
2300 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
2301 updatedGroupDefinition.setMembers(null);
2302 Map<String, String> members = groupDefinition.getMembers();
2303 if (members != null) {
2304 updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
2306 result.add(updatedGroupDefinition);
2312 protected void updateGroupMembers(Map<String, GroupDefinition> groups, GroupDefinition updatedGroupDefinition, Resource component,
2313 List<ComponentInstance> componentInstances, String groupName, Map<String, String> members) {
2314 Set<String> compInstancesNames = members.keySet();
2315 if (CollectionUtils.isEmpty(componentInstances)) {
2316 String membersAstString = compInstancesNames.stream().collect(joining(","));
2317 log.debug("The members: {}, in group: {}, cannot be found in component {}. There are no component instances.", membersAstString,
2318 groupName, component.getNormalizedName());
2319 throw new ComponentException(componentsUtils
2320 .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(),
2321 serviceImportParseLogic.getComponentTypeForResponse(component)));
2323 Map<String, String> memberNames = componentInstances.stream().collect(toMap(ComponentInstance::getName, ComponentInstance::getUniqueId));
2324 memberNames.putAll(groups.keySet().stream().collect(toMap(g -> g, g -> "")));
2325 Map<String, String> relevantInstances = memberNames.entrySet().stream().filter(n -> compInstancesNames.contains(n.getKey()))
2326 .collect(toMap(Map.Entry::getKey, Map.Entry::getValue));
2327 if (relevantInstances == null || relevantInstances.size() != compInstancesNames.size()) {
2328 List<String> foundMembers = new ArrayList<>();
2329 if (relevantInstances != null) {
2330 foundMembers = relevantInstances.keySet().stream().collect(toList());
2332 compInstancesNames.removeAll(foundMembers);
2333 String membersAstString = compInstancesNames.stream().collect(joining(","));
2334 throw new ComponentException(componentsUtils
2335 .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(),
2336 serviceImportParseLogic.getComponentTypeForResponse(component)));
2338 updatedGroupDefinition.setMembers(relevantInstances);
2341 protected Resource createResourceTransaction(Resource resource, User user, boolean isNormative) {
2342 Either<Boolean, StorageOperationStatus> eitherValidation = toscaOperationFacade
2343 .validateComponentNameExists(resource.getName(), resource.getResourceType(), resource.getComponentType());
2344 if (eitherValidation.isRight()) {
2345 ResponseFormat errorResponse = componentsUtils
2346 .getResponseFormat(componentsUtils.convertFromStorageResponse(eitherValidation.right().value()));
2347 throw new ComponentException(errorResponse);
2349 if (eitherValidation.left().value()) {
2350 log.debug("resource with name: {}, already exists", resource.getName());
2351 ResponseFormat errorResponse = componentsUtils
2352 .getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resource.getName());
2353 throw new ComponentException(errorResponse);
2355 log.debug("send resource {} to dao for create", resource.getName());
2356 serviceImportParseLogic.createArtifactsPlaceHolderData(resource, user);
2358 log.debug("enrich resource with creator, version and state");
2359 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2360 resource.setVersion(INITIAL_VERSION);
2361 resource.setHighestVersion(true);
2362 if (resource.getResourceType() != null && resource.getResourceType() != ResourceTypeEnum.VF) {
2363 resource.setAbstract(false);
2366 return toscaOperationFacade.createToscaComponent(resource).left()
2367 .on(r -> serviceImportParseLogic.throwComponentExceptionByResource(r, resource));
2370 protected ImmutablePair<Resource, ActionStatus> updateExistingResourceByImport(Resource newResource, Resource oldResource, User user,
2371 boolean inTransaction, boolean needLock, boolean isNested) {
2372 String lockedResourceId = oldResource.getUniqueId();
2373 log.debug("found resource: name={}, id={}, version={}, state={}", oldResource.getName(), lockedResourceId, oldResource.getVersion(),
2374 oldResource.getLifecycleState());
2375 ImmutablePair<Resource, ActionStatus> resourcePair = null;
2377 serviceBusinessLogic.lockComponent(lockedResourceId, oldResource, needLock, "Update Resource by Import");
2378 oldResource = serviceImportParseLogic.prepareResourceForUpdate(oldResource, newResource, user, inTransaction, false);
2379 serviceImportParseLogic.mergeOldResourceMetadataWithNew(oldResource, newResource);
2380 serviceImportParseLogic.validateResourceFieldsBeforeUpdate(oldResource, newResource, inTransaction, isNested);
2381 serviceImportParseLogic.validateCapabilityTypesCreate(user, serviceImportParseLogic.getCapabilityTypeOperation(), newResource,
2382 AuditingActionEnum.IMPORT_RESOURCE, inTransaction);
2383 createNewResourceToOldResource(newResource, oldResource, user);
2384 Either<Resource, StorageOperationStatus> overrideResource = toscaOperationFacade.overrideComponent(newResource, oldResource);
2385 if (overrideResource.isRight()) {
2386 ResponseFormat responseFormat = new ResponseFormat();
2387 serviceBusinessLogic.throwComponentException(responseFormat);
2389 log.debug("Resource updated successfully!!!");
2390 resourcePair = new ImmutablePair<>(overrideResource.left().value(), ActionStatus.OK);
2391 return resourcePair;
2393 if (resourcePair == null) {
2394 BeEcompErrorManager.getInstance().logBeSystemError("Change LifecycleState - Certify");
2395 serviceBusinessLogic.janusGraphDao.rollback();
2396 } else if (!inTransaction) {
2397 serviceBusinessLogic.janusGraphDao.commit();
2400 log.debug("unlock resource {}", lockedResourceId);
2401 serviceBusinessLogic.graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource);
2406 protected void createNewResourceToOldResource(Resource newResource, Resource oldResource, User user) {
2407 newResource.setContactId(newResource.getContactId().toLowerCase());
2408 newResource.setCreatorUserId(user.getUserId());
2409 newResource.setCreatorFullName(user.getFullName());
2410 newResource.setLastUpdaterUserId(user.getUserId());
2411 newResource.setLastUpdaterFullName(user.getFullName());
2412 newResource.setUniqueId(oldResource.getUniqueId());
2413 newResource.setVersion(oldResource.getVersion());
2414 newResource.setInvariantUUID(oldResource.getInvariantUUID());
2415 newResource.setLifecycleState(oldResource.getLifecycleState());
2416 newResource.setUUID(oldResource.getUUID());
2417 newResource.setNormalizedName(oldResource.getNormalizedName());
2418 newResource.setSystemName(oldResource.getSystemName());
2419 if (oldResource.getCsarUUID() != null) {
2420 newResource.setCsarUUID(oldResource.getCsarUUID());
2422 if (oldResource.getImportedToscaChecksum() != null) {
2423 newResource.setImportedToscaChecksum(oldResource.getImportedToscaChecksum());
2425 if (newResource.getDerivedFromGenericType() == null || newResource.getDerivedFromGenericType().isEmpty()) {
2426 newResource.setDerivedFromGenericType(oldResource.getDerivedFromGenericType());
2428 if (newResource.getDerivedFromGenericVersion() == null || newResource.getDerivedFromGenericVersion().isEmpty()) {
2429 newResource.setDerivedFromGenericVersion(oldResource.getDerivedFromGenericVersion());
2431 if (newResource.getToscaArtifacts() == null || newResource.getToscaArtifacts().isEmpty()) {
2432 serviceBusinessLogic.setToscaArtifactsPlaceHolders(newResource, user);
2434 if (newResource.getInterfaces() == null || newResource.getInterfaces().isEmpty()) {
2435 newResource.setInterfaces(oldResource.getInterfaces());
2437 if (CollectionUtils.isEmpty(newResource.getProperties())) {
2438 newResource.setProperties(oldResource.getProperties());
2440 if (newResource.getModel() == null) {
2441 newResource.setModel(oldResource.getModel());
2445 protected Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Service service, Map<String, Object> mappedToscaTemplate,
2447 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2448 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
2449 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
2451 Either<String, ImportUtils.ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
2452 TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
2453 if (toscaVersion.isRight()) {
2454 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
2456 Map<String, Object> mapToConvert = new HashMap<>();
2457 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value());
2458 Map<String, Object> nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate);
2459 createNodeTypes(yamlName, service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
2460 mapToConvert, nodeTypes);
2461 return csarInfo.getCreatedNodes();
2462 } catch (Exception e) {
2463 log.debug("Exception occured when createResourcesFromYamlNodeTypesList,error is:{}", e.getMessage(), e);
2464 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2468 protected void createNodeTypes(String yamlName, Service service, boolean needLock,
2469 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2470 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
2471 Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
2472 Iterator<Map.Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet().iterator();
2473 Resource vfcCreated = null;
2474 while (nodesNameValueIter.hasNext()) {
2475 Map.Entry<String, Object> nodeType = nodesNameValueIter.next();
2476 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle =
2477 nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeType.getKey());
2478 if (nodeTypesInfo.containsKey(nodeType.getKey())) {
2479 vfcCreated = handleNestedVfc(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
2481 log.trace("************* Finished to handle nested vfc {}", nodeType.getKey());
2482 } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames()
2483 .containsKey(nodeType.getKey())) {
2484 ImmutablePair<Resource, ActionStatus> resourceCreated = serviceImportParseLogic
2485 .createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(), mapToConvert, service, needLock,
2486 nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true);
2487 log.debug("************* Finished to create node {}", nodeType.getKey());
2488 vfcCreated = resourceCreated.getLeft();
2489 csarInfo.getCreatedNodesToscaResourceNames().put(nodeType.getKey(), vfcCreated.getName());
2491 if (vfcCreated != null) {
2492 csarInfo.getCreatedNodes().put(nodeType.getKey(), vfcCreated);
2494 mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());