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.BusinessLogicException;
50 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
51 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
52 import org.openecomp.sdc.be.components.impl.utils.CINodeFilterUtils;
53 import org.openecomp.sdc.be.components.impl.utils.CreateServiceFromYamlParameter;
54 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
55 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
56 import org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic;
57 import org.openecomp.sdc.be.components.path.ForwardingPathValidator;
58 import org.openecomp.sdc.be.components.validation.NodeFilterValidator;
59 import org.openecomp.sdc.be.components.validation.ServiceDistributionValidation;
60 import org.openecomp.sdc.be.components.validation.component.ComponentContactIdValidator;
61 import org.openecomp.sdc.be.components.validation.component.ComponentDescriptionValidator;
62 import org.openecomp.sdc.be.components.validation.component.ComponentIconValidator;
63 import org.openecomp.sdc.be.components.validation.component.ComponentNameValidator;
64 import org.openecomp.sdc.be.components.validation.component.ComponentProjectCodeValidator;
65 import org.openecomp.sdc.be.components.validation.component.ComponentTagsValidator;
66 import org.openecomp.sdc.be.components.validation.component.ComponentValidator;
67 import org.openecomp.sdc.be.config.BeEcompErrorManager;
68 import org.openecomp.sdc.be.config.ConfigurationManager;
69 import org.openecomp.sdc.be.dao.api.ActionStatus;
70 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
71 import org.openecomp.sdc.be.datamodel.utils.ArtifactUtils;
72 import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter;
73 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
74 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
75 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
76 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
77 import org.openecomp.sdc.be.datatypes.elements.RequirementSubstitutionFilterPropertyDataDefinition;
78 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
79 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
80 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
81 import org.openecomp.sdc.be.impl.ComponentsUtils;
82 import org.openecomp.sdc.be.info.NodeTypeInfoToUpdateArtifacts;
83 import org.openecomp.sdc.be.model.ArtifactDefinition;
84 import org.openecomp.sdc.be.model.AttributeDefinition;
85 import org.openecomp.sdc.be.model.CapabilityDefinition;
86 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
87 import org.openecomp.sdc.be.model.Component;
88 import org.openecomp.sdc.be.model.ComponentInstance;
89 import org.openecomp.sdc.be.model.ComponentInstanceInput;
90 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
91 import org.openecomp.sdc.be.model.ComponentParametersView;
92 import org.openecomp.sdc.be.model.DataTypeDefinition;
93 import org.openecomp.sdc.be.model.DistributionStatusEnum;
94 import org.openecomp.sdc.be.model.GroupDefinition;
95 import org.openecomp.sdc.be.model.InputDefinition;
96 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
97 import org.openecomp.sdc.be.model.LifecycleStateEnum;
98 import org.openecomp.sdc.be.model.NodeTypeInfo;
99 import org.openecomp.sdc.be.model.Operation;
100 import org.openecomp.sdc.be.model.OutputDefinition;
101 import org.openecomp.sdc.be.model.ParsedToscaYamlInfo;
102 import org.openecomp.sdc.be.model.PolicyDefinition;
103 import org.openecomp.sdc.be.model.PropertyDefinition;
104 import org.openecomp.sdc.be.model.RelationshipImpl;
105 import org.openecomp.sdc.be.model.RelationshipInfo;
106 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
107 import org.openecomp.sdc.be.model.RequirementDefinition;
108 import org.openecomp.sdc.be.model.Resource;
109 import org.openecomp.sdc.be.model.Service;
110 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
111 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
112 import org.openecomp.sdc.be.model.UploadPropInfo;
113 import org.openecomp.sdc.be.model.UploadReqInfo;
114 import org.openecomp.sdc.be.model.UploadResourceInfo;
115 import org.openecomp.sdc.be.model.User;
116 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
117 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
118 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
119 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
120 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeFilterOperation;
121 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
122 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
123 import org.openecomp.sdc.be.model.operations.StorageException;
124 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
125 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
126 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
127 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
128 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
129 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
130 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
131 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
132 import org.openecomp.sdc.be.tosca.CsarUtils;
133 import org.openecomp.sdc.be.utils.TypeUtils;
134 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
135 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
136 import org.openecomp.sdc.common.api.Constants;
137 import org.openecomp.sdc.common.datastructure.Wrapper;
138 import org.openecomp.sdc.common.kpi.api.ASDCKpiApi;
139 import org.openecomp.sdc.common.log.wrappers.Logger;
140 import org.openecomp.sdc.common.util.ValidationUtils;
141 import org.openecomp.sdc.exception.ResponseFormat;
142 import org.yaml.snakeyaml.Yaml;
146 @org.springframework.stereotype.Component("serviceImportBusinessLogic")
147 public class ServiceImportBusinessLogic {
149 protected static final String CREATE_RESOURCE = "Create Resource";
150 private static final String INITIAL_VERSION = "0.1";
151 private static final String IN_RESOURCE = " in resource {} ";
152 private static final String COMPONENT_INSTANCE_WITH_NAME = "component instance with name ";
153 private static final String COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE = "component instance with name {} in resource {} ";
154 private static final String CERTIFICATION_ON_IMPORT = "certification on import";
155 private static final String VALIDATE_DERIVED_BEFORE_UPDATE = "validate derived before update";
156 private static final String PLACE_HOLDER_RESOURCE_TYPES = "validForResourceTypes";
157 private static final String CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES = "Create Resource - validateCapabilityTypesCreate";
158 private static final String CATEGORY_IS_EMPTY = "Resource category is empty";
159 private static final Logger log = Logger.getLogger(ServiceImportBusinessLogic.class);
161 private final ComponentsUtils componentsUtils;
162 private final ToscaOperationFacade toscaOperationFacade;
163 private final UiComponentDataConverter uiComponentDataConverter;
164 private final ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
165 private final ServiceBusinessLogic serviceBusinessLogic;
166 private final CsarBusinessLogic csarBusinessLogic;
167 private final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic;
168 private final LifecycleBusinessLogic lifecycleBusinessLogic;
169 private final CompositionBusinessLogic compositionBusinessLogic;
170 private final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic;
171 private final ServiceImportParseLogic serviceImportParseLogic;
172 private final ComponentNodeFilterBusinessLogic componentNodeFilterBusinessLogic;
173 private final GroupBusinessLogic groupBusinessLogic;
174 private final PolicyBusinessLogic policyBusinessLogic;
175 private final JanusGraphDao janusGraphDao;
176 private final ArtifactsBusinessLogic artifactsBusinessLogic;
177 private final IGraphLockOperation graphLockOperation;
179 public ServiceImportBusinessLogic(IElementOperation elementDao, IGroupOperation groupOperation, IGroupInstanceOperation groupInstanceOperation,
180 IGroupTypeOperation groupTypeOperation, GroupBusinessLogic groupBusinessLogic,
181 InterfaceOperation interfaceOperation, InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
182 ArtifactsBusinessLogic artifactsBusinessLogic, IDistributionEngine distributionEngine,
183 ComponentInstanceBusinessLogic componentInstanceBusinessLogic,
184 ServiceDistributionValidation serviceDistributionValidation, ForwardingPathValidator forwardingPathValidator,
185 UiComponentDataConverter uiComponentDataConverter, NodeFilterOperation serviceFilterOperation,
186 NodeFilterValidator serviceFilterValidator, ArtifactsOperations artifactToscaOperation,
187 ComponentContactIdValidator componentContactIdValidator, ComponentNameValidator componentNameValidator,
188 ComponentTagsValidator componentTagsValidator, ComponentValidator componentValidator,
189 ComponentIconValidator componentIconValidator, ComponentProjectCodeValidator componentProjectCodeValidator,
190 ComponentDescriptionValidator componentDescriptionValidator, final ComponentsUtils componentsUtils,
191 final ToscaOperationFacade toscaOperationFacade, final ServiceBusinessLogic serviceBusinessLogic,
192 final CsarBusinessLogic csarBusinessLogic,
193 final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic,
194 final LifecycleBusinessLogic lifecycleBusinessLogic, final CompositionBusinessLogic compositionBusinessLogic,
195 final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic,
196 final ServiceImportParseLogic serviceImportParseLogic,
197 final ComponentNodeFilterBusinessLogic componentNodeFilterBusinessLogic,
198 final PolicyBusinessLogic policyBusinessLogic, final JanusGraphDao janusGraphDao,
199 final IGraphLockOperation graphLockOperation) {
200 this.componentInstanceBusinessLogic = componentInstanceBusinessLogic;
201 this.uiComponentDataConverter = uiComponentDataConverter;
202 this.componentsUtils = componentsUtils;
203 this.toscaOperationFacade = toscaOperationFacade;
204 this.serviceBusinessLogic = serviceBusinessLogic;
205 this.csarBusinessLogic = csarBusinessLogic;
206 this.csarArtifactsAndGroupsBusinessLogic = csarArtifactsAndGroupsBusinessLogic;
207 this.lifecycleBusinessLogic = lifecycleBusinessLogic;
208 this.compositionBusinessLogic = compositionBusinessLogic;
209 this.resourceDataMergeBusinessLogic = resourceDataMergeBusinessLogic;
210 this.serviceImportParseLogic = serviceImportParseLogic;
211 this.componentNodeFilterBusinessLogic = componentNodeFilterBusinessLogic;
212 this.groupBusinessLogic = groupBusinessLogic;
213 this.policyBusinessLogic = policyBusinessLogic;
214 this.janusGraphDao = janusGraphDao;
215 this.artifactsBusinessLogic = artifactsBusinessLogic;
216 this.graphLockOperation = graphLockOperation;
219 public Service createService(Service service, AuditingActionEnum auditingAction, User user, Map<String, byte[]> csarUIPayload,
220 String payloadName) {
221 log.debug("enter createService");
222 service.setCreatorUserId(user.getUserId());
223 service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
224 service.setVersion(INITIAL_VERSION);
225 service.setConformanceLevel(ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel());
226 service.setDistributionStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
228 final var serviceBeforeCreate = serviceBusinessLogic.validateServiceBeforeCreate(service, user, auditingAction);
229 if (serviceBeforeCreate.isRight()) {
230 throw new ComponentException(ActionStatus.GENERAL_ERROR);
232 log.debug("enter createService,validateServiceBeforeCreate success");
233 String csarUUID = payloadName == null ? service.getCsarUUID() : payloadName;
234 log.debug("enter createService,get csarUUID:{}", csarUUID);
235 csarBusinessLogic.validateCsarBeforeCreate(service, csarUUID);
236 log.debug("CsarUUID is {} - going to create resource from CSAR", csarUUID);
237 return createServiceFromCsar(service, user, csarUIPayload, csarUUID);
238 } catch (Exception e) {
239 log.debug("Exception occured when createService,error is:{}", e.getMessage(), e);
240 throw new ComponentException(ActionStatus.GENERAL_ERROR);
244 protected Service createServiceFromCsar(Service service, User user, Map<String, byte[]> csarUIPayload, String csarUUID) {
245 log.trace("************* created successfully from YAML, resource TOSCA ");
247 CsarInfo csarInfo = csarBusinessLogic.getCsarInfo(service, null, user, csarUIPayload, csarUUID);
248 Map<String, NodeTypeInfo> nodeTypesInfo = csarInfo.extractTypesInfo();
249 Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandleRes = serviceImportParseLogic
250 .findNodeTypesArtifactsToHandle(nodeTypesInfo, csarInfo, service);
251 if (findNodeTypesArtifactsToHandleRes.isRight()) {
252 log.debug("failed to find node types for update with artifacts during import csar {}. ", csarInfo.getCsarUUID());
253 throw new ComponentException(findNodeTypesArtifactsToHandleRes.right().value());
255 return createServiceFromYaml(service, csarInfo.getMainTemplateContent(), csarInfo.getMainTemplateName(), nodeTypesInfo, csarInfo,
256 findNodeTypesArtifactsToHandleRes.left().value(), true, false, null, user.getUserId());
257 } catch (Exception e) {
258 log.debug("Exception occured when createServiceFromCsar,error is:{}", e.getMessage(), e);
259 throw new ComponentException(ActionStatus.GENERAL_ERROR);
263 protected Service createServiceFromYaml(Service service, String topologyTemplateYaml, String yamlName, Map<String, NodeTypeInfo> nodeTypesInfo,
265 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
266 boolean shouldLock, boolean inTransaction, String nodeName, final String userId)
267 throws BusinessLogicException {
268 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
269 Service createdService;
270 CreateServiceFromYamlParameter csfyp = new CreateServiceFromYamlParameter();
272 ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic
273 .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, service);
274 log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", service.getName());
275 csfyp.setYamlName(yamlName);
276 csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
277 csfyp.setCreatedArtifacts(createdArtifacts);
278 csfyp.setTopologyTemplateYaml(topologyTemplateYaml);
279 csfyp.setNodeTypesInfo(nodeTypesInfo);
280 csfyp.setCsarInfo(csarInfo);
281 csfyp.setNodeName(nodeName);
282 createdService = createServiceAndRIsFromYaml(service, false, nodeTypesArtifactsToCreate, shouldLock, inTransaction, csfyp, userId);
283 log.debug("#createResourceFromYaml - The resource {} has been created ", service.getName());
284 } catch (ComponentException | BusinessLogicException e) {
285 log.debug("Create Service from yaml failed", e);
287 } catch (StorageException e) {
288 log.debug("create Service From Yaml failed,get StorageException:{}", e);
291 return createdService;
294 protected Service createServiceAndRIsFromYaml(Service service, boolean isNormative,
295 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
296 boolean shouldLock, boolean inTransaction, CreateServiceFromYamlParameter csfyp,
298 throws BusinessLogicException {
299 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
300 String yamlName = csfyp.getYamlName();
301 ParsedToscaYamlInfo parsedToscaYamlInfo = csfyp.getParsedToscaYamlInfo();
302 List<ArtifactDefinition> createdArtifacts = csfyp.getCreatedArtifacts();
303 String topologyTemplateYaml = csfyp.getTopologyTemplateYaml();
304 Map<String, NodeTypeInfo> nodeTypesInfo = csfyp.getNodeTypesInfo();
305 CsarInfo csarInfo = csfyp.getCsarInfo();
306 String nodeName = csfyp.getNodeName();
308 Either<Boolean, ResponseFormat> lockResult = serviceBusinessLogic.lockComponentByName(service.getSystemName(), service, CREATE_RESOURCE);
309 if (lockResult.isRight()) {
310 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
311 throw new ComponentException(lockResult.right().value());
313 log.debug("name is locked {} status = {}", service.getSystemName(), lockResult);
316 log.trace("************* Adding properties to service from interface yaml {}", yamlName);
317 Map<String, PropertyDefinition> properties = parsedToscaYamlInfo.getProperties();
318 if (properties != null && !properties.isEmpty()) {
319 final List<PropertyDefinition> propertiesList = new ArrayList<>();
320 properties.forEach((propertyName, propertyDefinition) -> {
321 propertyDefinition.setName(propertyName);
322 propertiesList.add(propertyDefinition);
324 service.setProperties(propertiesList);
326 log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
327 service = serviceImportParseLogic.createServiceTransaction(service, csarInfo.getModifier(), isNormative);
328 log.trace("************* Going to add inputs from yaml {}", yamlName);
329 Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
330 service = serviceImportParseLogic.createInputsOnService(service, inputs);
331 log.trace("************* Finished to add inputs from yaml {}", yamlName);
332 ListDataDefinition<RequirementSubstitutionFilterPropertyDataDefinition> substitutionFilterProperties = parsedToscaYamlInfo.getSubstitutionFilterProperties();
333 service = serviceImportParseLogic.createSubstitutionFilterOnService(service, substitutionFilterProperties);
334 log.trace("************* Added Substitution filter from interface yaml {}", yamlName);
335 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances();
336 log.trace("************* Going to create nodes, RI's and Relations from yaml {}", yamlName);
337 service = createRIAndRelationsFromYaml(yamlName, service, uploadComponentInstanceInfoMap, topologyTemplateYaml,
338 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName);
339 log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName);
340 log.trace("************* Going to add outputs from yaml {}", yamlName);
341 Map<String, OutputDefinition> outputs = parsedToscaYamlInfo.getOutputs();
342 service = serviceImportParseLogic.createOutputsOnService(service, outputs, userId);
343 log.trace("************* Finished to add outputs from yaml {}", yamlName);
345 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes
346 = groupBusinessLogic.validateUpdateVfGroupNames(parsedToscaYamlInfo.getGroups(), service.getSystemName());
347 if (validateUpdateVfGroupNamesRes.isRight()) {
348 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
349 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
351 Map<String, GroupDefinition> groups;
352 log.trace("************* Going to add groups from yaml {}", yamlName);
353 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
354 groups = validateUpdateVfGroupNamesRes.left().value();
356 groups = parsedToscaYamlInfo.getGroups();
358 Either<Service, ResponseFormat> createGroupsOnResource = createGroupsOnResource(service, groups);
359 if (createGroupsOnResource.isRight()) {
360 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
361 throw new ComponentException(createGroupsOnResource.right().value());
363 service = createGroupsOnResource.left().value();
365 Either<Service, ResponseFormat> createPoliciesOnResource = createPoliciesOnResource(service, parsedToscaYamlInfo.getPolicies());
366 if (createPoliciesOnResource.isRight()) {
367 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
368 throw new ComponentException(createPoliciesOnResource.right().value());
370 service = createPoliciesOnResource.left().value();
371 log.trace("************* Going to add artifacts from yaml {}", yamlName);
372 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
373 Either<Service, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
374 createdArtifacts, yamlName, csarInfo, service, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
375 if (createArtifactsEither.isRight()) {
376 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
377 throw new ComponentException(createArtifactsEither.right().value());
379 service = serviceImportParseLogic.getServiceWithGroups(createArtifactsEither.left().value().getUniqueId());
380 ASDCKpiApi.countCreatedResourcesKPI();
382 } catch (ComponentException | StorageException | BusinessLogicException e) {
383 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
386 if (!inTransaction) {
387 janusGraphDao.commit();
390 graphLockOperation.unlockComponentByName(service.getSystemName(), service.getUniqueId(), NodeTypeEnum.Resource);
395 protected Either<Resource, ResponseFormat> createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum operation,
396 List<ArtifactDefinition> createdArtifacts, String yamlFileName,
397 CsarInfo csarInfo, Resource preparedResource,
398 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
399 boolean inTransaction, boolean shouldLock) {
400 String nodeName = nodeTypeInfoToUpdateArtifacts.getNodeName();
401 Resource resource = preparedResource;
402 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = nodeTypeInfoToUpdateArtifacts
403 .getNodeTypesArtifactsToHandle();
404 if (preparedResource.getResourceType() == ResourceTypeEnum.VF) {
405 if (nodeName != null && nodeTypesArtifactsToHandle.get(nodeName) != null && !nodeTypesArtifactsToHandle.get(nodeName).isEmpty()) {
406 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = handleNodeTypeArtifacts(preparedResource,
407 nodeTypesArtifactsToHandle.get(nodeName), createdArtifacts, csarInfo.getModifier(), inTransaction, true);
408 if (handleNodeTypeArtifactsRes.isRight()) {
409 return Either.right(handleNodeTypeArtifactsRes.right().value());
413 Either<Resource, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedResource, csarInfo, createdArtifacts,
414 new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction);
415 log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
416 if (createdCsarArtifactsEither.isRight()) {
417 return createdCsarArtifactsEither;
419 resource = createdCsarArtifactsEither.left().value();
421 return Either.left(resource);
424 protected Either<Resource, ResponseFormat> handleVfCsarArtifacts(Resource resource, CsarInfo csarInfo, List<ArtifactDefinition> createdArtifacts,
425 ArtifactOperationInfo artifactOperation, boolean shouldLock,
426 boolean inTransaction) {
427 if (csarInfo.getCsar() != null) {
428 createOrUpdateSingleNonMetaArtifactToComstants(resource, csarInfo, artifactOperation, shouldLock, inTransaction);
429 Either<Resource, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, resource, createdArtifacts, shouldLock,
430 inTransaction, artifactOperation);
431 if (eitherCreateResult.isRight()) {
432 return Either.right(eitherCreateResult.right().value());
434 Either<Resource, StorageOperationStatus> eitherGerResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
435 if (eitherGerResource.isRight()) {
436 ResponseFormat responseFormat = componentsUtils
437 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), resource);
438 return Either.right(responseFormat);
440 resource = eitherGerResource.left().value();
441 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
442 .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
443 if (artifacsMetaCsarStatus.isLeft()) {
444 return getResourceResponseFormatEither(resource, csarInfo, createdArtifacts, artifactOperation, shouldLock, inTransaction,
445 artifacsMetaCsarStatus);
447 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(resource, csarInfo, shouldLock, inTransaction);
450 return Either.left(resource);
453 protected void createOrUpdateSingleNonMetaArtifactToComstants(Resource resource, CsarInfo csarInfo, ArtifactOperationInfo artifactOperation,
454 boolean shouldLock, boolean inTransaction) {
455 String vendorLicenseModelId = null;
456 String vfLicenseModelId = null;
457 if (artifactOperation.getArtifactOperationEnum() == ArtifactOperationEnum.UPDATE) {
458 Map<String, ArtifactDefinition> deploymentArtifactsMap = resource.getDeploymentArtifacts();
459 if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
460 for (Map.Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
461 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
462 vendorLicenseModelId = artifactEntry.getValue().getUniqueId();
464 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
465 vfLicenseModelId = artifactEntry.getValue().getUniqueId();
470 createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL,
471 Constants.VENDOR_LICENSE_MODEL, ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
472 Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME, Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId,
473 artifactOperation, null, true, shouldLock, inTransaction);
474 createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
475 ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL, Constants.VF_LICENSE_DISPLAY_NAME,
476 Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId, artifactOperation, null, true, shouldLock, inTransaction);
479 private Either<Resource, ResponseFormat> getResourceResponseFormatEither(Resource resource, CsarInfo csarInfo,
480 List<ArtifactDefinition> createdArtifacts,
481 ArtifactOperationInfo artifactOperation, boolean shouldLock,
482 boolean inTransaction,
483 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus) {
485 String artifactsFileName = artifacsMetaCsarStatus.left().value().getKey();
486 String artifactsContents = artifacsMetaCsarStatus.left().value().getValue();
487 Either<Resource, ResponseFormat> createArtifactsFromCsar;
488 if (ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
489 createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic
490 .createResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts);
492 Either<Component, ResponseFormat> result = csarArtifactsAndGroupsBusinessLogic
493 .updateResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
495 if ((result.left().value() instanceof Resource) && result.isLeft()) {
496 Resource service1 = (Resource) result.left().value();
497 createArtifactsFromCsar = Either.left(service1);
499 createArtifactsFromCsar = Either.right(result.right().value());
502 if (createArtifactsFromCsar.isRight()) {
503 log.debug("Couldn't create artifacts from artifacts.meta");
504 return Either.right(createArtifactsFromCsar.right().value());
506 return Either.left(createArtifactsFromCsar.left().value());
507 } catch (Exception e) {
508 log.debug("Exception occured in getResourceResponseFormatEither, message:{}", e.getMessage(), e);
509 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
513 private <T extends Component> Either<T, ResponseFormat> createOrUpdateNonMetaArtifactsComp(CsarInfo csarInfo, T component,
514 List<ArtifactDefinition> createdArtifacts,
515 boolean shouldLock, boolean inTransaction,
516 ArtifactOperationInfo artifactOperation) {
517 Either<T, ResponseFormat> resStatus = null;
518 Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
520 Either<List<CsarUtils.NonMetaArtifactInfo>, String> artifactPathAndNameList = getValidArtifactNames(csarInfo, collectedWarningMessages);
521 if (artifactPathAndNameList.isRight()) {
523 getComponentsUtils().getResponseFormatByArtifactId(ActionStatus.ARTIFACT_NAME_INVALID, artifactPathAndNameList.right().value()));
525 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = null;
526 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
527 vfCsarArtifactsToHandle = new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
528 vfCsarArtifactsToHandle.put(artifactOperation.getArtifactOperationEnum(), artifactPathAndNameList.left().value());
530 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandleRes = findVfCsarArtifactsToHandle(
531 component, artifactPathAndNameList.left().value(), csarInfo.getModifier());
532 if (findVfCsarArtifactsToHandleRes.isRight()) {
533 resStatus = Either.right(findVfCsarArtifactsToHandleRes.right().value());
535 if (resStatus == null) {
536 vfCsarArtifactsToHandle = findVfCsarArtifactsToHandleRes.left().value();
539 if (resStatus == null && vfCsarArtifactsToHandle != null) {
540 resStatus = processCsarArtifacts(csarInfo, component, createdArtifacts, shouldLock, inTransaction, resStatus,
541 vfCsarArtifactsToHandle);
543 if (resStatus == null) {
544 resStatus = Either.left(component);
546 } catch (Exception e) {
547 resStatus = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
548 log.debug("Exception occured in createNonMetaArtifacts, message:{}", e.getMessage(), e);
550 CsarUtils.handleWarningMessages(collectedWarningMessages);
555 protected Either<Resource, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Resource resource,
556 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
557 boolean inTransaction, ArtifactOperationInfo artifactOperation) {
558 return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation);
561 protected <T extends Component> Either<T, ResponseFormat> processCsarArtifacts(CsarInfo csarInfo, Component comp,
562 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
563 boolean inTransaction, Either<T, ResponseFormat> resStatus,
564 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle) {
565 for (Map.Entry<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> currArtifactOperationPair : vfCsarArtifactsToHandle
567 Optional<ResponseFormat> optionalCreateInDBError = currArtifactOperationPair.getValue().stream().map(
568 e -> createOrUpdateSingleNonMetaArtifact(comp, csarInfo, e.getPath(), e.getArtifactName(), e.getArtifactType(),
569 e.getArtifactGroupType(), e.getArtifactLabel(), e.getDisplayName(), CsarUtils.ARTIFACT_CREATED_FROM_CSAR, e.getArtifactUniqueId(),
570 new ArtifactOperationInfo(false, false, currArtifactOperationPair.getKey()), createdArtifacts, e.isFromCsar(), shouldLock,
571 inTransaction)).filter(Either::isRight).map(e -> e.right().value()).findAny();
572 if (optionalCreateInDBError.isPresent()) {
573 resStatus = Either.right(optionalCreateInDBError.get());
580 protected Either<Boolean, ResponseFormat> createOrUpdateSingleNonMetaArtifact(Component component, CsarInfo csarInfo, String artifactPath,
581 String artifactFileName, String artifactType,
582 ArtifactGroupTypeEnum artifactGroupType, String artifactLabel,
583 String artifactDisplayName, String artifactDescription,
584 String artifactId, ArtifactOperationInfo operation,
585 List<ArtifactDefinition> createdArtifacts, boolean isFromCsar,
586 boolean shouldLock, boolean inTransaction) {
587 byte[] artifactFileBytes = null;
588 if (csarInfo.getCsar().containsKey(artifactPath)) {
589 artifactFileBytes = csarInfo.getCsar().get(artifactPath);
591 Either<Boolean, ResponseFormat> result = Either.left(true);
592 if (operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE
593 || operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE) {
594 if (serviceImportParseLogic.isArtifactDeletionRequired(artifactId, artifactFileBytes, isFromCsar)) {
595 Either<ArtifactDefinition, ResponseFormat> handleDelete = artifactsBusinessLogic
596 .handleDelete(component.getUniqueId(), artifactId, csarInfo.getModifier(), component, shouldLock, inTransaction);
597 if (handleDelete.isRight()) {
598 result = Either.right(handleDelete.right().value());
602 if (org.apache.commons.lang.StringUtils.isEmpty(artifactId) && artifactFileBytes != null) {
603 operation = new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
606 if (artifactFileBytes != null) {
607 Map<String, Object> vendorLicenseModelJson = ArtifactUtils
608 .buildJsonForUpdateArtifact(artifactId, artifactFileName, artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
609 artifactDescription, artifactFileBytes, null, isFromCsar);
610 Either<Either<ArtifactDefinition, Operation>, ResponseFormat> eitherNonMetaArtifacts = csarArtifactsAndGroupsBusinessLogic
611 .createOrUpdateCsarArtifactFromJson(component, csarInfo.getModifier(), vendorLicenseModelJson, operation);
612 serviceImportParseLogic.addNonMetaCreatedArtifactsToSupportRollback(operation, createdArtifacts, eitherNonMetaArtifacts);
613 if (eitherNonMetaArtifacts.isRight()) {
614 BeEcompErrorManager.getInstance().logInternalFlowError("UploadLicenseArtifact",
615 "Failed to upload license artifact: " + artifactFileName + "With csar uuid: " + csarInfo.getCsarUUID(),
616 BeEcompErrorManager.ErrorSeverity.WARNING);
617 return Either.right(eitherNonMetaArtifacts.right().value());
623 private Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifacts(Resource nodeTypeResource,
624 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
625 List<ArtifactDefinition> createdArtifacts, User user,
626 boolean inTransaction, boolean ignoreLifecycleState) {
627 List<ArtifactDefinition> handleNodeTypeArtifactsRequestRes;
628 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = null;
629 Either<Resource, ResponseFormat> changeStateResponse;
631 changeStateResponse = checkoutResource(nodeTypeResource, user, inTransaction);
632 if (changeStateResponse.isRight()) {
633 return Either.right(changeStateResponse.right().value());
635 nodeTypeResource = changeStateResponse.left().value();
636 List<ArtifactDefinition> handledNodeTypeArtifacts = new ArrayList<>();
637 log.debug("************* Going to handle artifacts of node type resource {}. ", nodeTypeResource.getName());
638 for (Map.Entry<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> curOperationEntry : nodeTypeArtifactsToHandle
640 ArtifactsBusinessLogic.ArtifactOperationEnum curOperation = curOperationEntry.getKey();
641 List<ArtifactDefinition> curArtifactsToHandle = curOperationEntry.getValue();
642 if (curArtifactsToHandle != null && !curArtifactsToHandle.isEmpty()) {
643 log.debug("************* Going to {} artifact to vfc {}", curOperation.name(), nodeTypeResource.getName());
644 handleNodeTypeArtifactsRequestRes = artifactsBusinessLogic
645 .handleArtifactsRequestForInnerVfcComponent(curArtifactsToHandle, nodeTypeResource, user, createdArtifacts,
646 new ArtifactOperationInfo(false, ignoreLifecycleState, curOperation), false, inTransaction);
647 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(curOperation)) {
648 createdArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
650 handledNodeTypeArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
653 if (handleNodeTypeArtifactsRes == null) {
654 handleNodeTypeArtifactsRes = Either.left(handledNodeTypeArtifacts);
656 } catch (Exception e) {
657 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
658 handleNodeTypeArtifactsRes = Either.right(responseFormat);
659 log.debug("Exception occured when handleVfcArtifacts, error is:{}", e.getMessage(), e);
661 return handleNodeTypeArtifactsRes;
664 private Either<Resource, ResponseFormat> checkoutResource(Resource resource, User user, boolean inTransaction) {
665 Either<Resource, ResponseFormat> checkoutResourceRes;
667 if (!resource.getComponentMetadataDefinition().getMetadataDataDefinition().getState()
668 .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
669 Either<? extends Component, ResponseFormat> checkoutRes = lifecycleBusinessLogic
670 .changeComponentState(resource.getComponentType(), resource.getUniqueId(), user, LifeCycleTransitionEnum.CHECKOUT,
671 new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
672 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR), inTransaction, true);
673 if (checkoutRes.isRight()) {
674 checkoutResourceRes = Either.right(checkoutRes.right().value());
676 checkoutResourceRes = Either.left((Resource) checkoutRes.left().value());
679 checkoutResourceRes = Either.left(resource);
681 } catch (Exception e) {
682 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
683 checkoutResourceRes = Either.right(responseFormat);
684 log.debug("Exception occured when checkoutResource {} , error is:{}", resource.getName(), e.getMessage(), e);
686 return checkoutResourceRes;
689 protected Either<Service, ResponseFormat> createOrUpdateArtifacts(ArtifactOperationEnum operation, List<ArtifactDefinition> createdArtifacts,
690 String yamlFileName, CsarInfo csarInfo, Service preparedService,
691 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
692 boolean inTransaction, boolean shouldLock) {
693 Either<Service, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedService, csarInfo, createdArtifacts,
694 new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction);
695 log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
696 if (createdCsarArtifactsEither.isRight()) {
697 return createdCsarArtifactsEither;
699 return Either.left(createdCsarArtifactsEither.left().value());
702 protected Either<Service, ResponseFormat> handleVfCsarArtifacts(Service service, CsarInfo csarInfo, List<ArtifactDefinition> createdArtifacts,
703 ArtifactOperationInfo artifactOperation, boolean shouldLock,
704 boolean inTransaction) {
705 if (csarInfo.getCsar() != null) {
706 String vendorLicenseModelId = null;
707 String vfLicenseModelId = null;
708 if (artifactOperation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE) {
709 Map<String, ArtifactDefinition> deploymentArtifactsMap = service.getDeploymentArtifacts();
710 if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
711 for (Map.Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
712 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
713 vendorLicenseModelId = artifactEntry.getValue().getUniqueId();
715 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
716 vfLicenseModelId = artifactEntry.getValue().getUniqueId();
721 createOrUpdateSingleNonMetaArtifact(service, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL,
722 Constants.VENDOR_LICENSE_MODEL, ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
723 Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME, Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId,
724 artifactOperation, null, true, shouldLock, inTransaction);
725 createOrUpdateSingleNonMetaArtifact(service, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
726 ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL,
727 Constants.VF_LICENSE_DISPLAY_NAME, Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId, artifactOperation, null, true, shouldLock,
729 Either<Service, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, service, createdArtifacts, shouldLock,
730 inTransaction, artifactOperation);
731 if (eitherCreateResult.isRight()) {
732 return Either.right(eitherCreateResult.right().value());
734 Either<Service, StorageOperationStatus> eitherGerResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
735 if (eitherGerResource.isRight()) {
736 ResponseFormat responseFormat = componentsUtils
737 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), service,
738 ComponentTypeEnum.SERVICE);
739 return Either.right(responseFormat);
741 service = eitherGerResource.left().value();
742 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
743 .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
744 if (artifacsMetaCsarStatus.isLeft()) {
745 String artifactsFileName = artifacsMetaCsarStatus.left().value().getKey();
746 String artifactsContents = artifacsMetaCsarStatus.left().value().getValue();
747 Either<Service, ResponseFormat> createArtifactsFromCsar;
748 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
749 createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic
750 .createResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts);
752 Either<Component, ResponseFormat> result = csarArtifactsAndGroupsBusinessLogic
753 .updateResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
755 if ((result.left().value() instanceof Service) && result.isLeft()) {
756 Service service1 = (Service) result.left().value();
757 createArtifactsFromCsar = Either.left(service1);
759 createArtifactsFromCsar = Either.right(result.right().value());
762 if (createArtifactsFromCsar.isRight()) {
763 log.debug("Couldn't create artifacts from artifacts.meta");
764 return Either.right(createArtifactsFromCsar.right().value());
766 return Either.left(createArtifactsFromCsar.left().value());
768 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(service, csarInfo, shouldLock, inTransaction);
771 return Either.left(service);
774 protected Either<Service, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Service resource,
775 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
776 boolean inTransaction, ArtifactOperationInfo artifactOperation) {
777 return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation);
780 protected Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandle(
781 Component component, List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList, User user) {
782 List<ArtifactDefinition> existingArtifacts = new ArrayList<>();
783 if (component.getDeploymentArtifacts() != null && !component.getDeploymentArtifacts().isEmpty()) {
784 existingArtifacts.addAll(component.getDeploymentArtifacts().values());
786 if (component.getArtifacts() != null && !component.getArtifacts().isEmpty()) {
787 existingArtifacts.addAll(component.getArtifacts().values());
789 existingArtifacts = existingArtifacts.stream().filter(this::isNonMetaArtifact).collect(toList());
790 List<String> artifactsToIgnore = new ArrayList<>();
791 if (component.getGroups() != null) {
792 component.getGroups().forEach(g -> {
793 if (g.getArtifacts() != null && !g.getArtifacts().isEmpty()) {
794 artifactsToIgnore.addAll(g.getArtifacts());
798 existingArtifacts = existingArtifacts.stream().filter(a -> !artifactsToIgnore.contains(a.getUniqueId())).collect(toList());
799 return organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifacts, component, user);
802 private boolean isNonMetaArtifact(ArtifactDefinition artifact) {
803 boolean result = true;
804 if (artifact.getMandatory() || artifact.getArtifactName() == null || !isValidArtifactType(artifact)) {
810 private boolean isValidArtifactType(ArtifactDefinition artifact) {
811 final String artifactType = artifact.getArtifactType();
812 return artifactType != null
813 && !ArtifactTypeEnum.VENDOR_LICENSE.getType().equals(ArtifactTypeEnum.findType(artifactType))
814 && !ArtifactTypeEnum.VF_LICENSE.getType().equals(ArtifactTypeEnum.findType(artifactType));
817 protected Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> organizeVfCsarArtifactsByArtifactOperation(
818 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList, List<ArtifactDefinition> existingArtifactsToHandle, Component component,
820 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> nodeTypeArtifactsToHandle = new EnumMap<>(
821 ArtifactsBusinessLogic.ArtifactOperationEnum.class);
822 Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
823 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> nodeTypeArtifactsToHandleRes = Either
824 .left(nodeTypeArtifactsToHandle);
826 List<CsarUtils.NonMetaArtifactInfo> artifactsToUpload = new ArrayList<>(artifactPathAndNameList);
827 List<CsarUtils.NonMetaArtifactInfo> artifactsToUpdate = new ArrayList<>();
828 List<CsarUtils.NonMetaArtifactInfo> artifactsToDelete = new ArrayList<>();
829 for (CsarUtils.NonMetaArtifactInfo currNewArtifact : artifactPathAndNameList) {
830 ArtifactDefinition foundArtifact;
831 if (!existingArtifactsToHandle.isEmpty()) {
832 foundArtifact = existingArtifactsToHandle.stream().filter(a -> a.getArtifactName().equals(currNewArtifact.getArtifactName()))
833 .findFirst().orElse(null);
834 if (foundArtifact != null) {
835 if (ArtifactTypeEnum.findType(foundArtifact.getArtifactType()).equals(currNewArtifact.getArtifactType())) {
836 if (!foundArtifact.getArtifactChecksum().equals(currNewArtifact.getArtifactChecksum())) {
837 currNewArtifact.setArtifactUniqueId(foundArtifact.getUniqueId());
838 artifactsToUpdate.add(currNewArtifact);
840 existingArtifactsToHandle.remove(foundArtifact);
841 artifactsToUpload.remove(currNewArtifact);
843 log.debug("Can't upload two artifact with the same name {}.", currNewArtifact.getArtifactName());
844 ResponseFormat responseFormat = ResponseFormatManager.getInstance()
845 .getResponseFormat(ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, currNewArtifact.getArtifactName(),
846 currNewArtifact.getArtifactType(), foundArtifact.getArtifactType());
847 AuditingActionEnum auditingAction = artifactsBusinessLogic.detectAuditingType(
848 new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE),
849 foundArtifact.getArtifactChecksum());
850 artifactsBusinessLogic.handleAuditing(auditingAction, component, component.getUniqueId(), user, null, null,
851 foundArtifact.getUniqueId(), responseFormat, component.getComponentType(), null);
852 responseWrapper.setInnerElement(responseFormat);
858 if (responseWrapper.isEmpty()) {
859 for (ArtifactDefinition currArtifact : existingArtifactsToHandle) {
860 if (currArtifact.getIsFromCsar()) {
861 artifactsToDelete.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
862 ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null,
863 currArtifact.getUniqueId(), currArtifact.getIsFromCsar()));
865 artifactsToUpdate.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
866 ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null,
867 currArtifact.getUniqueId(), currArtifact.getIsFromCsar()));
871 if (responseWrapper.isEmpty()) {
872 if (!artifactsToUpload.isEmpty()) {
873 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, artifactsToUpload);
875 if (!artifactsToUpdate.isEmpty()) {
876 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE, artifactsToUpdate);
878 if (!artifactsToDelete.isEmpty()) {
879 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE, artifactsToDelete);
882 if (!responseWrapper.isEmpty()) {
883 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
885 } catch (Exception e) {
886 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
887 responseWrapper.setInnerElement(responseFormat);
888 log.debug("Exception occured when findNodeTypeArtifactsToHandle, error is:{}", e.getMessage(), e);
889 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
891 return nodeTypeArtifactsToHandleRes;
894 protected Either<List<CsarUtils.NonMetaArtifactInfo>, String> getValidArtifactNames(CsarInfo csarInfo,
895 Map<String, Set<List<String>>> collectedWarningMessages) {
896 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = csarInfo.getCsar().entrySet().stream()
897 .filter(e -> Pattern.compile(VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN).matcher(e.getKey()).matches())
898 .map(e -> CsarUtils.validateNonMetaArtifact(e.getKey(), e.getValue(), collectedWarningMessages)).filter(Either::isLeft)
899 .map(e -> e.left().value()).collect(toList());
900 Pattern englishNumbersAndUnderScoresOnly = Pattern.compile(CsarUtils.VALID_ENGLISH_ARTIFACT_NAME);
901 for (CsarUtils.NonMetaArtifactInfo nonMetaArtifactInfo : artifactPathAndNameList) {
902 if (!englishNumbersAndUnderScoresOnly.matcher(nonMetaArtifactInfo.getDisplayName()).matches()) {
903 return Either.right(nonMetaArtifactInfo.getArtifactName());
906 return Either.left(artifactPathAndNameList);
909 protected Either<Service, ResponseFormat> createGroupsOnResource(Service service, Map<String, GroupDefinition> groups) {
910 if (groups != null && !groups.isEmpty()) {
911 List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, service);
912 serviceImportParseLogic.handleGroupsProperties(service, groups);
913 serviceImportParseLogic.fillGroupsFinalFields(groupsAsList);
914 Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic.createGroups(service, groupsAsList, true);
915 if (createGroups.isRight()) {
916 return Either.right(createGroups.right().value());
919 return Either.left(service);
921 return getServiceResponseFormatEither(service);
924 private Either<Service, ResponseFormat> createPoliciesOnResource(Service service,
925 Map<String, PolicyDefinition> policies) {
926 if (MapUtils.isNotEmpty(policies)) {
927 policyBusinessLogic.createPolicies(service, policies);
929 return Either.left(service);
931 return getServiceResponseFormatEither(service);
934 private Either<Service, ResponseFormat> getServiceResponseFormatEither(Service service) {
935 Either<Service, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
936 if (updatedResource.isRight()) {
937 ResponseFormat responseFormat = componentsUtils
938 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), service,
939 ComponentTypeEnum.SERVICE);
940 return Either.right(responseFormat);
942 return Either.left(updatedResource.left().value());
945 protected List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups, Service component) {
946 List<GroupDefinition> result = new ArrayList<>();
947 List<ComponentInstance> componentInstances = component.getComponentInstances();
948 if (groups != null) {
949 for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
950 String groupName = entry.getKey();
951 GroupDefinition groupDefinition = entry.getValue();
952 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
953 updatedGroupDefinition.setMembers(null);
954 Map<String, String> members = groupDefinition.getMembers();
955 if (members != null) {
956 serviceImportParseLogic.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
958 result.add(updatedGroupDefinition);
964 protected Resource createRIAndRelationsFromYaml(String yamlName, Resource resource,
965 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap,
966 String topologyTemplateYaml, List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
967 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
968 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
971 log.debug("************* Going to create all nodes {}", yamlName);
972 handleNodeTypes(yamlName, resource, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
974 log.debug("************* Going to create all resource instances {}", yamlName);
975 resource = createResourceInstances(yamlName, resource, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes());
976 log.debug("************* Finished to create all resource instances {}", yamlName);
977 resource = createResourceInstancesRelations(csarInfo.getModifier(), yamlName, resource, uploadComponentInstanceInfoMap);
978 log.debug("************* Going to create positions {}", yamlName);
979 compositionBusinessLogic.setPositionsForComponentInstances(resource, csarInfo.getModifier().getUserId());
980 log.debug("************* Finished to set positions {}", yamlName);
982 } catch (Exception e) {
983 throw new ComponentException(ActionStatus.GENERAL_ERROR);
987 protected Resource createResourceInstancesRelations(User user, String yamlName, Resource resource,
988 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
989 log.debug("#createResourceInstancesRelations - Going to create relations ");
990 List<ComponentInstance> componentInstancesList = resource.getComponentInstances();
991 if (((MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)) &&
992 resource.getResourceType() != ResourceTypeEnum.PNF)) { // PNF can have no resource instances
993 log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
994 resource.getUniqueId(), yamlName);
995 BeEcompErrorManager.getInstance()
996 .logInternalDataError("createResourceInstancesRelations", "No instances found in a resource or nn yaml template. ",
997 BeEcompErrorManager.ErrorSeverity.ERROR);
998 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName));
1000 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1001 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1002 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1003 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1004 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1005 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1006 Map<String, Resource> originCompMap = new HashMap<>();
1007 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1008 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1009 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1011 log.debug("enter ServiceImportBusinessLogic createResourceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. ");
1012 final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache;
1013 if (applicationDataTypeCache != null) {
1014 Resource finalResource = resource;
1015 uploadResInstancesMap.values().forEach(
1016 i -> processComponentInstance(yamlName, finalResource, componentInstancesList,
1017 componentsUtils.getAllDataTypes(applicationDataTypeCache, finalResource.getModel()), instProperties, instCapabilities,
1018 instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs, instNodeFilter, i));
1020 serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, resource, instProperties);
1021 serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, resource, instInputs);
1022 serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts);
1023 serviceImportParseLogic.associateArtifactsToInstances(yamlName, resource, instArtifacts);
1024 serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements);
1025 serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes);
1026 resource = serviceImportParseLogic.getResourceAfterCreateRelations(resource);
1027 serviceImportParseLogic.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList, relations);
1028 serviceImportParseLogic.associateResourceInstances(yamlName, resource, relations);
1029 handleSubstitutionMappings(resource, uploadResInstancesMap);
1030 log.debug("************* in create relations, getResource start");
1031 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
1032 log.debug("************* in create relations, getResource end");
1033 if (eitherGetResource.isRight()) {
1034 throw new ComponentException(
1035 componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource));
1037 return eitherGetResource.left().value();
1040 protected void processProperty(Resource resource, ComponentInstance currentCompInstance, Map<String, DataTypeDefinition> allDataTypes,
1041 Map<String, InputDefinition> currPropertiesMap, List<ComponentInstanceInput> instPropList,
1042 List<UploadPropInfo> propertyList) {
1043 UploadPropInfo propertyInfo = propertyList.get(0);
1044 String propName = propertyInfo.getName();
1045 if (!currPropertiesMap.containsKey(propName)) {
1046 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName));
1048 processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, resource.getInputs());
1051 private void processProperty(Map<String, DataTypeDefinition> allDataTypes, Map<String, InputDefinition> currPropertiesMap,
1052 List<ComponentInstanceInput> instPropList, UploadPropInfo propertyInfo, String propName,
1053 List<InputDefinition> inputs2) {
1054 InputDefinition curPropertyDef = currPropertiesMap.get(propName);
1055 ComponentInstanceInput property = null;
1056 String value = null;
1057 List<GetInputValueDataDefinition> getInputs = null;
1058 boolean isValidate = true;
1059 if (propertyInfo.getValue() != null) {
1060 getInputs = propertyInfo.getGet_input();
1061 isValidate = getInputs == null || getInputs.isEmpty();
1063 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
1065 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
1068 property = new ComponentInstanceInput(curPropertyDef, value, null);
1069 String validPropertyVAlue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
1070 property.setValue(validPropertyVAlue);
1071 if (isNotEmpty(getInputs)) {
1072 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1073 for (GetInputValueDataDefinition getInput : getInputs) {
1074 List<InputDefinition> inputs = inputs2;
1075 if (CollectionUtils.isEmpty(inputs)) {
1076 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1078 Optional<InputDefinition> optional = inputs.stream().filter(p -> p.getName().equals(getInput.getInputName())).findAny();
1079 if (!optional.isPresent()) {
1080 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1082 InputDefinition input = optional.get();
1083 getInput.setInputId(input.getUniqueId());
1084 getInputValues.add(getInput);
1085 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
1086 processGetInput(getInputValues, inputs, getInputIndex);
1088 property.setGetInputValues(getInputValues);
1090 instPropList.add(property);
1091 currPropertiesMap.remove(property.getName());
1094 protected void handleSubstitutionMappings(Resource resource, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1095 if (resource.getResourceType() == ResourceTypeEnum.VF) {
1096 Either<Resource, StorageOperationStatus> getResourceRes = toscaOperationFacade.getToscaFullElement(resource.getUniqueId());
1097 if (getResourceRes.isRight()) {
1098 ResponseFormat responseFormat = componentsUtils
1099 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource);
1100 throw new ComponentException(responseFormat);
1102 getResourceRes = updateCalculatedCapReqWithSubstitutionMappings(getResourceRes.left().value(), uploadResInstancesMap);
1103 if (getResourceRes.isRight()) {
1104 ResponseFormat responseFormat = componentsUtils
1105 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource);
1106 throw new ComponentException(responseFormat);
1111 protected Resource createResourceInstances(String yamlName, Resource resource, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1112 Map<String, Resource> nodeNamespaceMap) {
1113 Either<Resource, ResponseFormat> eitherResource = null;
1114 log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
1115 if (MapUtils.isEmpty(uploadResInstancesMap) && resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
1116 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
1117 throw new ComponentException(responseFormat);
1119 Map<String, Resource> existingNodeTypeMap = new HashMap<>();
1120 if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
1121 nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v));
1123 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1124 uploadResInstancesMap.values()
1125 .forEach(i -> createAndAddResourceInstance(i, yamlName, resource, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap));
1126 if (MapUtils.isNotEmpty(resourcesInstancesMap)) {
1128 toscaOperationFacade.associateComponentInstancesToComponent(resource, resourcesInstancesMap, false, false);
1129 } catch (StorageException exp) {
1130 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
1131 log.debug("Failed to add component instances to container component {}", resource.getName());
1132 ResponseFormat responseFormat = componentsUtils
1133 .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
1134 eitherResource = Either.right(responseFormat);
1135 throw new ByResponseFormatComponentException(eitherResource.right().value());
1139 log.debug("*************Going to get resource {}", resource.getUniqueId());
1140 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade
1141 .getToscaElement(resource.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter());
1142 log.debug("*************finished to get resource {}", resource.getUniqueId());
1143 if (eitherGetResource.isRight()) {
1144 ResponseFormat responseFormat = componentsUtils
1145 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource);
1146 throw new ComponentException(responseFormat);
1148 if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances()) &&
1149 resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
1150 log.debug("Error when create resource instance from csar. ComponentInstances list empty");
1151 BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty");
1152 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
1154 return eitherGetResource.left().value();
1157 protected void handleNodeTypes(String yamlName, Resource resource, String topologyTemplateYaml, boolean needLock,
1158 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1159 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1162 for (Map.Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
1163 if (nodeTypeEntry.getValue().isNested()) {
1164 handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1165 nodeTypeEntry.getKey());
1166 log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
1169 Map<String, Object> mappedToscaTemplate = null;
1170 if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo
1171 .containsKey(nodeName)) {
1172 mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
1174 if (MapUtils.isEmpty(mappedToscaTemplate)) {
1175 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
1177 createResourcesFromYamlNodeTypesList(yamlName, resource, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle,
1178 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
1179 } catch (ComponentException e) {
1180 ResponseFormat responseFormat =
1181 e.getResponseFormat() != null ? e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
1182 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
1184 } catch (StorageException e) {
1185 ResponseFormat responseFormat = componentsUtils
1186 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
1187 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
1189 } catch (Exception e) {
1190 log.debug("Exception occured when handleNodeTypes, error is:{}", e.getMessage(), e);
1191 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1195 protected Resource handleNestedVfc(Service service,
1196 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1197 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1200 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
1201 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
1202 createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
1204 log.debug("************* Finished to create node types from yaml {}", yamlName);
1205 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1206 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1207 return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
1209 return new Resource();
1210 } catch (Exception e) {
1211 log.debug("Exception occured when handleNestedVFc, error is:{}", e.getMessage(), e);
1212 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1216 protected Resource handleNestedVfc(Resource resource,
1217 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1218 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1220 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
1221 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
1222 log.debug("************* Going to create node types from yaml {}", yamlName);
1223 createResourcesFromYamlNodeTypesList(yamlName, resource, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
1225 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1226 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1227 resource = handleComplexVfc(resource, nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
1232 protected Resource handleComplexVfc(Resource resource,
1233 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1234 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1235 String nodeName, String yamlName) {
1236 Resource oldComplexVfc = null;
1237 Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(resource, csarInfo, nodeName, nodesInfo);
1238 Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
1239 .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
1240 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
1241 oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
1242 serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), nodeName).getRight());
1244 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
1245 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1246 } else if (oldComplexVfcRes.isLeft()) {
1247 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
1248 Either<Boolean, ResponseFormat> eitherValidation = serviceImportParseLogic
1249 .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc,
1250 ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
1251 if (eitherValidation.isLeft()) {
1252 oldComplexVfc = oldComplexVfcRes.left().value();
1255 newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc,
1257 csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
1258 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
1259 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR);
1260 log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
1261 final Resource result = serviceImportParseLogic
1262 .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true);
1263 csarInfo.getCreatedNodes().put(nodeName, result);
1264 csarInfo.removeNodeFromQueue();
1268 private Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Resource resource, Map<String, Object> mappedToscaTemplate,
1270 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1271 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1272 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
1273 Either<String, ImportUtils.ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
1274 TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
1275 if (toscaVersion.isRight()) {
1276 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
1278 Map<String, Object> mapToConvert = new HashMap<>();
1279 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value());
1280 Map<String, Object> nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate);
1281 createNodeTypes(yamlName, resource, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert,
1283 return csarInfo.getCreatedNodes();
1286 protected void createNodeTypes(String yamlName, Resource resource, boolean needLock,
1287 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1288 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1289 Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
1290 Iterator<Map.Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet().iterator();
1291 Resource vfcCreated = null;
1292 while (nodesNameValueIter.hasNext()) {
1293 Map.Entry<String, Object> nodeType = nodesNameValueIter.next();
1294 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle =
1295 nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeType.getKey());
1296 if (nodeTypesInfo.containsKey(nodeType.getKey())) {
1297 log.trace("************* Going to handle nested vfc {}", nodeType.getKey());
1298 vfcCreated = handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1300 log.trace("************* Finished to handle nested vfc {}", nodeType.getKey());
1301 } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames()
1302 .containsKey(nodeType.getKey())) {
1303 log.trace("************* Going to create node {}", nodeType.getKey());
1304 ImmutablePair<Resource, ActionStatus> resourceCreated = createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(),
1305 mapToConvert, resource, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true);
1306 log.debug("************* Finished to create node {}", nodeType.getKey());
1307 vfcCreated = resourceCreated.getLeft();
1308 csarInfo.getCreatedNodesToscaResourceNames().put(nodeType.getKey(), vfcCreated.getToscaResourceName());
1310 if (vfcCreated != null) {
1311 csarInfo.getCreatedNodes().put(nodeType.getKey(), vfcCreated);
1313 mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());
1317 protected ImmutablePair<Resource, ActionStatus> createNodeTypeResourceFromYaml(String yamlName, Map.Entry<String, Object> nodeNameValue,
1318 User user, Map<String, Object> mapToConvert, Resource resourceVf,
1320 Map<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
1321 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1322 boolean forceCertificationAllowed, CsarInfo csarInfo,
1324 UploadResourceInfo resourceMetaData = serviceImportParseLogic.fillResourceMetadata(yamlName, resourceVf, nodeNameValue.getKey(), user);
1325 String singleVfcYaml = serviceImportParseLogic.buildNodeTypeYaml(nodeNameValue, mapToConvert, resourceMetaData.getResourceType(), csarInfo);
1326 user = serviceBusinessLogic.validateUser(user, "CheckIn Resource", resourceVf, AuditingActionEnum.CHECKIN_RESOURCE, true);
1327 return serviceImportParseLogic.createResourceFromNodeType(singleVfcYaml, resourceMetaData, user, true, needLock, nodeTypeArtifactsToHandle,
1328 nodeTypesNewCreatedArtifacts, forceCertificationAllowed, csarInfo, nodeNameValue.getKey(), isNested);
1331 protected Service createRIAndRelationsFromYaml(String yamlName, Service service,
1332 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap,
1333 String topologyTemplateYaml, List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1334 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1335 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
1337 log.debug("************* Going to create all nodes {}", yamlName);
1338 handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts,
1339 nodeTypesInfo, csarInfo, nodeName);
1340 if (MapUtils.isNotEmpty(uploadComponentInstanceInfoMap)) {
1341 log.debug("************* Going to create all resource instances {}", yamlName);
1342 service = createServiceInstances(yamlName, service, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes());
1343 log.debug("************* Going to create all relations {}", yamlName);
1344 service = createServiceInstancesRelations(csarInfo.getModifier(), yamlName, service, uploadComponentInstanceInfoMap);
1345 log.debug("************* Going to create positions {}", yamlName);
1346 compositionBusinessLogic.setPositionsForComponentInstances(service, csarInfo.getModifier().getUserId());
1347 log.debug("************* Finished to set positions {}", yamlName);
1352 protected Service createServiceInstancesRelations(User user, String yamlName, Service service,
1353 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1354 log.debug("#createResourceInstancesRelations - Going to create relations ");
1355 List<ComponentInstance> componentInstancesList = service.getComponentInstances();
1356 if (((MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)))) { // PNF can have no resource instances
1357 log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
1358 service.getUniqueId(), yamlName);
1359 BeEcompErrorManager.getInstance()
1360 .logInternalDataError("createResourceInstancesRelations", "No instances found in a component or nn yaml template. ",
1361 BeEcompErrorManager.ErrorSeverity.ERROR);
1362 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName));
1364 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1365 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1366 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1367 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1368 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1369 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1370 Map<String, Resource> originCompMap = new HashMap<>();
1371 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1372 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1373 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1374 log.debug("enter ServiceImportBusinessLogic createServiceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. ");
1375 final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache;
1376 if (applicationDataTypeCache != null) {
1377 Service finalResource = service;
1378 uploadResInstancesMap.values().forEach(
1379 i -> processComponentInstance(yamlName, finalResource, componentInstancesList,
1380 componentsUtils.getAllDataTypes(applicationDataTypeCache, finalResource.getModel()), instProperties,
1381 instCapabilities, instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs,
1382 instNodeFilter, i));
1384 serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, service, instProperties);
1385 serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, service, instInputs);
1386 serviceImportParseLogic.associateCINodeFilterToComponent(yamlName, service, instNodeFilter);
1387 serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, service, instDeploymentArtifacts);
1388 serviceImportParseLogic.associateArtifactsToInstances(yamlName, service, instArtifacts);
1389 serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, service, instCapabilities, instRequirements);
1390 log.debug("enter createServiceInstancesRelations test,instRequirements:{},instCapabilities:{}", instRequirements, instCapabilities);
1391 serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, service, instAttributes);
1392 ToscaElement serviceTemplate = ModelConverter.convertToToscaElement(service);
1393 Map<String, ListCapabilityDataDefinition> capabilities = serviceTemplate.getCapabilities();
1394 Map<String, ListRequirementDataDefinition> requirements = serviceTemplate.getRequirements();
1395 serviceImportParseLogic.associateCapabilitiesToService(yamlName, service, capabilities);
1396 serviceImportParseLogic.associateRequirementsToService(yamlName, service, requirements);
1397 service = getResourceAfterCreateRelations(service);
1398 addRelationsToRI(yamlName, service, uploadResInstancesMap, componentInstancesList, relations);
1399 serviceImportParseLogic.associateResourceInstances(yamlName, service, relations);
1400 log.debug("************* in create relations, getResource start");
1401 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
1402 log.debug("************* in create relations, getResource end");
1403 if (eitherGetResource.isRight()) {
1404 throw new ComponentException(componentsUtils
1405 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service,
1406 service.getComponentType()));
1408 return eitherGetResource.left().value();
1411 protected void processComponentInstance(String yamlName, Component component, List<ComponentInstance> componentInstancesList,
1412 Map<String, DataTypeDefinition> allDataTypes,
1413 Map<String, List<ComponentInstanceProperty>> instProperties,
1414 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
1415 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements,
1416 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts,
1417 Map<String, Map<String, ArtifactDefinition>> instArtifacts,
1418 Map<String, List<AttributeDefinition>> instAttributes, Map<String, Resource> originCompMap,
1419 Map<String, List<ComponentInstanceInput>> instInputs,
1420 Map<String, UploadNodeFilterInfo> instNodeFilter,
1421 UploadComponentInstanceInfo uploadComponentInstanceInfo) {
1422 log.debug("enter ServiceImportBusinessLogic processComponentInstance");
1423 Optional<ComponentInstance> currentCompInstanceOpt = componentInstancesList.stream()
1424 .filter(i -> i.getName().equals(uploadComponentInstanceInfo.getName())).findFirst();
1425 if (!currentCompInstanceOpt.isPresent()) {
1426 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), component.getUniqueId());
1427 BeEcompErrorManager.getInstance()
1428 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, component.getUniqueId(),
1429 BeEcompErrorManager.ErrorSeverity.ERROR);
1430 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1431 throw new ComponentException(responseFormat);
1433 ComponentInstance currentCompInstance = currentCompInstanceOpt.get();
1434 String resourceInstanceId = currentCompInstance.getUniqueId();
1435 Resource originResource = getOriginResource(yamlName, originCompMap, currentCompInstance);
1436 if (MapUtils.isNotEmpty(originResource.getRequirements())) {
1437 instRequirements.put(currentCompInstance, originResource.getRequirements());
1439 if (MapUtils.isNotEmpty(originResource.getCapabilities())) {
1440 processComponentInstanceCapabilities(allDataTypes, instCapabilties, uploadComponentInstanceInfo, currentCompInstance, originResource);
1442 if (originResource.getDeploymentArtifacts() != null && !originResource.getDeploymentArtifacts().isEmpty()) {
1443 instDeploymentArtifacts.put(resourceInstanceId, originResource.getDeploymentArtifacts());
1445 if (originResource.getArtifacts() != null && !originResource.getArtifacts().isEmpty()) {
1446 instArtifacts.put(resourceInstanceId, originResource.getArtifacts());
1448 if (originResource.getAttributes() != null && !originResource.getAttributes().isEmpty()) {
1449 instAttributes.put(resourceInstanceId, originResource.getAttributes());
1451 if (uploadComponentInstanceInfo.getUploadNodeFilterInfo() != null) {
1452 instNodeFilter.put(resourceInstanceId, uploadComponentInstanceInfo.getUploadNodeFilterInfo());
1454 if (originResource.getResourceType() != ResourceTypeEnum.VF) {
1455 ResponseFormat addPropertiesValueToRiRes = addPropertyValuesToRi(uploadComponentInstanceInfo, component, originResource,
1456 currentCompInstance, instProperties, allDataTypes);
1457 if (addPropertiesValueToRiRes.getStatus() != 200) {
1458 throw new ComponentException(addPropertiesValueToRiRes);
1461 addInputsValuesToRi(uploadComponentInstanceInfo, component, originResource, currentCompInstance, instInputs, allDataTypes);
1465 protected void addInputsValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component, Resource originResource,
1466 ComponentInstance currentCompInstance, Map<String, List<ComponentInstanceInput>> instInputs,
1467 Map<String, DataTypeDefinition> allDataTypes) {
1468 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
1470 if (MapUtils.isNotEmpty(propMap)) {
1471 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
1472 List<ComponentInstanceInput> instPropList = new ArrayList<>();
1473 if (CollectionUtils.isEmpty(originResource.getInputs())) {
1474 log.debug("failed to find properties ");
1475 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND));
1477 originResource.getInputs().forEach(p -> serviceImportParseLogic.addInput(currPropertiesMap, p));
1478 for (List<UploadPropInfo> propertyList : propMap.values()) {
1479 processProperty(component, currentCompInstance, allDataTypes, currPropertiesMap, instPropList, propertyList);
1481 currPropertiesMap.values().forEach(p -> instPropList.add(new ComponentInstanceInput(p)));
1482 instInputs.put(currentCompInstance.getUniqueId(), instPropList);
1484 } catch (Exception e) {
1485 log.debug("failed to add Inputs Values To Ri");
1486 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1490 protected void processProperty(Component component, ComponentInstance currentCompInstance, Map<String, DataTypeDefinition> allDataTypes,
1491 Map<String, InputDefinition> currPropertiesMap, List<ComponentInstanceInput> instPropList,
1492 List<UploadPropInfo> propertyList) {
1493 UploadPropInfo propertyInfo = propertyList.get(0);
1494 String propName = propertyInfo.getName();
1495 if (!currPropertiesMap.containsKey(propName)) {
1496 log.debug("failed to find property {} ", propName);
1497 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName));
1499 processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, component.getInputs());
1502 protected void processGetInput(List<GetInputValueDataDefinition> getInputValues, List<InputDefinition> inputs,
1503 GetInputValueDataDefinition getInputIndex) {
1504 Optional<InputDefinition> optional;
1505 if (getInputIndex != null) {
1506 optional = inputs.stream().filter(p -> p.getName().equals(getInputIndex.getInputName())).findAny();
1507 if (!optional.isPresent()) {
1508 log.debug("Failed to find input {} ", getInputIndex.getInputName());
1509 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1511 InputDefinition inputIndex = optional.get();
1512 getInputIndex.setInputId(inputIndex.getUniqueId());
1513 getInputValues.add(getInputIndex);
1517 protected ResponseFormat addPropertyValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component,
1518 Resource originResource, ComponentInstance currentCompInstance,
1519 Map<String, List<ComponentInstanceProperty>> instProperties,
1520 Map<String, DataTypeDefinition> allDataTypes) {
1521 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
1522 Map<String, PropertyDefinition> currPropertiesMap = new HashMap<>();
1523 List<PropertyDefinition> listFromMap = originResource.getProperties();
1524 if ((propMap != null && !propMap.isEmpty()) && (listFromMap == null || listFromMap.isEmpty())) {
1525 log.debug("failed to find properties ");
1526 return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND);
1528 if (listFromMap == null || listFromMap.isEmpty()) {
1529 return componentsUtils.getResponseFormat(ActionStatus.OK);
1531 for (PropertyDefinition prop : listFromMap) {
1532 String propName = prop.getName();
1533 if (!currPropertiesMap.containsKey(propName)) {
1534 currPropertiesMap.put(propName, prop);
1537 List<ComponentInstanceProperty> instPropList = new ArrayList<>();
1538 if (propMap != null && propMap.size() > 0) {
1539 for (List<UploadPropInfo> propertyList : propMap.values()) {
1540 UploadPropInfo propertyInfo = propertyList.get(0);
1541 String propName = propertyInfo.getName();
1542 if (!currPropertiesMap.containsKey(propName)) {
1543 log.debug("failed to find property {} ", propName);
1544 return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName);
1546 PropertyDefinition curPropertyDef = currPropertiesMap.get(propName);
1547 ComponentInstanceProperty property = null;
1548 String value = null;
1549 List<GetInputValueDataDefinition> getInputs = null;
1550 boolean isValidate = true;
1551 if (propertyInfo.getValue() != null) {
1552 getInputs = propertyInfo.getGet_input();
1553 isValidate = getInputs == null || getInputs.isEmpty();
1555 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
1557 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
1560 property = new ComponentInstanceProperty(curPropertyDef, value, null);
1561 String validatePropValue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
1562 property.setValue(validatePropValue);
1563 if (getInputs != null && !getInputs.isEmpty()) {
1564 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1565 for (GetInputValueDataDefinition getInput : getInputs) {
1566 List<InputDefinition> inputs = component.getInputs();
1567 if (inputs == null || inputs.isEmpty()) {
1568 log.debug("Failed to add property {} to instance. Inputs list is empty ", property);
1569 serviceBusinessLogic.rollbackWithException(ActionStatus.INPUTS_NOT_FOUND,
1570 property.getGetInputValues().stream().map(GetInputValueDataDefinition::getInputName).collect(toList()).toString());
1572 InputDefinition input = serviceImportParseLogic.findInputByName(inputs, getInput);
1573 getInput.setInputId(input.getUniqueId());
1574 getInputValues.add(getInput);
1575 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
1576 if (getInputIndex != null) {
1577 input = serviceImportParseLogic.findInputByName(inputs, getInputIndex);
1578 getInputIndex.setInputId(input.getUniqueId());
1579 getInputValues.add(getInputIndex);
1582 property.setGetInputValues(getInputValues);
1584 instPropList.add(property);
1585 currPropertiesMap.remove(property.getName());
1588 if (!currPropertiesMap.isEmpty()) {
1589 for (PropertyDefinition value : currPropertiesMap.values()) {
1590 instPropList.add(new ComponentInstanceProperty(value));
1593 instProperties.put(currentCompInstance.getUniqueId(), instPropList);
1594 return componentsUtils.getResponseFormat(ActionStatus.OK);
1597 protected void processComponentInstanceCapabilities(Map<String, DataTypeDefinition> allDataTypes,
1598 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
1599 UploadComponentInstanceInfo uploadComponentInstanceInfo,
1600 ComponentInstance currentCompInstance, Resource originResource) {
1601 log.debug("enter processComponentInstanceCapabilities");
1602 Map<String, List<CapabilityDefinition>> originCapabilities;
1603 if (MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities())) {
1604 originCapabilities = new HashMap<>();
1605 Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
1606 originResource.getCapabilities().forEach((k, v) -> serviceImportParseLogic.addCapabilities(originCapabilities, k, v));
1607 uploadComponentInstanceInfo.getCapabilities().values()
1608 .forEach(l -> serviceImportParseLogic.addCapabilitiesProperties(newPropertiesMap, l));
1609 updateCapabilityPropertiesValues(allDataTypes, originCapabilities, newPropertiesMap);
1611 originCapabilities = originResource.getCapabilities();
1613 instCapabilties.put(currentCompInstance, originCapabilities);
1616 protected void updateCapabilityPropertiesValues(Map<String, DataTypeDefinition> allDataTypes,
1617 Map<String, List<CapabilityDefinition>> originCapabilities,
1618 Map<String, Map<String, UploadPropInfo>> newPropertiesMap) {
1619 originCapabilities.values().stream().flatMap(Collection::stream).filter(c -> newPropertiesMap.containsKey(c.getName()))
1620 .forEach(c -> updatePropertyValues(c.getProperties(), newPropertiesMap.get(c.getName()), allDataTypes));
1623 protected void updatePropertyValues(List<ComponentInstanceProperty> properties, Map<String, UploadPropInfo> newProperties,
1624 Map<String, DataTypeDefinition> allDataTypes) {
1625 properties.forEach(p -> updatePropertyValue(p, newProperties.get(p.getName()), allDataTypes));
1628 protected String updatePropertyValue(ComponentInstanceProperty property, UploadPropInfo propertyInfo,
1629 Map<String, DataTypeDefinition> allDataTypes) {
1630 String value = null;
1631 List<GetInputValueDataDefinition> getInputs = null;
1632 boolean isValidate = true;
1633 if (null != propertyInfo && propertyInfo.getValue() != null) {
1634 getInputs = propertyInfo.getGet_input();
1635 isValidate = getInputs == null || getInputs.isEmpty();
1637 value = getPropertyJsonStringValue(propertyInfo.getValue(), property.getType());
1639 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
1642 property.setValue(value);
1643 return serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
1646 protected Resource getOriginResource(String yamlName, Map<String, Resource> originCompMap, ComponentInstance currentCompInstance) {
1647 Resource originResource;
1648 log.debug("after enter ServiceImportBusinessLogic processComponentInstance, enter getOriginResource");
1649 if (!originCompMap.containsKey(currentCompInstance.getComponentUid())) {
1650 Either<Resource, StorageOperationStatus> getOriginResourceRes = toscaOperationFacade
1651 .getToscaFullElement(currentCompInstance.getComponentUid());
1652 if (getOriginResourceRes.isRight()) {
1653 ResponseFormat responseFormat = componentsUtils
1654 .getResponseFormat(componentsUtils.convertFromStorageResponse(getOriginResourceRes.right().value()), yamlName);
1655 throw new ComponentException(responseFormat);
1657 originResource = getOriginResourceRes.left().value();
1658 originCompMap.put(originResource.getUniqueId(), originResource);
1660 originResource = originCompMap.get(currentCompInstance.getComponentUid());
1662 return originResource;
1665 protected Either<Resource, StorageOperationStatus> updateCalculatedCapReqWithSubstitutionMappings(Resource resource,
1666 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1667 Either<Resource, StorageOperationStatus> updateRes = null;
1668 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities = new HashMap<>();
1669 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements = new HashMap<>();
1670 StorageOperationStatus status = toscaOperationFacade.deleteAllCalculatedCapabilitiesRequirements(resource.getUniqueId());
1671 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
1672 log.debug("Failed to delete all calculated capabilities and requirements of resource {} upon update. Status is {}",
1673 resource.getUniqueId(), status);
1674 updateRes = Either.right(status);
1676 if (updateRes == null) {
1677 fillUpdatedInstCapabilitiesRequirements(resource.getComponentInstances(), uploadResInstancesMap, updatedInstCapabilities,
1678 updatedInstRequirements);
1679 status = toscaOperationFacade.associateOrAddCalculatedCapReq(updatedInstCapabilities, updatedInstRequirements, resource);
1680 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
1681 updateRes = Either.right(status);
1684 if (updateRes == null) {
1685 updateRes = Either.left(resource);
1690 protected void fillUpdatedInstCapabilitiesRequirements(List<ComponentInstance> componentInstances,
1691 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1692 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities,
1693 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements) {
1694 componentInstances.stream().forEach(i -> {
1695 fillUpdatedInstCapabilities(updatedInstCapabilities, i, uploadResInstancesMap.get(i.getName()).getCapabilitiesNamesToUpdate());
1696 fillUpdatedInstRequirements(updatedInstRequirements, i, uploadResInstancesMap.get(i.getName()).getRequirementsNamesToUpdate());
1700 protected void fillUpdatedInstCapabilities(Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilties,
1701 ComponentInstance instance, Map<String, String> capabilitiesNamesToUpdate) {
1702 Map<String, List<CapabilityDefinition>> updatedCapabilities = new HashMap<>();
1703 Set<String> updatedCapNames = new HashSet<>();
1704 if (MapUtils.isNotEmpty(capabilitiesNamesToUpdate)) {
1705 for (Map.Entry<String, List<CapabilityDefinition>> requirements : instance.getCapabilities().entrySet()) {
1706 updatedCapabilities.put(requirements.getKey(), requirements.getValue().stream().filter(
1707 c -> capabilitiesNamesToUpdate.containsKey(c.getName()) && !updatedCapNames.contains(capabilitiesNamesToUpdate.get(c.getName())))
1709 c.setParentName(c.getName());
1710 c.setName(capabilitiesNamesToUpdate.get(c.getName()));
1711 updatedCapNames.add(c.getName());
1713 }).collect(toList()));
1716 if (MapUtils.isNotEmpty(updatedCapabilities)) {
1717 updatedInstCapabilties.put(instance, updatedCapabilities);
1721 protected void fillUpdatedInstRequirements(Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements,
1722 ComponentInstance instance, Map<String, String> requirementsNamesToUpdate) {
1723 Map<String, List<RequirementDefinition>> updatedRequirements = new HashMap<>();
1724 Set<String> updatedReqNames = new HashSet<>();
1725 if (MapUtils.isNotEmpty(requirementsNamesToUpdate)) {
1726 for (Map.Entry<String, List<RequirementDefinition>> requirements : instance.getRequirements().entrySet()) {
1727 updatedRequirements.put(requirements.getKey(), requirements.getValue().stream().filter(
1728 r -> requirementsNamesToUpdate.containsKey(r.getName()) && !updatedReqNames.contains(requirementsNamesToUpdate.get(r.getName())))
1730 r.setParentName(r.getName());
1731 r.setName(requirementsNamesToUpdate.get(r.getName()));
1732 updatedReqNames.add(r.getName());
1734 }).collect(toList()));
1737 if (MapUtils.isNotEmpty(updatedRequirements)) {
1738 updatedInstRequirements.put(instance, updatedRequirements);
1742 protected void addRelationsToRI(String yamlName, Service service, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1743 List<ComponentInstance> componentInstancesList, List<RequirementCapabilityRelDef> relations) {
1744 for (Map.Entry<String, UploadComponentInstanceInfo> entry : uploadResInstancesMap.entrySet()) {
1745 UploadComponentInstanceInfo uploadComponentInstanceInfo = entry.getValue();
1746 ComponentInstance currentCompInstance = null;
1747 for (ComponentInstance compInstance : componentInstancesList) {
1748 if (compInstance.getName().equals(uploadComponentInstanceInfo.getName())) {
1749 currentCompInstance = compInstance;
1753 if (currentCompInstance == null) {
1754 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), service.getUniqueId());
1755 BeEcompErrorManager.getInstance()
1756 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, service.getUniqueId(),
1757 BeEcompErrorManager.ErrorSeverity.ERROR);
1758 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1759 throw new ComponentException(responseFormat);
1761 ResponseFormat addRelationToRiRes = addRelationToRI(yamlName, service, entry.getValue(), relations);
1762 if (addRelationToRiRes.getStatus() != 200) {
1763 throw new ComponentException(addRelationToRiRes);
1768 protected ResponseFormat addRelationToRI(String yamlName, Service service, UploadComponentInstanceInfo nodesInfoValue,
1769 List<RequirementCapabilityRelDef> relations) {
1770 List<ComponentInstance> componentInstancesList = service.getComponentInstances();
1771 ComponentInstance currentCompInstance = null;
1772 for (ComponentInstance compInstance : componentInstancesList) {
1773 if (compInstance.getName().equals(nodesInfoValue.getName())) {
1774 currentCompInstance = compInstance;
1778 if (currentCompInstance == null) {
1779 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, nodesInfoValue.getName(), service.getUniqueId());
1780 BeEcompErrorManager.getInstance()
1781 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + nodesInfoValue.getName() + IN_RESOURCE, service.getUniqueId(),
1782 BeEcompErrorManager.ErrorSeverity.ERROR);
1783 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1785 String resourceInstanceId = currentCompInstance.getUniqueId();
1786 Map<String, List<UploadReqInfo>> regMap = nodesInfoValue.getRequirements();
1787 if (regMap != null) {
1788 Iterator<Map.Entry<String, List<UploadReqInfo>>> nodesRegValue = regMap.entrySet().iterator();
1789 while (nodesRegValue.hasNext()) {
1790 Map.Entry<String, List<UploadReqInfo>> nodesRegInfoEntry = nodesRegValue.next();
1791 List<UploadReqInfo> uploadRegInfoList = nodesRegInfoEntry.getValue();
1792 for (UploadReqInfo uploadRegInfo : uploadRegInfoList) {
1793 log.debug("Going to create relation {}", uploadRegInfo.getName());
1794 String regName = uploadRegInfo.getName();
1795 RequirementCapabilityRelDef regCapRelDef = new RequirementCapabilityRelDef();
1796 regCapRelDef.setFromNode(resourceInstanceId);
1797 log.debug("try to find available requirement {} ", regName);
1798 Either<RequirementDefinition, ResponseFormat> eitherReqStatus = serviceImportParseLogic
1799 .findAvailableRequirement(regName, yamlName, nodesInfoValue, currentCompInstance, uploadRegInfo.getCapabilityName());
1800 if (eitherReqStatus.isRight()) {
1801 log.debug("failed to find available requirement {} status is {}", regName, eitherReqStatus.right().value());
1802 return eitherReqStatus.right().value();
1804 RequirementDefinition validReq = eitherReqStatus.left().value();
1805 List<CapabilityRequirementRelationship> reqAndRelationshipPairList = regCapRelDef.getRelationships();
1806 if (reqAndRelationshipPairList == null) {
1807 reqAndRelationshipPairList = new ArrayList<>();
1809 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1810 reqAndRelationshipPair.setRequirement(regName);
1811 reqAndRelationshipPair.setRequirementOwnerId(validReq.getOwnerId());
1812 reqAndRelationshipPair.setRequirementUid(validReq.getUniqueId());
1813 RelationshipImpl relationship = new RelationshipImpl();
1814 relationship.setType(validReq.getCapability());
1815 reqAndRelationshipPair.setRelationships(relationship);
1816 ComponentInstance currentCapCompInstance = null;
1817 for (ComponentInstance compInstance : componentInstancesList) {
1818 if (compInstance.getName().equals(uploadRegInfo.getNode())) {
1819 currentCapCompInstance = compInstance;
1823 if (currentCapCompInstance == null) {
1824 log.debug("The component instance with name {} not found on resource {} ", uploadRegInfo.getNode(), service.getUniqueId());
1825 BeEcompErrorManager.getInstance()
1826 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadRegInfo.getNode() + IN_RESOURCE, service.getUniqueId(),
1827 BeEcompErrorManager.ErrorSeverity.ERROR);
1828 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1830 regCapRelDef.setToNode(currentCapCompInstance.getUniqueId());
1831 log.debug("try to find aviable Capability req name is {} ", validReq.getName());
1832 CapabilityDefinition aviableCapForRel = serviceImportParseLogic
1833 .findAvailableCapabilityByTypeOrName(validReq, currentCapCompInstance, uploadRegInfo);
1834 if (aviableCapForRel == null) {
1835 BeEcompErrorManager.getInstance().logInternalDataError(
1836 "aviable capability was not found. req name is " + validReq.getName() + " component instance is " + currentCapCompInstance
1837 .getUniqueId(), service.getUniqueId(), BeEcompErrorManager.ErrorSeverity.ERROR);
1838 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1840 reqAndRelationshipPair.setCapability(aviableCapForRel.getName());
1841 reqAndRelationshipPair.setCapabilityUid(aviableCapForRel.getUniqueId());
1842 reqAndRelationshipPair.setCapabilityOwnerId(aviableCapForRel.getOwnerId());
1843 CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship();
1844 capReqRel.setRelation(reqAndRelationshipPair);
1845 reqAndRelationshipPairList.add(capReqRel);
1846 regCapRelDef.setRelationships(reqAndRelationshipPairList);
1847 relations.add(regCapRelDef);
1851 return componentsUtils.getResponseFormat(ActionStatus.OK, yamlName);
1854 protected Service getResourceAfterCreateRelations(Service service) {
1855 ComponentParametersView parametersView = serviceImportParseLogic.getComponentFilterAfterCreateRelations();
1856 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId(), parametersView);
1857 if (eitherGetResource.isRight()) {
1858 serviceImportParseLogic.throwComponentExceptionByResource(eitherGetResource.right().value(), service);
1860 return eitherGetResource.left().value();
1863 protected Service createServiceInstances(String yamlName, Service service, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1864 Map<String, Resource> nodeNamespaceMap) {
1865 Either<Resource, ResponseFormat> eitherResource = null;
1866 log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
1867 if (MapUtils.isEmpty(uploadResInstancesMap)) { // PNF can have no resource instances
1868 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
1869 throw new ComponentException(responseFormat);
1871 Map<String, Resource> existingNodeTypeMap = new HashMap<>();
1872 if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
1873 nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v));
1875 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1876 uploadResInstancesMap.values()
1877 .forEach(i -> createAndAddResourceInstance(i, yamlName, service, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap));
1878 if (MapUtils.isNotEmpty(resourcesInstancesMap)) {
1880 toscaOperationFacade.associateComponentInstancesToComponent(service, resourcesInstancesMap, false, false);
1881 } catch (StorageException exp) {
1882 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
1883 log.debug("Failed to add component instances to container component {}", service.getName());
1884 ResponseFormat responseFormat = componentsUtils
1885 .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
1886 eitherResource = Either.right(responseFormat);
1887 throw new ComponentException(eitherResource.right().value());
1891 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade
1892 .getToscaElement(service.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter());
1893 log.debug("*************finished to get resource {}", service.getUniqueId());
1894 if (eitherGetResource.isRight()) {
1895 ResponseFormat responseFormat = componentsUtils
1896 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service,
1897 ComponentTypeEnum.SERVICE);
1898 throw new ComponentException(responseFormat);
1900 if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances())) { // PNF can have no resource instances
1901 log.debug("Error when create resource instance from csar. ComponentInstances list empty");
1902 BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty");
1903 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
1905 return eitherGetResource.left().value();
1908 protected void createAndAddResourceInstance(UploadComponentInstanceInfo uploadComponentInstanceInfo, String yamlName, Component component,
1909 Map<String, Resource> nodeNamespaceMap, Map<String, Resource> existingnodeTypeMap,
1910 Map<ComponentInstance, Resource> resourcesInstancesMap) {
1911 log.debug("*************Going to create resource instances {}", uploadComponentInstanceInfo.getName());
1913 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
1914 uploadComponentInstanceInfo.setType(nodeNamespaceMap.get(uploadComponentInstanceInfo.getType()).getToscaResourceName());
1916 Resource refResource = validateResourceInstanceBeforeCreate(yamlName, uploadComponentInstanceInfo, existingnodeTypeMap);
1917 ComponentInstance componentInstance = new ComponentInstance();
1918 componentInstance.setComponentUid(refResource.getUniqueId());
1919 Collection<String> directives = uploadComponentInstanceInfo.getDirectives();
1920 if (directives != null && !directives.isEmpty()) {
1921 componentInstance.setDirectives(new ArrayList<>(directives));
1923 UploadNodeFilterInfo uploadNodeFilterInfo = uploadComponentInstanceInfo.getUploadNodeFilterInfo();
1924 if (uploadNodeFilterInfo != null) {
1926 .setNodeFilter(new CINodeFilterUtils().getNodeFilterDataDefinition(uploadNodeFilterInfo, componentInstance.getUniqueId()));
1928 ComponentTypeEnum containerComponentType = component.getComponentType();
1929 NodeTypeEnum containerNodeType = containerComponentType.getNodeType();
1930 if (containerNodeType.equals(NodeTypeEnum.Resource) && MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities()) && MapUtils
1931 .isNotEmpty(refResource.getCapabilities())) {
1932 serviceImportParseLogic.setCapabilityNamesTypes(refResource.getCapabilities(), uploadComponentInstanceInfo.getCapabilities());
1933 Map<String, List<CapabilityDefinition>> validComponentInstanceCapabilities = serviceImportParseLogic
1934 .getValidComponentInstanceCapabilities(refResource.getUniqueId(), refResource.getCapabilities(),
1935 uploadComponentInstanceInfo.getCapabilities());
1936 componentInstance.setCapabilities(validComponentInstanceCapabilities);
1938 if (!existingnodeTypeMap.containsKey(uploadComponentInstanceInfo.getType())) {
1939 ResponseFormat responseFormat = componentsUtils
1940 .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(),
1941 uploadComponentInstanceInfo.getType());
1942 throw new ComponentException(responseFormat);
1944 Resource origResource = existingnodeTypeMap.get(uploadComponentInstanceInfo.getType());
1945 componentInstance.setName(uploadComponentInstanceInfo.getName());
1946 componentInstance.setIcon(origResource.getIcon());
1947 resourcesInstancesMap.put(componentInstance, origResource);
1948 } catch (Exception e) {
1949 throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
1953 protected Resource validateResourceInstanceBeforeCreate(String yamlName, UploadComponentInstanceInfo uploadComponentInstanceInfo,
1954 Map<String, Resource> nodeNamespaceMap) {
1955 Resource refResource;
1957 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
1958 refResource = nodeNamespaceMap.get(uploadComponentInstanceInfo.getType());
1960 Either<Resource, StorageOperationStatus> findResourceEither = toscaOperationFacade
1961 .getLatestResourceByToscaResourceName(uploadComponentInstanceInfo.getType());
1962 if (findResourceEither.isRight()) {
1963 ResponseFormat responseFormat = componentsUtils
1964 .getResponseFormat(componentsUtils.convertFromStorageResponse(findResourceEither.right().value()));
1965 throw new ComponentException(responseFormat);
1967 refResource = findResourceEither.left().value();
1968 nodeNamespaceMap.put(refResource.getToscaResourceName(), refResource);
1970 String componentState = refResource.getComponentMetadataDefinition().getMetadataDataDefinition().getState();
1971 if (componentState.equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
1972 ResponseFormat responseFormat = componentsUtils
1973 .getResponseFormat(ActionStatus.ILLEGAL_COMPONENT_STATE, refResource.getComponentType().getValue(), refResource.getName(),
1975 throw new ComponentException(responseFormat);
1977 if (!ModelConverter.isAtomicComponent(refResource) && refResource.getResourceType() != ResourceTypeEnum.VF) {
1978 log.debug("validateResourceInstanceBeforeCreate - ref resource type is ", refResource.getResourceType());
1979 ResponseFormat responseFormat = componentsUtils
1980 .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(),
1981 uploadComponentInstanceInfo.getType());
1982 throw new ComponentException(responseFormat);
1985 } catch (Exception e) {
1986 throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
1990 protected void handleServiceNodeTypes(String yamlName, Service service, String topologyTemplateYaml, boolean needLock,
1991 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1992 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo,
1993 CsarInfo csarInfo, String nodeName) {
1995 for (Map.Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
1996 boolean isResourceNotExisted = validateResourceNotExisted(nodeTypeEntry.getKey());
1997 if (nodeTypeEntry.getValue().isNested() && isResourceNotExisted) {
1998 handleNestedVF(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1999 nodeTypeEntry.getKey());
2000 log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
2003 Map<String, Object> mappedToscaTemplate = null;
2004 if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo
2005 .containsKey(nodeName)) {
2006 mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
2008 if (MapUtils.isEmpty(mappedToscaTemplate)) {
2009 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
2011 createResourcesFromYamlNodeTypesList(yamlName, service, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle,
2012 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
2013 } catch (ComponentException | StorageException e) {
2015 } catch (Exception e) {
2016 log.debug("Exception occured when handleServiceNodeTypes, error is:{}", e.getMessage(), e);
2017 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2021 protected boolean validateResourceNotExisted(String type) {
2023 Either<Resource, StorageOperationStatus> latestResource = toscaOperationFacade.getLatestResourceByToscaResourceName(type);
2024 return latestResource.isRight();
2025 } catch (Exception e) {
2026 log.debug("Exception occured when validateResourceNotExisted, error is:{}", e.getMessage(), e);
2027 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2031 protected Resource handleNestedVF(Service service,
2032 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2033 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
2036 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
2037 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
2038 createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
2040 log.debug("************* Finished to create node types from yaml {}", yamlName);
2041 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
2042 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
2043 return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
2045 return new Resource();
2046 } catch (Exception e) {
2047 log.debug("Exception occured when handleNestedVF, error is:{}", e.getMessage(), e);
2048 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2052 protected Resource handleComplexVfc(
2053 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2054 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName) {
2056 Resource oldComplexVfc = null;
2057 Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(csarInfo, nodeName, nodesInfo);
2058 Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
2059 .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
2060 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
2061 oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
2062 serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), nodeName)
2065 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
2066 log.debug("Failed to fetch previous complex VFC by tosca resource name {}. Status is {}. ", newComplexVfc.getToscaResourceName(),
2067 oldComplexVfcRes.right().value());
2068 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2069 } else if (oldComplexVfcRes.isLeft()) {
2070 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
2071 Either<Boolean, ResponseFormat> eitherValidation = serviceImportParseLogic
2072 .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc,
2073 ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
2074 if (eitherValidation.isLeft()) {
2075 oldComplexVfc = oldComplexVfcRes.left().value();
2078 newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc,
2080 csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
2081 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
2082 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR);
2083 log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
2084 final Resource result = serviceImportParseLogic
2085 .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true);
2086 csarInfo.getCreatedNodes().put(nodeName, result);
2087 csarInfo.removeNodeFromQueue();
2089 } catch (Exception e) {
2090 log.debug("Exception occured when handleComplexVfc, error is:{}", e.getMessage(), e);
2091 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2095 protected Resource handleComplexVfc(
2096 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2097 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName,
2098 Resource oldComplexVfc, Resource newComplexVfc) {
2099 Resource handleComplexVfcRes;
2101 Map<String, Object> mappedToscaTemplate = nodesInfo.get(nodeName).getMappedToscaTemplate();
2102 String yamlContent = new String(csarInfo.getCsar().get(yamlName));
2103 Map<String, NodeTypeInfo> newNodeTypesInfo = nodesInfo.entrySet().stream()
2104 .collect(toMap(Map.Entry::getKey, e -> e.getValue().getUnmarkedCopy()));
2105 CsarInfo.markNestedVfc(mappedToscaTemplate, newNodeTypesInfo);
2106 if (oldComplexVfc == null) {
2107 handleComplexVfcRes = createResourceFromYaml(newComplexVfc, yamlContent, yamlName, newNodeTypesInfo, csarInfo, nodesArtifactsToHandle,
2108 false, true, nodeName);
2110 handleComplexVfcRes = updateResourceFromYaml(oldComplexVfc, newComplexVfc, AuditingActionEnum.UPDATE_RESOURCE_METADATA,
2111 createdArtifacts, yamlContent, yamlName, csarInfo, newNodeTypesInfo, nodesArtifactsToHandle, nodeName, true);
2113 return handleComplexVfcRes;
2114 } catch (Exception e) {
2115 log.debug("Exception occured when handleComplexVfc, error is:{}", e.getMessage(), e);
2116 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2120 protected Resource updateResourceFromYaml(Resource oldRresource, Resource newRresource, AuditingActionEnum actionEnum,
2121 List<ArtifactDefinition> createdArtifacts, String yamlFileName, String yamlFileContent,
2122 CsarInfo csarInfo, Map<String, NodeTypeInfo> nodeTypesInfo,
2123 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2124 String nodeName, boolean isNested) {
2125 boolean inTransaction = true;
2126 boolean shouldLock = false;
2127 Resource preparedResource = null;
2128 ParsedToscaYamlInfo uploadComponentInstanceInfoMap = null;
2130 uploadComponentInstanceInfoMap = csarBusinessLogic
2131 .getParsedToscaYamlInfo(yamlFileContent, yamlFileName, nodeTypesInfo, csarInfo, nodeName, oldRresource);
2132 Map<String, UploadComponentInstanceInfo> instances = uploadComponentInstanceInfoMap.getInstances();
2133 if (MapUtils.isEmpty(instances) && newRresource.getResourceType() != ResourceTypeEnum.PNF) {
2134 throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlFileName);
2136 preparedResource = updateExistingResourceByImport(newRresource, oldRresource, csarInfo.getModifier(), inTransaction, shouldLock,
2138 log.trace("YAML topology file found in CSAR, file name: {}, contents: {}", yamlFileName, yamlFileContent);
2139 serviceImportParseLogic.handleResourceGenericType(preparedResource);
2140 handleNodeTypes(yamlFileName, preparedResource, yamlFileContent, shouldLock, nodeTypesArtifactsToHandle, createdArtifacts, nodeTypesInfo,
2141 csarInfo, nodeName);
2142 preparedResource = serviceImportParseLogic.createInputsOnResource(preparedResource, uploadComponentInstanceInfoMap.getInputs());
2143 preparedResource = createResourceInstances(yamlFileName, preparedResource, instances, csarInfo.getCreatedNodes());
2144 preparedResource = createResourceInstancesRelations(csarInfo.getModifier(), yamlFileName, preparedResource, instances);
2145 } catch (ComponentException e) {
2146 ResponseFormat responseFormat =
2147 e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
2148 log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat);
2150 .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum);
2152 } catch (StorageException e) {
2153 ResponseFormat responseFormat = componentsUtils
2154 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
2155 log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat);
2157 .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum);
2160 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic.validateUpdateVfGroupNames(
2161 uploadComponentInstanceInfoMap.getGroups(), preparedResource.getSystemName());
2162 if (validateUpdateVfGroupNamesRes.isRight()) {
2163 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
2165 Map<String, GroupDefinition> groups;
2166 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
2167 groups = validateUpdateVfGroupNamesRes.left().value();
2169 groups = uploadComponentInstanceInfoMap.getGroups();
2171 serviceImportParseLogic.handleGroupsProperties(preparedResource, groups);
2172 preparedResource = serviceImportParseLogic.updateGroupsOnResource(preparedResource, groups);
2173 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToHandle);
2174 Either<Resource, ResponseFormat> updateArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE,
2175 createdArtifacts, yamlFileName, csarInfo, preparedResource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
2176 if (updateArtifactsEither.isRight()) {
2177 log.debug("failed to update artifacts {}", updateArtifactsEither.right().value());
2178 throw new ComponentException(updateArtifactsEither.right().value());
2180 preparedResource = serviceImportParseLogic.getResourceWithGroups(updateArtifactsEither.left().value().getUniqueId());
2181 ActionStatus mergingPropsAndInputsStatus = resourceDataMergeBusinessLogic.mergeResourceEntities(oldRresource, preparedResource);
2182 if (mergingPropsAndInputsStatus != ActionStatus.OK) {
2183 ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(mergingPropsAndInputsStatus, preparedResource);
2184 throw new ComponentException(responseFormat);
2186 compositionBusinessLogic.setPositionsForComponentInstances(preparedResource, csarInfo.getModifier().getUserId());
2187 return preparedResource;
2190 protected Resource createResourceFromYaml(Resource resource, String topologyTemplateYaml, String yamlName,
2191 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
2192 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
2193 boolean shouldLock, boolean inTransaction, String nodeName) {
2194 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
2195 Resource createdResource;
2197 ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic
2198 .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, resource);
2199 if (MapUtils.isEmpty(parsedToscaYamlInfo.getInstances()) && resource.getResourceType() != ResourceTypeEnum.PNF) {
2200 throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2202 log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", resource.getName());
2203 createdResource = createResourceAndRIsFromYaml(yamlName, resource, parsedToscaYamlInfo, AuditingActionEnum.IMPORT_RESOURCE, false,
2204 createdArtifacts, topologyTemplateYaml, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName);
2205 log.debug("#createResourceFromYaml - The resource {} has been created ", resource.getName());
2206 } catch (ComponentException e) {
2207 ResponseFormat responseFormat =
2208 e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
2209 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
2211 } catch (StorageException e) {
2212 ResponseFormat responseFormat = componentsUtils
2213 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
2214 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
2217 return createdResource;
2220 protected Resource createResourceAndRIsFromYaml(String yamlName, Resource resource, ParsedToscaYamlInfo parsedToscaYamlInfo,
2221 AuditingActionEnum actionEnum, boolean isNormative, List<ArtifactDefinition> createdArtifacts,
2222 String topologyTemplateYaml, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
2223 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
2224 boolean shouldLock, boolean inTransaction, String nodeName) {
2225 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2227 Either<Boolean, ResponseFormat> lockResult = serviceBusinessLogic
2228 .lockComponentByName(resource.getSystemName(), resource, CREATE_RESOURCE);
2229 if (lockResult.isRight()) {
2230 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2231 throw new ComponentException(lockResult.right().value());
2233 log.debug("name is locked {} status = {}", resource.getSystemName(), lockResult);
2236 log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
2237 Resource genericResource = serviceBusinessLogic.fetchAndSetDerivedFromGenericType(resource);
2238 resource = createResourceTransaction(resource, csarInfo.getModifier(), isNormative);
2239 log.trace("************* Going to add inputs from yaml {}", yamlName);
2240 Map<String, Object> yamlMap = ImportUtils.loadYamlAsStrictMap(csarInfo.getMainTemplateContent());
2241 Map<String, Object> metadata = (Map<String, Object>) yamlMap.get("metadata");
2242 String type = (String) metadata.get("type");
2243 if (resource.shouldGenerateInputs() && !"Service".equalsIgnoreCase(type)) {
2244 serviceBusinessLogic.generateAndAddInputsFromGenericTypeProperties(resource, genericResource);
2246 Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
2247 resource = serviceImportParseLogic.createInputsOnResource(resource, inputs);
2248 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances();
2249 resource = createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap, topologyTemplateYaml,
2250 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName);
2251 log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName);
2252 // validate update vf module group names
2253 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic.validateUpdateVfGroupNames(
2254 parsedToscaYamlInfo.getGroups(), resource.getSystemName());
2255 if (validateUpdateVfGroupNamesRes.isRight()) {
2256 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2257 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
2259 Map<String, GroupDefinition> groups;
2260 log.trace("************* Going to add groups from yaml {}", yamlName);
2261 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
2262 groups = validateUpdateVfGroupNamesRes.left().value();
2264 groups = parsedToscaYamlInfo.getGroups();
2266 Either<Resource, ResponseFormat> createGroupsOnResource = createGroupsOnResource(resource, groups);
2267 if (createGroupsOnResource.isRight()) {
2268 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2269 throw new ComponentException(createGroupsOnResource.right().value());
2271 resource = createGroupsOnResource.left().value();
2272 log.trace("************* Going to add artifacts from yaml {}", yamlName);
2273 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
2274 Either<Resource, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
2275 createdArtifacts, yamlName, csarInfo, resource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
2276 if (createArtifactsEither.isRight()) {
2277 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2278 throw new ComponentException(createArtifactsEither.right().value());
2280 resource = serviceImportParseLogic.getResourceWithGroups(createArtifactsEither.left().value().getUniqueId());
2281 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.CREATED);
2282 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, actionEnum);
2283 ASDCKpiApi.countCreatedResourcesKPI();
2285 } catch (ComponentException | StorageException e) {
2286 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2289 if (!inTransaction) {
2290 janusGraphDao.commit();
2293 graphLockOperation.unlockComponentByName(resource.getSystemName(), resource.getUniqueId(), NodeTypeEnum.Resource);
2298 protected Either<Resource, ResponseFormat> createGroupsOnResource(Resource resource, Map<String, GroupDefinition> groups) {
2299 if (groups != null && !groups.isEmpty()) {
2300 List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, resource);
2301 serviceImportParseLogic.handleGroupsProperties(resource, groups);
2302 serviceImportParseLogic.fillGroupsFinalFields(groupsAsList);
2303 Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic.createGroups(resource, groupsAsList, true);
2304 if (createGroups.isRight()) {
2305 return Either.right(createGroups.right().value());
2308 return Either.left(resource);
2310 Either<Resource, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
2311 if (updatedResource.isRight()) {
2312 ResponseFormat responseFormat = componentsUtils
2313 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), resource);
2314 return Either.right(responseFormat);
2316 return Either.left(updatedResource.left().value());
2319 protected List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups, Resource component) {
2320 List<GroupDefinition> result = new ArrayList<>();
2321 List<ComponentInstance> componentInstances = component.getComponentInstances();
2322 if (groups != null) {
2323 for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
2324 String groupName = entry.getKey();
2325 GroupDefinition groupDefinition = entry.getValue();
2326 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
2327 updatedGroupDefinition.setMembers(null);
2328 Map<String, String> members = groupDefinition.getMembers();
2329 if (members != null) {
2330 updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
2332 result.add(updatedGroupDefinition);
2338 protected void updateGroupMembers(Map<String, GroupDefinition> groups, GroupDefinition updatedGroupDefinition, Resource component,
2339 List<ComponentInstance> componentInstances, String groupName, Map<String, String> members) {
2340 Set<String> compInstancesNames = members.keySet();
2341 if (CollectionUtils.isEmpty(componentInstances)) {
2342 String membersAstString = compInstancesNames.stream().collect(joining(","));
2343 log.debug("The members: {}, in group: {}, cannot be found in component {}. There are no component instances.", membersAstString,
2344 groupName, component.getNormalizedName());
2345 throw new ComponentException(componentsUtils
2346 .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(),
2347 serviceImportParseLogic.getComponentTypeForResponse(component)));
2349 Map<String, String> memberNames = componentInstances.stream().collect(toMap(ComponentInstance::getName, ComponentInstance::getUniqueId));
2350 memberNames.putAll(groups.keySet().stream().collect(toMap(g -> g, g -> "")));
2351 Map<String, String> relevantInstances = memberNames.entrySet().stream().filter(n -> compInstancesNames.contains(n.getKey()))
2352 .collect(toMap(Map.Entry::getKey, Map.Entry::getValue));
2353 if (relevantInstances == null || relevantInstances.size() != compInstancesNames.size()) {
2354 List<String> foundMembers = new ArrayList<>();
2355 if (relevantInstances != null) {
2356 foundMembers = relevantInstances.keySet().stream().collect(toList());
2358 compInstancesNames.removeAll(foundMembers);
2359 String membersAstString = compInstancesNames.stream().collect(joining(","));
2360 throw new ComponentException(componentsUtils
2361 .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(),
2362 serviceImportParseLogic.getComponentTypeForResponse(component)));
2364 updatedGroupDefinition.setMembers(relevantInstances);
2367 protected Resource createResourceTransaction(Resource resource, User user, boolean isNormative) {
2368 Either<Boolean, StorageOperationStatus> eitherValidation = toscaOperationFacade
2369 .validateComponentNameExists(resource.getName(), resource.getResourceType(), resource.getComponentType());
2370 if (eitherValidation.isRight()) {
2371 ResponseFormat errorResponse = componentsUtils
2372 .getResponseFormat(componentsUtils.convertFromStorageResponse(eitherValidation.right().value()));
2373 throw new ComponentException(errorResponse);
2375 if (eitherValidation.left().value()) {
2376 log.debug("resource with name: {}, already exists", resource.getName());
2377 ResponseFormat errorResponse = componentsUtils
2378 .getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resource.getName());
2379 throw new ComponentException(errorResponse);
2381 log.debug("send resource {} to dao for create", resource.getName());
2382 serviceImportParseLogic.createArtifactsPlaceHolderData(resource, user);
2384 log.debug("enrich resource with creator, version and state");
2385 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2386 resource.setVersion(INITIAL_VERSION);
2387 resource.setHighestVersion(true);
2388 if (resource.getResourceType() != null && resource.getResourceType() != ResourceTypeEnum.VF) {
2389 resource.setAbstract(false);
2392 return toscaOperationFacade.createToscaComponent(resource).left()
2393 .on(r -> serviceImportParseLogic.throwComponentExceptionByResource(r, resource));
2396 protected ImmutablePair<Resource, ActionStatus> updateExistingResourceByImport(Resource newResource, Resource oldResource, User user,
2397 boolean inTransaction, boolean needLock, boolean isNested) {
2398 String lockedResourceId = oldResource.getUniqueId();
2399 log.debug("found resource: name={}, id={}, version={}, state={}", oldResource.getName(), lockedResourceId, oldResource.getVersion(),
2400 oldResource.getLifecycleState());
2401 ImmutablePair<Resource, ActionStatus> resourcePair = null;
2403 serviceBusinessLogic.lockComponent(lockedResourceId, oldResource, needLock, "Update Resource by Import");
2404 oldResource = serviceImportParseLogic.prepareResourceForUpdate(oldResource, newResource, user, inTransaction, false);
2405 serviceImportParseLogic.mergeOldResourceMetadataWithNew(oldResource, newResource);
2406 serviceImportParseLogic.validateResourceFieldsBeforeUpdate(oldResource, newResource, inTransaction, isNested);
2407 serviceImportParseLogic.validateCapabilityTypesCreate(user, serviceImportParseLogic.getCapabilityTypeOperation(), newResource,
2408 AuditingActionEnum.IMPORT_RESOURCE, inTransaction);
2409 createNewResourceToOldResource(newResource, oldResource, user);
2410 Either<Resource, StorageOperationStatus> overrideResource = toscaOperationFacade.overrideComponent(newResource, oldResource);
2411 if (overrideResource.isRight()) {
2412 ResponseFormat responseFormat = new ResponseFormat();
2413 serviceBusinessLogic.throwComponentException(responseFormat);
2415 log.debug("Resource updated successfully!!!");
2416 resourcePair = new ImmutablePair<>(overrideResource.left().value(), ActionStatus.OK);
2417 return resourcePair;
2419 if (resourcePair == null) {
2420 BeEcompErrorManager.getInstance().logBeSystemError("Change LifecycleState - Certify");
2421 janusGraphDao.rollback();
2422 } else if (!inTransaction) {
2423 janusGraphDao.commit();
2426 log.debug("unlock resource {}", lockedResourceId);
2427 graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource);
2432 protected void createNewResourceToOldResource(Resource newResource, Resource oldResource, User user) {
2433 newResource.setContactId(newResource.getContactId().toLowerCase());
2434 newResource.setCreatorUserId(user.getUserId());
2435 newResource.setCreatorFullName(user.getFullName());
2436 newResource.setLastUpdaterUserId(user.getUserId());
2437 newResource.setLastUpdaterFullName(user.getFullName());
2438 newResource.setUniqueId(oldResource.getUniqueId());
2439 newResource.setVersion(oldResource.getVersion());
2440 newResource.setInvariantUUID(oldResource.getInvariantUUID());
2441 newResource.setLifecycleState(oldResource.getLifecycleState());
2442 newResource.setUUID(oldResource.getUUID());
2443 newResource.setNormalizedName(oldResource.getNormalizedName());
2444 newResource.setSystemName(oldResource.getSystemName());
2445 if (oldResource.getCsarUUID() != null) {
2446 newResource.setCsarUUID(oldResource.getCsarUUID());
2448 if (oldResource.getCsarVersionId() != null) {
2449 newResource.setCsarVersionId(oldResource.getCsarVersionId());
2451 if (oldResource.getImportedToscaChecksum() != null) {
2452 newResource.setImportedToscaChecksum(oldResource.getImportedToscaChecksum());
2454 if (newResource.getDerivedFromGenericType() == null || newResource.getDerivedFromGenericType().isEmpty()) {
2455 newResource.setDerivedFromGenericType(oldResource.getDerivedFromGenericType());
2457 if (newResource.getDerivedFromGenericVersion() == null || newResource.getDerivedFromGenericVersion().isEmpty()) {
2458 newResource.setDerivedFromGenericVersion(oldResource.getDerivedFromGenericVersion());
2460 if (newResource.getToscaArtifacts() == null || newResource.getToscaArtifacts().isEmpty()) {
2461 serviceBusinessLogic.setToscaArtifactsPlaceHolders(newResource, user);
2463 if (newResource.getInterfaces() == null || newResource.getInterfaces().isEmpty()) {
2464 newResource.setInterfaces(oldResource.getInterfaces());
2466 if (CollectionUtils.isEmpty(newResource.getProperties())) {
2467 newResource.setProperties(oldResource.getProperties());
2469 if (newResource.getModel() == null) {
2470 newResource.setModel(oldResource.getModel());
2474 protected Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Service service, Map<String, Object> mappedToscaTemplate,
2476 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2477 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
2478 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
2480 Either<String, ImportUtils.ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
2481 TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
2482 if (toscaVersion.isRight()) {
2483 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
2485 Map<String, Object> mapToConvert = new HashMap<>();
2486 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value());
2487 Map<String, Object> nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate);
2488 createNodeTypes(yamlName, service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
2489 mapToConvert, nodeTypes);
2490 return csarInfo.getCreatedNodes();
2491 } catch (Exception e) {
2492 log.debug("Exception occured when createResourcesFromYamlNodeTypesList,error is:{}", e.getMessage(), e);
2493 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2497 protected void createNodeTypes(String yamlName, Service service, boolean needLock,
2498 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2499 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
2500 Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
2501 Iterator<Map.Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet().iterator();
2502 Resource vfcCreated = null;
2503 while (nodesNameValueIter.hasNext()) {
2504 Map.Entry<String, Object> nodeType = nodesNameValueIter.next();
2505 String nodeTypeKey = nodeType.getKey();
2506 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle =
2507 nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeTypeKey);
2508 if (nodeTypesInfo.containsKey(nodeTypeKey)) {
2509 vfcCreated = handleNestedVfc(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
2511 log.trace("************* Finished to handle nested vfc {}", nodeTypeKey);
2512 } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames()
2513 .containsKey(nodeTypeKey)) {
2514 ImmutablePair<Resource, ActionStatus> resourceCreated = serviceImportParseLogic
2515 .createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(), mapToConvert, service, needLock,
2516 nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true);
2517 log.debug("************* Finished to create node {}", nodeTypeKey);
2518 vfcCreated = resourceCreated.getLeft();
2519 csarInfo.getCreatedNodesToscaResourceNames().put(nodeTypeKey, vfcCreated.getName());
2521 if (vfcCreated != null) {
2522 csarInfo.getCreatedNodes().put(nodeTypeKey, vfcCreated);
2524 mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());