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 com.google.gson.Gson;
27 import fj.data.Either;
28 import java.util.ArrayList;
29 import java.util.Collection;
30 import java.util.EnumMap;
31 import java.util.HashMap;
32 import java.util.HashSet;
33 import java.util.Iterator;
34 import java.util.List;
36 import java.util.Map.Entry;
37 import java.util.Optional;
39 import java.util.regex.Pattern;
40 import java.util.stream.Collectors;
41 import java.util.stream.Stream;
44 import org.apache.commons.collections.CollectionUtils;
45 import org.apache.commons.collections.MapUtils;
46 import org.apache.commons.lang3.StringUtils;
47 import org.apache.commons.lang3.tuple.ImmutablePair;
48 import org.openecomp.sdc.be.components.csar.CsarArtifactsAndGroupsBusinessLogic;
49 import org.openecomp.sdc.be.components.csar.CsarBusinessLogic;
50 import org.openecomp.sdc.be.components.csar.CsarInfo;
51 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
52 import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
53 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
54 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
55 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
56 import org.openecomp.sdc.be.components.impl.utils.CINodeFilterUtils;
57 import org.openecomp.sdc.be.components.impl.utils.CreateServiceFromYamlParameter;
58 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
59 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
60 import org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic;
61 import org.openecomp.sdc.be.config.BeEcompErrorManager;
62 import org.openecomp.sdc.be.config.ConfigurationManager;
63 import org.openecomp.sdc.be.dao.api.ActionStatus;
64 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
65 import org.openecomp.sdc.be.datamodel.utils.ArtifactUtils;
66 import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter;
67 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
68 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
69 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
70 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
71 import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition;
72 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
73 import org.openecomp.sdc.be.datatypes.elements.RequirementSubstitutionFilterPropertyDataDefinition;
74 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
75 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
76 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
77 import org.openecomp.sdc.be.impl.ComponentsUtils;
78 import org.openecomp.sdc.be.info.NodeTypeInfoToUpdateArtifacts;
79 import org.openecomp.sdc.be.model.ArtifactDefinition;
80 import org.openecomp.sdc.be.model.AttributeDefinition;
81 import org.openecomp.sdc.be.model.CapabilityDefinition;
82 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
83 import org.openecomp.sdc.be.model.Component;
84 import org.openecomp.sdc.be.model.ComponentInstance;
85 import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
86 import org.openecomp.sdc.be.model.ComponentInstanceInput;
87 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
88 import org.openecomp.sdc.be.model.ComponentParametersView;
89 import org.openecomp.sdc.be.model.DataTypeDefinition;
90 import org.openecomp.sdc.be.model.DistributionStatusEnum;
91 import org.openecomp.sdc.be.model.GroupDefinition;
92 import org.openecomp.sdc.be.model.InputDefinition;
93 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
94 import org.openecomp.sdc.be.model.LifecycleStateEnum;
95 import org.openecomp.sdc.be.model.NodeTypeInfo;
96 import org.openecomp.sdc.be.model.Operation;
97 import org.openecomp.sdc.be.model.OutputDefinition;
98 import org.openecomp.sdc.be.model.ParsedToscaYamlInfo;
99 import org.openecomp.sdc.be.model.PolicyDefinition;
100 import org.openecomp.sdc.be.model.PropertyDefinition;
101 import org.openecomp.sdc.be.model.RelationshipImpl;
102 import org.openecomp.sdc.be.model.RelationshipInfo;
103 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
104 import org.openecomp.sdc.be.model.RequirementDefinition;
105 import org.openecomp.sdc.be.model.Resource;
106 import org.openecomp.sdc.be.model.Service;
107 import org.openecomp.sdc.be.model.UploadAttributeInfo;
108 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
109 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
110 import org.openecomp.sdc.be.model.UploadPropInfo;
111 import org.openecomp.sdc.be.model.UploadReqInfo;
112 import org.openecomp.sdc.be.model.UploadResourceInfo;
113 import org.openecomp.sdc.be.model.User;
114 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
115 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
116 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
117 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
118 import org.openecomp.sdc.be.model.operations.StorageException;
119 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
120 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
121 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
122 import org.openecomp.sdc.be.tosca.CsarUtils;
123 import org.openecomp.sdc.be.ui.model.OperationUi;
124 import org.openecomp.sdc.be.utils.TypeUtils;
125 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
126 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
127 import org.openecomp.sdc.common.api.Constants;
128 import org.openecomp.sdc.common.datastructure.Wrapper;
129 import org.openecomp.sdc.common.kpi.api.ASDCKpiApi;
130 import org.openecomp.sdc.common.log.wrappers.Logger;
131 import org.openecomp.sdc.common.util.ValidationUtils;
132 import org.openecomp.sdc.exception.ResponseFormat;
133 import org.yaml.snakeyaml.Yaml;
137 @org.springframework.stereotype.Component("serviceImportBusinessLogic")
138 public class ServiceImportBusinessLogic {
140 protected static final String CREATE_RESOURCE = "Create Resource";
141 private static final String INITIAL_VERSION = "0.1";
142 private static final String IN_RESOURCE = " in resource {} ";
143 private static final String COMPONENT_INSTANCE_WITH_NAME = "component instance with name ";
144 private static final String COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE = "component instance with name {} in resource {} ";
145 private static final String CERTIFICATION_ON_IMPORT = "certification on import";
146 private static final String VALIDATE_DERIVED_BEFORE_UPDATE = "validate derived before update";
147 private static final String PLACE_HOLDER_RESOURCE_TYPES = "validForResourceTypes";
148 private static final String CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES = "Create Resource - validateCapabilityTypesCreate";
149 private static final String CATEGORY_IS_EMPTY = "Resource category is empty";
150 private static final Logger log = Logger.getLogger(ServiceImportBusinessLogic.class);
152 private final ComponentsUtils componentsUtils;
153 private final ToscaOperationFacade toscaOperationFacade;
154 private final UiComponentDataConverter uiComponentDataConverter;
155 private final ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
156 private final ServiceBusinessLogic serviceBusinessLogic;
157 private final CsarBusinessLogic csarBusinessLogic;
158 private final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic;
159 private final LifecycleBusinessLogic lifecycleBusinessLogic;
160 private final CompositionBusinessLogic compositionBusinessLogic;
161 private final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic;
162 private final ServiceImportParseLogic serviceImportParseLogic;
163 private final ComponentNodeFilterBusinessLogic componentNodeFilterBusinessLogic;
164 private final GroupBusinessLogic groupBusinessLogic;
165 private final PolicyBusinessLogic policyBusinessLogic;
166 private final JanusGraphDao janusGraphDao;
167 private final ArtifactsBusinessLogic artifactsBusinessLogic;
168 private final IGraphLockOperation graphLockOperation;
169 private final ToscaFunctionService toscaFunctionService;
171 public ServiceImportBusinessLogic(final GroupBusinessLogic groupBusinessLogic,
172 final ArtifactsBusinessLogic artifactsBusinessLogic,
173 final ComponentInstanceBusinessLogic componentInstanceBusinessLogic,
174 final UiComponentDataConverter uiComponentDataConverter, final ComponentsUtils componentsUtils,
175 final ToscaOperationFacade toscaOperationFacade, final ServiceBusinessLogic serviceBusinessLogic,
176 final CsarBusinessLogic csarBusinessLogic,
177 final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic,
178 final LifecycleBusinessLogic lifecycleBusinessLogic, final CompositionBusinessLogic compositionBusinessLogic,
179 final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic,
180 final ServiceImportParseLogic serviceImportParseLogic,
181 final ComponentNodeFilterBusinessLogic componentNodeFilterBusinessLogic,
182 final PolicyBusinessLogic policyBusinessLogic, final JanusGraphDao janusGraphDao,
183 final IGraphLockOperation graphLockOperation, final ToscaFunctionService toscaFunctionService) {
184 this.componentInstanceBusinessLogic = componentInstanceBusinessLogic;
185 this.uiComponentDataConverter = uiComponentDataConverter;
186 this.componentsUtils = componentsUtils;
187 this.toscaOperationFacade = toscaOperationFacade;
188 this.serviceBusinessLogic = serviceBusinessLogic;
189 this.csarBusinessLogic = csarBusinessLogic;
190 this.csarArtifactsAndGroupsBusinessLogic = csarArtifactsAndGroupsBusinessLogic;
191 this.lifecycleBusinessLogic = lifecycleBusinessLogic;
192 this.compositionBusinessLogic = compositionBusinessLogic;
193 this.resourceDataMergeBusinessLogic = resourceDataMergeBusinessLogic;
194 this.serviceImportParseLogic = serviceImportParseLogic;
195 this.componentNodeFilterBusinessLogic = componentNodeFilterBusinessLogic;
196 this.groupBusinessLogic = groupBusinessLogic;
197 this.policyBusinessLogic = policyBusinessLogic;
198 this.janusGraphDao = janusGraphDao;
199 this.artifactsBusinessLogic = artifactsBusinessLogic;
200 this.graphLockOperation = graphLockOperation;
201 this.toscaFunctionService = toscaFunctionService;
204 public Service createService(Service service, AuditingActionEnum auditingAction, User user, Map<String, byte[]> csarUIPayload,
205 String payloadName) {
206 log.debug("enter createService");
207 service.setCreatorUserId(user.getUserId());
208 service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
209 service.setVersion(INITIAL_VERSION);
210 service.setConformanceLevel(ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel());
211 service.setDistributionStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
213 final var serviceBeforeCreate = serviceBusinessLogic.validateServiceBeforeCreate(service, user, auditingAction);
214 if (serviceBeforeCreate.isRight()) {
215 throw new ComponentException(ActionStatus.GENERAL_ERROR);
217 log.debug("enter createService,validateServiceBeforeCreate success");
218 String csarUUID = payloadName == null ? service.getCsarUUID() : payloadName;
219 log.debug("enter createService,get csarUUID:{}", csarUUID);
220 csarBusinessLogic.validateCsarBeforeCreate(service, csarUUID);
221 log.debug("CsarUUID is {} - going to create resource from CSAR", csarUUID);
222 return createServiceFromCsar(service, user, csarUIPayload, csarUUID);
223 } catch (final ComponentException e) {
224 log.debug("Exception occurred when createService: {}", e.getMessage(), e);
226 } catch (final Exception e) {
227 log.debug("Exception occurred when createService: {}", e.getMessage(), e);
228 throw new ComponentException(ActionStatus.GENERAL_ERROR);
232 protected Service createServiceFromCsar(Service service, User user, Map<String, byte[]> csarUIPayload, String csarUUID) {
233 log.trace("************* created successfully from YAML, resource TOSCA ");
235 CsarInfo csarInfo = csarBusinessLogic.getCsarInfo(service, null, user, csarUIPayload, csarUUID);
236 Map<String, NodeTypeInfo> nodeTypesInfo = csarInfo.extractTypesInfo();
237 Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandleRes = serviceImportParseLogic
238 .findNodeTypesArtifactsToHandle(nodeTypesInfo, csarInfo, service);
239 if (findNodeTypesArtifactsToHandleRes.isRight()) {
240 log.debug("failed to find node types for update with artifacts during import csar {}. ", csarInfo.getCsarUUID());
241 throw new ComponentException(findNodeTypesArtifactsToHandleRes.right().value());
243 return createServiceFromYaml(service, csarInfo.getMainTemplateContent(), csarInfo.getMainTemplateName(), nodeTypesInfo, csarInfo,
244 findNodeTypesArtifactsToHandleRes.left().value(), true, false, null, user.getUserId());
245 } catch (final ComponentException e) {
246 log.debug("Exception occurred when createServiceFromCsar,error is:{}", e.getMessage(), e);
248 } catch (final Exception e) {
249 log.debug("Exception occurred when createServiceFromCsar,error is:{}", e.getMessage(), e);
250 throw new ComponentException(ActionStatus.GENERAL_ERROR);
254 protected Service createServiceFromYaml(Service service, String topologyTemplateYaml, String yamlName, Map<String, NodeTypeInfo> nodeTypesInfo,
256 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
257 boolean shouldLock, boolean inTransaction, String nodeName, final String userId)
258 throws BusinessLogicException {
259 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
260 Service createdService;
261 CreateServiceFromYamlParameter csfyp = new CreateServiceFromYamlParameter();
263 ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic
264 .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, service);
265 log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", service.getName());
266 csfyp.setYamlName(yamlName);
267 csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
268 csfyp.setCreatedArtifacts(createdArtifacts);
269 csfyp.setTopologyTemplateYaml(topologyTemplateYaml);
270 csfyp.setNodeTypesInfo(nodeTypesInfo);
271 csfyp.setCsarInfo(csarInfo);
272 csfyp.setNodeName(nodeName);
273 createdService = createServiceAndRIsFromYaml(service, false, nodeTypesArtifactsToCreate, shouldLock, inTransaction, csfyp, userId);
274 log.debug("#createResourceFromYaml - The resource {} has been created ", service.getName());
275 } catch (ComponentException | BusinessLogicException e) {
276 log.debug("Create Service from yaml failed", e);
278 } catch (StorageException e) {
279 log.debug("create Service From Yaml failed,get StorageException:{}", e);
282 return createdService;
285 protected Service createServiceAndRIsFromYaml(Service service, boolean isNormative,
286 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
287 boolean shouldLock, boolean inTransaction, CreateServiceFromYamlParameter csfyp,
289 throws BusinessLogicException {
290 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
291 String yamlName = csfyp.getYamlName();
292 ParsedToscaYamlInfo parsedToscaYamlInfo = csfyp.getParsedToscaYamlInfo();
293 List<ArtifactDefinition> createdArtifacts = csfyp.getCreatedArtifacts();
294 String topologyTemplateYaml = csfyp.getTopologyTemplateYaml();
295 Map<String, NodeTypeInfo> nodeTypesInfo = csfyp.getNodeTypesInfo();
296 CsarInfo csarInfo = csfyp.getCsarInfo();
297 String nodeName = csfyp.getNodeName();
299 Either<Boolean, ResponseFormat> lockResult = serviceBusinessLogic.lockComponentByName(service.getSystemName(), service, CREATE_RESOURCE);
300 if (lockResult.isRight()) {
301 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
302 throw new ComponentException(lockResult.right().value());
304 log.debug("name is locked {} status = {}", service.getSystemName(), lockResult);
307 log.trace("************* Adding properties to service from interface yaml {}", yamlName);
308 Map<String, PropertyDefinition> properties = parsedToscaYamlInfo.getProperties();
309 if (properties != null && !properties.isEmpty()) {
310 final List<PropertyDefinition> propertiesList = new ArrayList<>();
311 properties.forEach((propertyName, propertyDefinition) -> {
312 propertyDefinition.setName(propertyName);
313 propertiesList.add(propertyDefinition);
315 service.setProperties(propertiesList);
317 log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
318 service = serviceImportParseLogic.createServiceTransaction(service, csarInfo.getModifier(), isNormative);
319 log.trace("************* Going to add inputs from yaml {}", yamlName);
320 Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
321 service = serviceImportParseLogic.createInputsOnService(service, inputs);
322 log.trace("************* Finished to add inputs from yaml {}", yamlName);
323 ListDataDefinition<RequirementSubstitutionFilterPropertyDataDefinition> substitutionFilterProperties = parsedToscaYamlInfo.getSubstitutionFilterProperties();
324 service = serviceImportParseLogic.createSubstitutionFilterOnService(service, substitutionFilterProperties);
325 log.trace("************* Added Substitution filter from interface yaml {}", yamlName);
326 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances();
327 log.trace("************* Going to create nodes, RI's and Relations from yaml {}", yamlName);
328 service = createRIAndRelationsFromYaml(yamlName, service, uploadComponentInstanceInfoMap, topologyTemplateYaml,
329 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName);
330 log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName);
331 log.trace("************* Going to add outputs from yaml {}", yamlName);
332 Map<String, OutputDefinition> outputs = parsedToscaYamlInfo.getOutputs();
333 service = serviceImportParseLogic.createOutputsOnService(service, outputs, userId);
334 log.trace("************* Finished to add outputs from yaml {}", yamlName);
336 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes
337 = groupBusinessLogic.validateUpdateVfGroupNames(parsedToscaYamlInfo.getGroups(), service.getSystemName());
338 if (validateUpdateVfGroupNamesRes.isRight()) {
339 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
340 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
342 Map<String, GroupDefinition> groups;
343 log.trace("************* Going to add groups from yaml {}", yamlName);
344 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
345 groups = validateUpdateVfGroupNamesRes.left().value();
347 groups = parsedToscaYamlInfo.getGroups();
349 Either<Service, ResponseFormat> createGroupsOnResource = createGroupsOnResource(service, groups);
350 if (createGroupsOnResource.isRight()) {
351 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
352 throw new ComponentException(createGroupsOnResource.right().value());
354 service = createGroupsOnResource.left().value();
356 Either<Service, ResponseFormat> createPoliciesOnResource = createPoliciesOnResource(service, parsedToscaYamlInfo.getPolicies());
357 if (createPoliciesOnResource.isRight()) {
358 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
359 throw new ComponentException(createPoliciesOnResource.right().value());
361 service = createPoliciesOnResource.left().value();
362 log.trace("************* Going to add artifacts from yaml {}", yamlName);
363 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
364 Either<Service, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
365 createdArtifacts, yamlName, csarInfo, service, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
366 if (createArtifactsEither.isRight()) {
367 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
368 throw new ComponentException(createArtifactsEither.right().value());
370 service = serviceImportParseLogic.getServiceWithGroups(createArtifactsEither.left().value().getUniqueId());
371 ASDCKpiApi.countCreatedResourcesKPI();
373 } catch (ComponentException | StorageException | BusinessLogicException e) {
374 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
377 if (!inTransaction) {
378 janusGraphDao.commit();
381 graphLockOperation.unlockComponentByName(service.getSystemName(), service.getUniqueId(), NodeTypeEnum.Resource);
386 protected Either<Resource, ResponseFormat> createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum operation,
387 List<ArtifactDefinition> createdArtifacts, String yamlFileName,
388 CsarInfo csarInfo, Resource preparedResource,
389 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
390 boolean inTransaction, boolean shouldLock) {
391 String nodeName = nodeTypeInfoToUpdateArtifacts.getNodeName();
392 Resource resource = preparedResource;
393 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = nodeTypeInfoToUpdateArtifacts
394 .getNodeTypesArtifactsToHandle();
395 if (preparedResource.getResourceType() == ResourceTypeEnum.VF) {
396 if (nodeName != null && nodeTypesArtifactsToHandle.get(nodeName) != null && !nodeTypesArtifactsToHandle.get(nodeName).isEmpty()) {
397 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = handleNodeTypeArtifacts(preparedResource,
398 nodeTypesArtifactsToHandle.get(nodeName), createdArtifacts, csarInfo.getModifier(), inTransaction, true);
399 if (handleNodeTypeArtifactsRes.isRight()) {
400 return Either.right(handleNodeTypeArtifactsRes.right().value());
404 Either<Resource, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedResource, csarInfo, createdArtifacts,
405 new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction);
406 log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
407 if (createdCsarArtifactsEither.isRight()) {
408 return createdCsarArtifactsEither;
410 resource = createdCsarArtifactsEither.left().value();
412 return Either.left(resource);
415 protected Either<Resource, ResponseFormat> handleVfCsarArtifacts(Resource resource, CsarInfo csarInfo, List<ArtifactDefinition> createdArtifacts,
416 ArtifactOperationInfo artifactOperation, boolean shouldLock,
417 boolean inTransaction) {
418 if (csarInfo.getCsar() != null) {
419 createOrUpdateSingleNonMetaArtifactToComstants(resource, csarInfo, artifactOperation, shouldLock, inTransaction);
420 Either<Resource, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, resource, createdArtifacts, shouldLock,
421 inTransaction, artifactOperation);
422 if (eitherCreateResult.isRight()) {
423 return Either.right(eitherCreateResult.right().value());
425 Either<Resource, StorageOperationStatus> eitherGerResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
426 if (eitherGerResource.isRight()) {
427 ResponseFormat responseFormat = componentsUtils
428 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), resource);
429 return Either.right(responseFormat);
431 resource = eitherGerResource.left().value();
432 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
433 .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
434 if (artifacsMetaCsarStatus.isLeft()) {
435 return getResourceResponseFormatEither(resource, csarInfo, createdArtifacts, artifactOperation, shouldLock, inTransaction,
436 artifacsMetaCsarStatus);
438 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(resource, csarInfo, shouldLock, inTransaction);
441 return Either.left(resource);
444 protected void createOrUpdateSingleNonMetaArtifactToComstants(Resource resource, CsarInfo csarInfo, ArtifactOperationInfo artifactOperation,
445 boolean shouldLock, boolean inTransaction) {
446 String vendorLicenseModelId = null;
447 String vfLicenseModelId = null;
448 if (artifactOperation.getArtifactOperationEnum() == ArtifactOperationEnum.UPDATE) {
449 Map<String, ArtifactDefinition> deploymentArtifactsMap = resource.getDeploymentArtifacts();
450 if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
451 for (Map.Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
452 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
453 vendorLicenseModelId = artifactEntry.getValue().getUniqueId();
455 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
456 vfLicenseModelId = artifactEntry.getValue().getUniqueId();
461 createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL,
462 Constants.VENDOR_LICENSE_MODEL, ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
463 Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME, Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId,
464 artifactOperation, null, true, shouldLock, inTransaction);
465 createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
466 ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL, Constants.VF_LICENSE_DISPLAY_NAME,
467 Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId, artifactOperation, null, true, shouldLock, inTransaction);
470 private Either<Resource, ResponseFormat> getResourceResponseFormatEither(Resource resource, CsarInfo csarInfo,
471 List<ArtifactDefinition> createdArtifacts,
472 ArtifactOperationInfo artifactOperation, boolean shouldLock,
473 boolean inTransaction,
474 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus) {
476 String artifactsFileName = artifacsMetaCsarStatus.left().value().getKey();
477 String artifactsContents = artifacsMetaCsarStatus.left().value().getValue();
478 Either<Resource, ResponseFormat> createArtifactsFromCsar;
479 if (ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
480 createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic
481 .createResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts);
483 Either<Component, ResponseFormat> result = csarArtifactsAndGroupsBusinessLogic
484 .updateResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
486 if ((result.left().value() instanceof Resource) && result.isLeft()) {
487 Resource service1 = (Resource) result.left().value();
488 createArtifactsFromCsar = Either.left(service1);
490 createArtifactsFromCsar = Either.right(result.right().value());
493 if (createArtifactsFromCsar.isRight()) {
494 log.debug("Couldn't create artifacts from artifacts.meta");
495 return Either.right(createArtifactsFromCsar.right().value());
497 return Either.left(createArtifactsFromCsar.left().value());
498 } catch (Exception e) {
499 log.debug("Exception occured in getResourceResponseFormatEither, message:{}", e.getMessage(), e);
500 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
504 private <T extends Component> Either<T, ResponseFormat> createOrUpdateNonMetaArtifactsComp(CsarInfo csarInfo, T component,
505 List<ArtifactDefinition> createdArtifacts,
506 boolean shouldLock, boolean inTransaction,
507 ArtifactOperationInfo artifactOperation) {
508 Either<T, ResponseFormat> resStatus = null;
509 Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
511 Either<List<CsarUtils.NonMetaArtifactInfo>, String> artifactPathAndNameList = getValidArtifactNames(csarInfo, collectedWarningMessages);
512 if (artifactPathAndNameList.isRight()) {
514 getComponentsUtils().getResponseFormatByArtifactId(ActionStatus.ARTIFACT_NAME_INVALID, artifactPathAndNameList.right().value()));
516 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = null;
517 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
518 vfCsarArtifactsToHandle = new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
519 vfCsarArtifactsToHandle.put(artifactOperation.getArtifactOperationEnum(), artifactPathAndNameList.left().value());
521 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandleRes = findVfCsarArtifactsToHandle(
522 component, artifactPathAndNameList.left().value(), csarInfo.getModifier());
523 if (findVfCsarArtifactsToHandleRes.isRight()) {
524 resStatus = Either.right(findVfCsarArtifactsToHandleRes.right().value());
526 if (resStatus == null) {
527 vfCsarArtifactsToHandle = findVfCsarArtifactsToHandleRes.left().value();
530 if (resStatus == null && vfCsarArtifactsToHandle != null) {
531 resStatus = processCsarArtifacts(csarInfo, component, createdArtifacts, shouldLock, inTransaction, resStatus,
532 vfCsarArtifactsToHandle);
534 if (resStatus == null) {
535 resStatus = Either.left(component);
537 } catch (Exception e) {
538 resStatus = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
539 log.debug("Exception occured in createNonMetaArtifacts, message:{}", e.getMessage(), e);
541 CsarUtils.handleWarningMessages(collectedWarningMessages);
546 protected Either<Resource, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Resource resource,
547 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
548 boolean inTransaction, ArtifactOperationInfo artifactOperation) {
549 return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation);
552 protected <T extends Component> Either<T, ResponseFormat> processCsarArtifacts(CsarInfo csarInfo, Component comp,
553 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
554 boolean inTransaction, Either<T, ResponseFormat> resStatus,
555 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle) {
556 for (Map.Entry<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> currArtifactOperationPair : vfCsarArtifactsToHandle
558 Optional<ResponseFormat> optionalCreateInDBError = currArtifactOperationPair.getValue().stream().map(
559 e -> createOrUpdateSingleNonMetaArtifact(comp, csarInfo, e.getPath(), e.getArtifactName(), e.getArtifactType(),
560 e.getArtifactGroupType(), e.getArtifactLabel(), e.getDisplayName(), CsarUtils.ARTIFACT_CREATED_FROM_CSAR, e.getArtifactUniqueId(),
561 new ArtifactOperationInfo(false, false, currArtifactOperationPair.getKey()), createdArtifacts, e.isFromCsar(), shouldLock,
562 inTransaction)).filter(Either::isRight).map(e -> e.right().value()).findAny();
563 if (optionalCreateInDBError.isPresent()) {
564 resStatus = Either.right(optionalCreateInDBError.get());
571 protected Either<Boolean, ResponseFormat> createOrUpdateSingleNonMetaArtifact(Component component, CsarInfo csarInfo, String artifactPath,
572 String artifactFileName, String artifactType,
573 ArtifactGroupTypeEnum artifactGroupType, String artifactLabel,
574 String artifactDisplayName, String artifactDescription,
575 String artifactId, ArtifactOperationInfo operation,
576 List<ArtifactDefinition> createdArtifacts, boolean isFromCsar,
577 boolean shouldLock, boolean inTransaction) {
578 byte[] artifactFileBytes = null;
579 if (csarInfo.getCsar().containsKey(artifactPath)) {
580 artifactFileBytes = csarInfo.getCsar().get(artifactPath);
582 Either<Boolean, ResponseFormat> result = Either.left(true);
583 if (operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE
584 || operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE) {
585 if (serviceImportParseLogic.isArtifactDeletionRequired(artifactId, artifactFileBytes, isFromCsar)) {
586 Either<ArtifactDefinition, ResponseFormat> handleDelete = artifactsBusinessLogic
587 .handleDelete(component.getUniqueId(), artifactId, csarInfo.getModifier(), component, shouldLock, inTransaction);
588 if (handleDelete.isRight()) {
589 result = Either.right(handleDelete.right().value());
593 if (org.apache.commons.lang.StringUtils.isEmpty(artifactId) && artifactFileBytes != null) {
594 operation = new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
597 if (artifactFileBytes != null) {
598 Map<String, Object> vendorLicenseModelJson = ArtifactUtils
599 .buildJsonForUpdateArtifact(artifactId, artifactFileName, artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
600 artifactDescription, artifactFileBytes, null, isFromCsar);
601 Either<Either<ArtifactDefinition, Operation>, ResponseFormat> eitherNonMetaArtifacts = csarArtifactsAndGroupsBusinessLogic
602 .createOrUpdateCsarArtifactFromJson(component, csarInfo.getModifier(), vendorLicenseModelJson, operation);
603 serviceImportParseLogic.addNonMetaCreatedArtifactsToSupportRollback(operation, createdArtifacts, eitherNonMetaArtifacts);
604 if (eitherNonMetaArtifacts.isRight()) {
605 BeEcompErrorManager.getInstance().logInternalFlowError("UploadLicenseArtifact",
606 "Failed to upload license artifact: " + artifactFileName + "With csar uuid: " + csarInfo.getCsarUUID(),
607 BeEcompErrorManager.ErrorSeverity.WARNING);
608 return Either.right(eitherNonMetaArtifacts.right().value());
614 private Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifacts(Resource nodeTypeResource,
615 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
616 List<ArtifactDefinition> createdArtifacts, User user,
617 boolean inTransaction, boolean ignoreLifecycleState) {
618 List<ArtifactDefinition> handleNodeTypeArtifactsRequestRes;
619 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = null;
620 Either<Resource, ResponseFormat> changeStateResponse;
622 changeStateResponse = checkoutResource(nodeTypeResource, user, inTransaction);
623 if (changeStateResponse.isRight()) {
624 return Either.right(changeStateResponse.right().value());
626 nodeTypeResource = changeStateResponse.left().value();
627 List<ArtifactDefinition> handledNodeTypeArtifacts = new ArrayList<>();
628 log.debug("************* Going to handle artifacts of node type resource {}. ", nodeTypeResource.getName());
629 for (Map.Entry<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> curOperationEntry : nodeTypeArtifactsToHandle
631 ArtifactsBusinessLogic.ArtifactOperationEnum curOperation = curOperationEntry.getKey();
632 List<ArtifactDefinition> curArtifactsToHandle = curOperationEntry.getValue();
633 if (curArtifactsToHandle != null && !curArtifactsToHandle.isEmpty()) {
634 log.debug("************* Going to {} artifact to vfc {}", curOperation.name(), nodeTypeResource.getName());
635 handleNodeTypeArtifactsRequestRes = artifactsBusinessLogic
636 .handleArtifactsRequestForInnerVfcComponent(curArtifactsToHandle, nodeTypeResource, user, createdArtifacts,
637 new ArtifactOperationInfo(false, ignoreLifecycleState, curOperation), false, inTransaction);
638 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(curOperation)) {
639 createdArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
641 handledNodeTypeArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
644 if (handleNodeTypeArtifactsRes == null) {
645 handleNodeTypeArtifactsRes = Either.left(handledNodeTypeArtifacts);
647 } catch (Exception e) {
648 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
649 handleNodeTypeArtifactsRes = Either.right(responseFormat);
650 log.debug("Exception occured when handleVfcArtifacts, error is:{}", e.getMessage(), e);
652 return handleNodeTypeArtifactsRes;
655 private Either<Resource, ResponseFormat> checkoutResource(Resource resource, User user, boolean inTransaction) {
656 Either<Resource, ResponseFormat> checkoutResourceRes;
658 if (!resource.getComponentMetadataDefinition().getMetadataDataDefinition().getState()
659 .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
660 Either<? extends Component, ResponseFormat> checkoutRes = lifecycleBusinessLogic
661 .changeComponentState(resource.getComponentType(), resource.getUniqueId(), user, LifeCycleTransitionEnum.CHECKOUT,
662 new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
663 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR), inTransaction, true);
664 if (checkoutRes.isRight()) {
665 checkoutResourceRes = Either.right(checkoutRes.right().value());
667 checkoutResourceRes = Either.left((Resource) checkoutRes.left().value());
670 checkoutResourceRes = Either.left(resource);
672 } catch (Exception e) {
673 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
674 checkoutResourceRes = Either.right(responseFormat);
675 log.debug("Exception occured when checkoutResource {} , error is:{}", resource.getName(), e.getMessage(), e);
677 return checkoutResourceRes;
680 protected Either<Service, ResponseFormat> createOrUpdateArtifacts(ArtifactOperationEnum operation, List<ArtifactDefinition> createdArtifacts,
681 String yamlFileName, CsarInfo csarInfo, Service preparedService,
682 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
683 boolean inTransaction, boolean shouldLock) {
684 Either<Service, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedService, csarInfo, createdArtifacts,
685 new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction);
686 log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
687 if (createdCsarArtifactsEither.isRight()) {
688 return createdCsarArtifactsEither;
690 return Either.left(createdCsarArtifactsEither.left().value());
693 protected Either<Service, ResponseFormat> handleVfCsarArtifacts(Service service, CsarInfo csarInfo, List<ArtifactDefinition> createdArtifacts,
694 ArtifactOperationInfo artifactOperation, boolean shouldLock,
695 boolean inTransaction) {
696 if (csarInfo.getCsar() != null) {
697 String vendorLicenseModelId = null;
698 String vfLicenseModelId = null;
699 if (artifactOperation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE) {
700 Map<String, ArtifactDefinition> deploymentArtifactsMap = service.getDeploymentArtifacts();
701 if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
702 for (Map.Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
703 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
704 vendorLicenseModelId = artifactEntry.getValue().getUniqueId();
706 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
707 vfLicenseModelId = artifactEntry.getValue().getUniqueId();
712 createOrUpdateSingleNonMetaArtifact(service, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL,
713 Constants.VENDOR_LICENSE_MODEL, ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
714 Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME, Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId,
715 artifactOperation, null, true, shouldLock, inTransaction);
716 createOrUpdateSingleNonMetaArtifact(service, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
717 ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL,
718 Constants.VF_LICENSE_DISPLAY_NAME, Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId, artifactOperation, null, true, shouldLock,
720 Either<Service, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, service, createdArtifacts, shouldLock,
721 inTransaction, artifactOperation);
722 if (eitherCreateResult.isRight()) {
723 return Either.right(eitherCreateResult.right().value());
725 Either<Service, StorageOperationStatus> eitherGerResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
726 if (eitherGerResource.isRight()) {
727 ResponseFormat responseFormat = componentsUtils
728 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), service,
729 ComponentTypeEnum.SERVICE);
730 return Either.right(responseFormat);
732 service = eitherGerResource.left().value();
733 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
734 .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
735 if (artifacsMetaCsarStatus.isLeft()) {
736 String artifactsFileName = artifacsMetaCsarStatus.left().value().getKey();
737 String artifactsContents = artifacsMetaCsarStatus.left().value().getValue();
738 Either<Service, ResponseFormat> createArtifactsFromCsar;
739 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
740 createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic
741 .createResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts);
743 Either<Component, ResponseFormat> result = csarArtifactsAndGroupsBusinessLogic
744 .updateResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
746 if ((result.left().value() instanceof Service) && result.isLeft()) {
747 Service service1 = (Service) result.left().value();
748 createArtifactsFromCsar = Either.left(service1);
750 createArtifactsFromCsar = Either.right(result.right().value());
753 if (createArtifactsFromCsar.isRight()) {
754 log.debug("Couldn't create artifacts from artifacts.meta");
755 return Either.right(createArtifactsFromCsar.right().value());
757 return Either.left(createArtifactsFromCsar.left().value());
759 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(service, csarInfo, shouldLock, inTransaction);
762 return Either.left(service);
765 protected Either<Service, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Service resource,
766 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
767 boolean inTransaction, ArtifactOperationInfo artifactOperation) {
768 return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation);
771 protected Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandle(
772 Component component, List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList, User user) {
773 List<ArtifactDefinition> existingArtifacts = new ArrayList<>();
774 if (component.getDeploymentArtifacts() != null && !component.getDeploymentArtifacts().isEmpty()) {
775 existingArtifacts.addAll(component.getDeploymentArtifacts().values());
777 if (component.getArtifacts() != null && !component.getArtifacts().isEmpty()) {
778 existingArtifacts.addAll(component.getArtifacts().values());
780 existingArtifacts = existingArtifacts.stream().filter(this::isNonMetaArtifact).collect(toList());
781 List<String> artifactsToIgnore = new ArrayList<>();
782 if (component.getGroups() != null) {
783 component.getGroups().forEach(g -> {
784 if (g.getArtifacts() != null && !g.getArtifacts().isEmpty()) {
785 artifactsToIgnore.addAll(g.getArtifacts());
789 existingArtifacts = existingArtifacts.stream().filter(a -> !artifactsToIgnore.contains(a.getUniqueId())).collect(toList());
790 return organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifacts, component, user);
793 private boolean isNonMetaArtifact(ArtifactDefinition artifact) {
794 boolean result = true;
795 if (artifact.getMandatory() || artifact.getArtifactName() == null || !isValidArtifactType(artifact)) {
801 private boolean isValidArtifactType(ArtifactDefinition artifact) {
802 final String artifactType = artifact.getArtifactType();
803 return artifactType != null
804 && !ArtifactTypeEnum.VENDOR_LICENSE.getType().equals(ArtifactTypeEnum.findType(artifactType))
805 && !ArtifactTypeEnum.VF_LICENSE.getType().equals(ArtifactTypeEnum.findType(artifactType));
808 protected Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> organizeVfCsarArtifactsByArtifactOperation(
809 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList, List<ArtifactDefinition> existingArtifactsToHandle, Component component,
811 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> nodeTypeArtifactsToHandle = new EnumMap<>(
812 ArtifactsBusinessLogic.ArtifactOperationEnum.class);
813 Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
814 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> nodeTypeArtifactsToHandleRes = Either
815 .left(nodeTypeArtifactsToHandle);
817 List<CsarUtils.NonMetaArtifactInfo> artifactsToUpload = new ArrayList<>(artifactPathAndNameList);
818 List<CsarUtils.NonMetaArtifactInfo> artifactsToUpdate = new ArrayList<>();
819 List<CsarUtils.NonMetaArtifactInfo> artifactsToDelete = new ArrayList<>();
820 for (CsarUtils.NonMetaArtifactInfo currNewArtifact : artifactPathAndNameList) {
821 ArtifactDefinition foundArtifact;
822 if (!existingArtifactsToHandle.isEmpty()) {
823 foundArtifact = existingArtifactsToHandle.stream().filter(a -> a.getArtifactName().equals(currNewArtifact.getArtifactName()))
824 .findFirst().orElse(null);
825 if (foundArtifact != null) {
826 if (ArtifactTypeEnum.findType(foundArtifact.getArtifactType()).equals(currNewArtifact.getArtifactType())) {
827 if (!foundArtifact.getArtifactChecksum().equals(currNewArtifact.getArtifactChecksum())) {
828 currNewArtifact.setArtifactUniqueId(foundArtifact.getUniqueId());
829 artifactsToUpdate.add(currNewArtifact);
831 existingArtifactsToHandle.remove(foundArtifact);
832 artifactsToUpload.remove(currNewArtifact);
834 log.debug("Can't upload two artifact with the same name {}.", currNewArtifact.getArtifactName());
835 ResponseFormat responseFormat = ResponseFormatManager.getInstance()
836 .getResponseFormat(ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, currNewArtifact.getArtifactName(),
837 currNewArtifact.getArtifactType(), foundArtifact.getArtifactType());
838 AuditingActionEnum auditingAction = artifactsBusinessLogic.detectAuditingType(
839 new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE),
840 foundArtifact.getArtifactChecksum());
841 artifactsBusinessLogic.handleAuditing(auditingAction, component, component.getUniqueId(), user, null, null,
842 foundArtifact.getUniqueId(), responseFormat, component.getComponentType(), null);
843 responseWrapper.setInnerElement(responseFormat);
849 if (responseWrapper.isEmpty()) {
850 for (ArtifactDefinition currArtifact : existingArtifactsToHandle) {
851 if (currArtifact.getIsFromCsar()) {
852 artifactsToDelete.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
853 ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null,
854 currArtifact.getUniqueId(), currArtifact.getIsFromCsar()));
856 artifactsToUpdate.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
857 ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null,
858 currArtifact.getUniqueId(), currArtifact.getIsFromCsar()));
862 if (responseWrapper.isEmpty()) {
863 if (!artifactsToUpload.isEmpty()) {
864 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, artifactsToUpload);
866 if (!artifactsToUpdate.isEmpty()) {
867 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE, artifactsToUpdate);
869 if (!artifactsToDelete.isEmpty()) {
870 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE, artifactsToDelete);
873 if (!responseWrapper.isEmpty()) {
874 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
876 } catch (Exception e) {
877 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
878 responseWrapper.setInnerElement(responseFormat);
879 log.debug("Exception occured when findNodeTypeArtifactsToHandle, error is:{}", e.getMessage(), e);
880 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
882 return nodeTypeArtifactsToHandleRes;
885 protected Either<List<CsarUtils.NonMetaArtifactInfo>, String> getValidArtifactNames(CsarInfo csarInfo,
886 Map<String, Set<List<String>>> collectedWarningMessages) {
887 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = csarInfo.getCsar().entrySet().stream()
888 .filter(e -> Pattern.compile(VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN).matcher(e.getKey()).matches())
889 .map(e -> CsarUtils.validateNonMetaArtifact(e.getKey(), e.getValue(), collectedWarningMessages)).filter(Either::isLeft)
890 .map(e -> e.left().value()).collect(toList());
891 Pattern englishNumbersAndUnderScoresOnly = Pattern.compile(CsarUtils.VALID_ENGLISH_ARTIFACT_NAME);
892 for (CsarUtils.NonMetaArtifactInfo nonMetaArtifactInfo : artifactPathAndNameList) {
893 if (!englishNumbersAndUnderScoresOnly.matcher(nonMetaArtifactInfo.getDisplayName()).matches()) {
894 return Either.right(nonMetaArtifactInfo.getArtifactName());
897 return Either.left(artifactPathAndNameList);
900 protected Either<Service, ResponseFormat> createGroupsOnResource(Service service, Map<String, GroupDefinition> groups) {
901 if (groups != null && !groups.isEmpty()) {
902 List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, service);
903 serviceImportParseLogic.handleGroupsProperties(service, groups);
904 serviceImportParseLogic.fillGroupsFinalFields(groupsAsList);
905 Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic.createGroups(service, groupsAsList, true);
906 if (createGroups.isRight()) {
907 return Either.right(createGroups.right().value());
910 return Either.left(service);
912 return getServiceResponseFormatEither(service);
915 private Either<Service, ResponseFormat> createPoliciesOnResource(final Service service,
916 final Map<String, PolicyDefinition> policies) {
917 if (MapUtils.isEmpty(policies)) {
918 return Either.left(service);
920 final Map<String, List<AttributeDefinition>> instanceAttributeMap =
921 service.getComponentInstancesAttributes()
925 entry -> entry.getValue().stream().map(AttributeDefinition.class::cast).collect(toList()))
927 policies.values().stream()
928 .map(PolicyDataDefinition::getProperties)
929 .flatMap(Collection::stream)
930 .filter(PropertyDataDefinition::isToscaFunction)
931 .forEach(policyDefinition ->
933 .updateFunctionWithDataFromSelfComponent(policyDefinition.getToscaFunction(), service, service.getComponentInstancesProperties(), instanceAttributeMap)
935 policyBusinessLogic.createPolicies(service, policies);
936 return getServiceResponseFormatEither(service);
939 private Either<Service, ResponseFormat> getServiceResponseFormatEither(Service service) {
940 Either<Service, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
941 if (updatedResource.isRight()) {
942 ResponseFormat responseFormat = componentsUtils
943 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), service,
944 ComponentTypeEnum.SERVICE);
945 return Either.right(responseFormat);
947 return Either.left(updatedResource.left().value());
950 protected List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups, Service component) {
951 List<GroupDefinition> result = new ArrayList<>();
952 List<ComponentInstance> componentInstances = component.getComponentInstances();
953 if (groups != null) {
954 for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
955 String groupName = entry.getKey();
956 GroupDefinition groupDefinition = entry.getValue();
957 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
958 updatedGroupDefinition.setMembers(null);
959 Map<String, String> members = groupDefinition.getMembers();
960 if (members != null) {
961 serviceImportParseLogic.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
963 result.add(updatedGroupDefinition);
969 protected Resource createRIAndRelationsFromYaml(String yamlName, Resource resource,
970 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap,
971 String topologyTemplateYaml, List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
972 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
973 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
976 log.debug("************* Going to create all nodes {}", yamlName);
977 handleNodeTypes(yamlName, resource, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
979 log.debug("************* Going to create all resource instances {}", yamlName);
980 resource = createResourceInstances(yamlName, resource, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes());
981 log.debug("************* Finished to create all resource instances {}", yamlName);
982 resource = createResourceInstancesRelations(csarInfo.getModifier(), yamlName, resource, uploadComponentInstanceInfoMap);
983 log.debug("************* Going to create positions {}", yamlName);
984 compositionBusinessLogic.setPositionsForComponentInstances(resource, csarInfo.getModifier().getUserId());
985 log.debug("************* Finished to set positions {}", yamlName);
987 } catch (Exception e) {
988 throw new ComponentException(ActionStatus.GENERAL_ERROR);
992 protected Resource createResourceInstancesRelations(User user, String yamlName, Resource resource,
993 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
994 log.debug("#createResourceInstancesRelations - Going to create relations ");
995 List<ComponentInstance> componentInstancesList = resource.getComponentInstances();
996 if (((MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)) &&
997 resource.getResourceType() != ResourceTypeEnum.PNF)) { // PNF can have no resource instances
998 log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
999 resource.getUniqueId(), yamlName);
1000 BeEcompErrorManager.getInstance()
1001 .logInternalDataError("createResourceInstancesRelations", "No instances found in a resource or nn yaml template. ",
1002 BeEcompErrorManager.ErrorSeverity.ERROR);
1003 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName));
1005 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1006 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1007 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1008 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1009 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1010 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1011 Map<String, Resource> originCompMap = new HashMap<>();
1012 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1013 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1014 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1016 log.debug("enter ServiceImportBusinessLogic createResourceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. ");
1017 final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache;
1018 if (applicationDataTypeCache != null) {
1019 Resource finalResource = resource;
1020 uploadResInstancesMap.values().forEach(
1021 i -> processComponentInstance(yamlName, finalResource, componentInstancesList,
1022 componentsUtils.getAllDataTypes(applicationDataTypeCache, finalResource.getModel()), instProperties, instCapabilities,
1023 instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs, instNodeFilter, i));
1025 serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, resource, instProperties);
1026 serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, resource, instInputs);
1027 serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts);
1028 serviceImportParseLogic.associateArtifactsToInstances(yamlName, resource, instArtifacts);
1029 serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements);
1030 serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes);
1031 resource = serviceImportParseLogic.getResourceAfterCreateRelations(resource);
1032 serviceImportParseLogic.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList, relations);
1033 serviceImportParseLogic.associateResourceInstances(yamlName, resource, relations);
1034 handleSubstitutionMappings(resource, uploadResInstancesMap);
1035 log.debug("************* in create relations, getResource start");
1036 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
1037 log.debug("************* in create relations, getResource end");
1038 if (eitherGetResource.isRight()) {
1039 throw new ComponentException(
1040 componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource));
1042 return eitherGetResource.left().value();
1045 protected void processProperty(Resource resource, ComponentInstance currentCompInstance, Map<String, DataTypeDefinition> allDataTypes,
1046 Map<String, InputDefinition> currPropertiesMap, List<ComponentInstanceInput> instPropList,
1047 List<UploadPropInfo> propertyList) {
1048 UploadPropInfo propertyInfo = propertyList.get(0);
1049 String propName = propertyInfo.getName();
1050 if (!currPropertiesMap.containsKey(propName)) {
1051 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName));
1053 processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, resource.getInputs());
1056 private void processProperty(Map<String, DataTypeDefinition> allDataTypes, Map<String, InputDefinition> currPropertiesMap,
1057 List<ComponentInstanceInput> instPropList, UploadPropInfo propertyInfo, String propName,
1058 List<InputDefinition> inputs2) {
1059 InputDefinition curPropertyDef = currPropertiesMap.get(propName);
1060 ComponentInstanceInput property = null;
1061 String value = null;
1062 List<GetInputValueDataDefinition> getInputs = null;
1063 boolean isValidate = true;
1064 if (propertyInfo.getValue() != null) {
1065 getInputs = propertyInfo.getGet_input();
1066 isValidate = getInputs == null || getInputs.isEmpty();
1068 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
1070 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
1073 property = new ComponentInstanceInput(curPropertyDef, value, null);
1074 String validPropertyVAlue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
1075 property.setValue(validPropertyVAlue);
1076 if (isNotEmpty(getInputs)) {
1077 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1078 for (GetInputValueDataDefinition getInput : getInputs) {
1079 List<InputDefinition> inputs = inputs2;
1080 if (CollectionUtils.isEmpty(inputs)) {
1081 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1083 Optional<InputDefinition> optional = inputs.stream().filter(p -> p.getName().equals(getInput.getInputName())).findAny();
1084 if (!optional.isPresent()) {
1085 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1087 InputDefinition input = optional.get();
1088 getInput.setInputId(input.getUniqueId());
1089 getInputValues.add(getInput);
1090 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
1091 processGetInput(getInputValues, inputs, getInputIndex);
1093 property.setGetInputValues(getInputValues);
1095 instPropList.add(property);
1096 currPropertiesMap.remove(property.getName());
1099 protected void handleSubstitutionMappings(Resource resource, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1100 if (resource.getResourceType() == ResourceTypeEnum.VF) {
1101 Either<Resource, StorageOperationStatus> getResourceRes = toscaOperationFacade.getToscaFullElement(resource.getUniqueId());
1102 if (getResourceRes.isRight()) {
1103 ResponseFormat responseFormat = componentsUtils
1104 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource);
1105 throw new ComponentException(responseFormat);
1107 getResourceRes = updateCalculatedCapReqWithSubstitutionMappings(getResourceRes.left().value(), uploadResInstancesMap);
1108 if (getResourceRes.isRight()) {
1109 ResponseFormat responseFormat = componentsUtils
1110 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource);
1111 throw new ComponentException(responseFormat);
1116 protected Resource createResourceInstances(String yamlName, Resource resource, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1117 Map<String, Resource> nodeNamespaceMap) {
1118 Either<Resource, ResponseFormat> eitherResource = null;
1119 log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
1120 if (MapUtils.isEmpty(uploadResInstancesMap) && resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
1121 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
1122 throw new ComponentException(responseFormat);
1124 Map<String, Resource> existingNodeTypeMap = new HashMap<>();
1125 if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
1126 nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v));
1128 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1129 uploadResInstancesMap.values()
1130 .forEach(i -> createAndAddResourceInstance(i, yamlName, resource, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap));
1131 if (MapUtils.isNotEmpty(resourcesInstancesMap)) {
1133 toscaOperationFacade.associateComponentInstancesToComponent(resource, resourcesInstancesMap, false, false);
1134 } catch (StorageException exp) {
1135 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
1136 log.debug("Failed to add component instances to container component {}", resource.getName());
1137 ResponseFormat responseFormat = componentsUtils
1138 .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
1139 eitherResource = Either.right(responseFormat);
1140 throw new ByResponseFormatComponentException(eitherResource.right().value());
1144 log.debug("*************Going to get resource {}", resource.getUniqueId());
1145 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade
1146 .getToscaElement(resource.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter());
1147 log.debug("*************finished to get resource {}", resource.getUniqueId());
1148 if (eitherGetResource.isRight()) {
1149 ResponseFormat responseFormat = componentsUtils
1150 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource);
1151 throw new ComponentException(responseFormat);
1153 if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances()) &&
1154 resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
1155 log.debug("Error when create resource instance from csar. ComponentInstances list empty");
1156 BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty");
1157 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
1159 return eitherGetResource.left().value();
1162 protected void handleNodeTypes(String yamlName, Resource resource, String topologyTemplateYaml, boolean needLock,
1163 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1164 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1167 for (Map.Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
1168 if (nodeTypeEntry.getValue().isNested()) {
1169 handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1170 nodeTypeEntry.getKey());
1171 log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
1174 Map<String, Object> mappedToscaTemplate = null;
1175 if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo
1176 .containsKey(nodeName)) {
1177 mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
1179 if (MapUtils.isEmpty(mappedToscaTemplate)) {
1180 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
1182 createResourcesFromYamlNodeTypesList(yamlName, resource, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle,
1183 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
1184 } catch (ComponentException e) {
1185 ResponseFormat responseFormat =
1186 e.getResponseFormat() != null ? e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
1187 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
1189 } catch (StorageException e) {
1190 ResponseFormat responseFormat = componentsUtils
1191 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
1192 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
1194 } catch (Exception e) {
1195 log.debug("Exception occured when handleNodeTypes, error is:{}", e.getMessage(), e);
1196 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1200 protected Resource handleNestedVfc(Service service,
1201 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1202 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1205 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
1206 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
1207 createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
1209 log.debug("************* Finished to create node types from yaml {}", yamlName);
1210 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1211 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1212 return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
1214 return new Resource();
1215 } catch (Exception e) {
1216 log.debug("Exception occured when handleNestedVFc, error is:{}", e.getMessage(), e);
1217 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1221 protected Resource handleNestedVfc(Resource resource,
1222 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1223 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1225 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
1226 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
1227 log.debug("************* Going to create node types from yaml {}", yamlName);
1228 createResourcesFromYamlNodeTypesList(yamlName, resource, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
1230 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1231 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1232 resource = handleComplexVfc(resource, nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
1237 protected Resource handleComplexVfc(Resource resource,
1238 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1239 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1240 String nodeName, String yamlName) {
1241 Resource oldComplexVfc = null;
1242 Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(resource, csarInfo, nodeName, nodesInfo);
1243 Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
1244 .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
1245 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
1246 oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
1247 serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), nodeName).getRight());
1249 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
1250 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1251 } else if (oldComplexVfcRes.isLeft()) {
1252 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
1253 Either<Boolean, ResponseFormat> eitherValidation = serviceImportParseLogic
1254 .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc,
1255 ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
1256 if (eitherValidation.isLeft()) {
1257 oldComplexVfc = oldComplexVfcRes.left().value();
1260 newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc,
1262 csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
1263 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
1264 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR);
1265 log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
1266 final Resource result = serviceImportParseLogic
1267 .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true);
1268 csarInfo.getCreatedNodes().put(nodeName, result);
1269 csarInfo.removeNodeFromQueue();
1273 private Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Resource resource, Map<String, Object> mappedToscaTemplate,
1275 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1276 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1277 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
1278 Either<String, ImportUtils.ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
1279 TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
1280 if (toscaVersion.isRight()) {
1281 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
1283 Map<String, Object> mapToConvert = new HashMap<>();
1284 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value());
1285 Map<String, Object> nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate);
1286 createNodeTypes(yamlName, resource, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert,
1288 return csarInfo.getCreatedNodes();
1291 protected void createNodeTypes(String yamlName, Resource resource, boolean needLock,
1292 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1293 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1294 Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
1295 Iterator<Map.Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet().iterator();
1296 Resource vfcCreated = null;
1297 while (nodesNameValueIter.hasNext()) {
1298 Map.Entry<String, Object> nodeType = nodesNameValueIter.next();
1299 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle =
1300 nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeType.getKey());
1301 if (nodeTypesInfo.containsKey(nodeType.getKey())) {
1302 log.trace("************* Going to handle nested vfc {}", nodeType.getKey());
1303 vfcCreated = handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1305 log.trace("************* Finished to handle nested vfc {}", nodeType.getKey());
1306 } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames()
1307 .containsKey(nodeType.getKey())) {
1308 log.trace("************* Going to create node {}", nodeType.getKey());
1309 ImmutablePair<Resource, ActionStatus> resourceCreated = createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(),
1310 mapToConvert, resource, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true);
1311 log.debug("************* Finished to create node {}", nodeType.getKey());
1312 vfcCreated = resourceCreated.getLeft();
1313 csarInfo.getCreatedNodesToscaResourceNames().put(nodeType.getKey(), vfcCreated.getToscaResourceName());
1315 if (vfcCreated != null) {
1316 csarInfo.getCreatedNodes().put(nodeType.getKey(), vfcCreated);
1318 mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());
1322 protected ImmutablePair<Resource, ActionStatus> createNodeTypeResourceFromYaml(String yamlName, Map.Entry<String, Object> nodeNameValue,
1323 User user, Map<String, Object> mapToConvert, Resource resourceVf,
1325 Map<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
1326 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1327 boolean forceCertificationAllowed, CsarInfo csarInfo,
1329 UploadResourceInfo resourceMetaData = serviceImportParseLogic.fillResourceMetadata(yamlName, resourceVf, nodeNameValue.getKey(), user);
1330 String singleVfcYaml = serviceImportParseLogic.buildNodeTypeYaml(nodeNameValue, mapToConvert, resourceMetaData.getResourceType(), csarInfo);
1331 user = serviceBusinessLogic.validateUser(user, "CheckIn Resource", resourceVf, AuditingActionEnum.CHECKIN_RESOURCE, true);
1332 return serviceImportParseLogic.createResourceFromNodeType(singleVfcYaml, resourceMetaData, user, true, needLock, nodeTypeArtifactsToHandle,
1333 nodeTypesNewCreatedArtifacts, forceCertificationAllowed, csarInfo, nodeNameValue.getKey(), isNested);
1336 protected Service createRIAndRelationsFromYaml(String yamlName, Service service,
1337 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap,
1338 String topologyTemplateYaml, List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1339 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1340 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
1342 log.debug("************* Going to create all nodes {}", yamlName);
1343 handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts,
1344 nodeTypesInfo, csarInfo, nodeName);
1345 if (MapUtils.isNotEmpty(uploadComponentInstanceInfoMap)) {
1346 log.debug("************* Going to create all resource instances {}", yamlName);
1347 service = createServiceInstances(yamlName, service, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes());
1348 log.debug("************* Going to create all relations {}", yamlName);
1349 service = createServiceInstancesRelations(csarInfo.getModifier(), yamlName, service, uploadComponentInstanceInfoMap);
1350 log.debug("************* Going to create positions {}", yamlName);
1351 compositionBusinessLogic.setPositionsForComponentInstances(service, csarInfo.getModifier().getUserId());
1352 log.debug("************* Finished to set positions {}", yamlName);
1357 protected Service createServiceInstancesRelations(User user, String yamlName, Service service,
1358 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1359 log.debug("#createResourceInstancesRelations - Going to create relations ");
1360 List<ComponentInstance> componentInstancesList = service.getComponentInstances();
1361 if (MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)) { // PNF can have no resource instances
1362 log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
1363 service.getUniqueId(), yamlName);
1364 BeEcompErrorManager.getInstance()
1365 .logInternalDataError("createResourceInstancesRelations", "No instances found in a component or nn yaml template. ",
1366 BeEcompErrorManager.ErrorSeverity.ERROR);
1367 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName));
1369 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1370 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1371 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1372 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1373 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1374 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1375 Map<String, Resource> originCompMap = new HashMap<>();
1376 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1377 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1378 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1379 log.debug("enter ServiceImportBusinessLogic createServiceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. ");
1380 final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache;
1381 if (applicationDataTypeCache != null) {
1382 final Map<String, DataTypeDefinition> allDataTypesMap =
1383 componentsUtils.getAllDataTypes(applicationDataTypeCache, service.getModel());
1384 final Service service1 = service;
1385 uploadResInstancesMap.values().forEach(
1386 i -> processComponentInstance(yamlName, service1, componentInstancesList,
1387 allDataTypesMap, instProperties,
1388 instCapabilities, instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs,
1389 instNodeFilter, i));
1391 updatePropertyToscaFunctionData(service, instProperties, instAttributes);
1392 serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, service, instProperties);
1393 serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, service, instInputs);
1394 serviceImportParseLogic.associateCINodeFilterToComponent(yamlName, service, instNodeFilter);
1395 serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, service, instDeploymentArtifacts);
1396 serviceImportParseLogic.associateArtifactsToInstances(yamlName, service, instArtifacts);
1397 serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, service, instCapabilities, instRequirements);
1398 log.debug("enter createServiceInstancesRelations test,instRequirements:{},instCapabilities:{}", instRequirements, instCapabilities);
1399 serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, service, instAttributes);
1400 ToscaElement serviceTemplate = ModelConverter.convertToToscaElement(service);
1401 Map<String, ListCapabilityDataDefinition> capabilities = serviceTemplate.getCapabilities();
1402 Map<String, ListRequirementDataDefinition> requirements = serviceTemplate.getRequirements();
1403 serviceImportParseLogic.associateCapabilitiesToService(yamlName, service, capabilities);
1404 serviceImportParseLogic.associateRequirementsToService(yamlName, service, requirements);
1405 service = getResourceAfterCreateRelations(service);
1406 addRelationsToRI(yamlName, service, uploadResInstancesMap, componentInstancesList, relations);
1407 serviceImportParseLogic.associateResourceInstances(yamlName, service, relations);
1408 log.debug("************* in create relations, getResource start");
1409 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
1410 log.debug("************* in create relations, getResource end");
1411 if (eitherGetResource.isRight()) {
1412 throw new ComponentException(componentsUtils
1413 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service,
1414 service.getComponentType()));
1416 return eitherGetResource.left().value();
1419 private void updatePropertyToscaFunctionData(final Component service,
1420 final Map<String, List<ComponentInstanceProperty>> instancePropertyMap,
1421 final Map<String, List<AttributeDefinition>> instanceAttributeMap) {
1422 final Component updatedService =
1423 toscaOperationFacade.getToscaElement(service.getUniqueId()).left()
1424 .on(storageOperationStatus -> {
1425 final ActionStatus status = componentsUtils.convertFromStorageResponse(storageOperationStatus);
1426 final ResponseFormat responseFormat =
1427 componentsUtils.getResponseFormatByComponent(status, service, service.getComponentType());
1428 throw new ComponentException(responseFormat);
1431 instancePropertyMap.values().forEach(instancePropertyList ->
1432 instancePropertyList.stream()
1433 .filter(PropertyDataDefinition::isToscaFunction)
1434 .forEach(instanceProperty -> {
1435 toscaFunctionService.updateFunctionWithDataFromSelfComponent(instanceProperty.getToscaFunction(),
1436 updatedService, instancePropertyMap, instanceAttributeMap);
1437 instanceProperty.setValue(instanceProperty.getToscaFunction().getValue());
1442 protected void processComponentInstance(String yamlName, Component component, List<ComponentInstance> componentInstancesList,
1443 Map<String, DataTypeDefinition> allDataTypes,
1444 Map<String, List<ComponentInstanceProperty>> instProperties,
1445 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
1446 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements,
1447 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts,
1448 Map<String, Map<String, ArtifactDefinition>> instArtifacts,
1449 Map<String, List<AttributeDefinition>> instAttributes, Map<String, Resource> originCompMap,
1450 Map<String, List<ComponentInstanceInput>> instInputs,
1451 Map<String, UploadNodeFilterInfo> instNodeFilter,
1452 UploadComponentInstanceInfo uploadComponentInstanceInfo) {
1453 log.debug("enter ServiceImportBusinessLogic processComponentInstance");
1454 Optional<ComponentInstance> currentCompInstanceOpt = componentInstancesList.stream()
1455 .filter(i -> i.getName().equals(uploadComponentInstanceInfo.getName())).findFirst();
1456 if (currentCompInstanceOpt.isEmpty()) {
1457 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), component.getUniqueId());
1458 BeEcompErrorManager.getInstance()
1459 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, component.getUniqueId(),
1460 BeEcompErrorManager.ErrorSeverity.ERROR);
1461 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1462 throw new ComponentException(responseFormat);
1464 ComponentInstance currentCompInstance = currentCompInstanceOpt.get();
1465 String resourceInstanceId = currentCompInstance.getUniqueId();
1466 Resource originResource = getOriginResource(yamlName, originCompMap, currentCompInstance);
1467 if (MapUtils.isNotEmpty(originResource.getRequirements())) {
1468 instRequirements.put(currentCompInstance, originResource.getRequirements());
1470 if (MapUtils.isNotEmpty(originResource.getCapabilities())) {
1471 processComponentInstanceCapabilities(allDataTypes, instCapabilties, uploadComponentInstanceInfo, currentCompInstance, originResource);
1473 if (originResource.getDeploymentArtifacts() != null && !originResource.getDeploymentArtifacts().isEmpty()) {
1474 instDeploymentArtifacts.put(resourceInstanceId, originResource.getDeploymentArtifacts());
1476 if (originResource.getArtifacts() != null && !originResource.getArtifacts().isEmpty()) {
1477 instArtifacts.put(resourceInstanceId, originResource.getArtifacts());
1479 if (originResource.getAttributes() != null && !originResource.getAttributes().isEmpty()) {
1480 instAttributes.put(resourceInstanceId, originResource.getAttributes());
1481 addAttributeValueToResourceInstance(instAttributes, uploadComponentInstanceInfo.getAttributes());
1483 if (uploadComponentInstanceInfo.getUploadNodeFilterInfo() != null) {
1484 instNodeFilter.put(resourceInstanceId, uploadComponentInstanceInfo.getUploadNodeFilterInfo());
1486 if (originResource.getResourceType() != ResourceTypeEnum.VF) {
1487 ResponseFormat addPropertiesValueToRiRes = addPropertyValuesToRi(uploadComponentInstanceInfo, component, originResource,
1488 currentCompInstance, instProperties, allDataTypes);
1489 if (addPropertiesValueToRiRes.getStatus() != 200) {
1490 throw new ComponentException(addPropertiesValueToRiRes);
1493 addInputsValuesToRi(uploadComponentInstanceInfo, component, originResource, currentCompInstance, instInputs, allDataTypes);
1497 protected void addInputsValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component, Resource originResource,
1498 ComponentInstance currentCompInstance, Map<String, List<ComponentInstanceInput>> instInputs,
1499 Map<String, DataTypeDefinition> allDataTypes) {
1500 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
1502 if (MapUtils.isNotEmpty(propMap)) {
1503 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
1504 List<ComponentInstanceInput> instPropList = new ArrayList<>();
1505 if (CollectionUtils.isEmpty(originResource.getInputs())) {
1506 log.debug("failed to find properties ");
1507 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND));
1509 originResource.getInputs().forEach(p -> serviceImportParseLogic.addInput(currPropertiesMap, p));
1510 for (List<UploadPropInfo> propertyList : propMap.values()) {
1511 processProperty(component, currentCompInstance, allDataTypes, currPropertiesMap, instPropList, propertyList);
1513 currPropertiesMap.values().forEach(p -> instPropList.add(new ComponentInstanceInput(p)));
1514 instInputs.put(currentCompInstance.getUniqueId(), instPropList);
1516 } catch (Exception e) {
1517 log.debug("failed to add Inputs Values To Ri");
1518 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1522 protected void processProperty(Component component, ComponentInstance currentCompInstance, Map<String, DataTypeDefinition> allDataTypes,
1523 Map<String, InputDefinition> currPropertiesMap, List<ComponentInstanceInput> instPropList,
1524 List<UploadPropInfo> propertyList) {
1525 UploadPropInfo propertyInfo = propertyList.get(0);
1526 String propName = propertyInfo.getName();
1527 if (!currPropertiesMap.containsKey(propName)) {
1528 log.debug("failed to find property {} ", propName);
1529 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName));
1531 processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, component.getInputs());
1534 protected void processGetInput(List<GetInputValueDataDefinition> getInputValues, List<InputDefinition> inputs,
1535 GetInputValueDataDefinition getInputIndex) {
1536 Optional<InputDefinition> optional;
1537 if (getInputIndex != null) {
1538 optional = inputs.stream().filter(p -> p.getName().equals(getInputIndex.getInputName())).findAny();
1539 if (!optional.isPresent()) {
1540 log.debug("Failed to find input {} ", getInputIndex.getInputName());
1541 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1543 InputDefinition inputIndex = optional.get();
1544 getInputIndex.setInputId(inputIndex.getUniqueId());
1545 getInputValues.add(getInputIndex);
1549 private void addAttributeValueToResourceInstance(Map<String, List<AttributeDefinition>> instAttributes,
1550 Map<String, UploadAttributeInfo> attributeMap) {
1551 if (attributeMap == null) {
1554 attributeMap.forEach((attributeName, attributeValue) -> instAttributes.values()
1555 .forEach(value -> value.stream().filter(attr -> attr.getName().equals(attributeName)).forEach(attr -> {
1556 if (attributeValue.getValue() instanceof Collection<?> || attributeValue.getValue() instanceof Map<?, ?>) {
1557 Gson gson = new Gson();
1558 String json = gson.toJson(attributeValue.getValue());
1559 attr.setValue(json);
1561 attr.setValue(String.valueOf(attributeValue.getValue()));
1566 protected ResponseFormat addPropertyValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component,
1567 Resource originResource, ComponentInstance currentCompInstance,
1568 Map<String, List<ComponentInstanceProperty>> instProperties,
1569 Map<String, DataTypeDefinition> allDataTypes) {
1570 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
1571 Map<String, PropertyDefinition> currPropertiesMap = new HashMap<>();
1572 List<PropertyDefinition> originalPropertyList = originResource.getProperties();
1573 if (MapUtils.isNotEmpty(propMap) && CollectionUtils.isEmpty(originalPropertyList)) {
1574 log.debug("failed to find properties ");
1575 return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND);
1577 if (CollectionUtils.isEmpty(originalPropertyList)) {
1578 return componentsUtils.getResponseFormat(ActionStatus.OK);
1580 originalPropertyList.stream()
1581 .filter(property -> !currPropertiesMap.containsKey(property.getName()))
1582 .forEach(property -> currPropertiesMap.put(property.getName(), property));
1583 List<ComponentInstanceProperty> instPropList = new ArrayList<>();
1584 if (MapUtils.isNotEmpty(propMap)) {
1585 for (final List<UploadPropInfo> propertyList : propMap.values()) {
1586 UploadPropInfo propertyInfo = propertyList.get(0);
1587 String propName = propertyInfo.getName();
1588 if (!currPropertiesMap.containsKey(propName)) {
1589 log.debug("failed to find property {} ", propName);
1590 return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName);
1592 PropertyDefinition curPropertyDef = currPropertiesMap.get(propName);
1593 String value = null;
1594 final List<GetInputValueDataDefinition> getInputs = new ArrayList<>();
1595 boolean isValidate = true;
1596 if (propertyInfo.getValue() != null) {
1597 getInputs.addAll(propertyInfo.getGet_input());
1598 isValidate = getInputs.isEmpty();
1600 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
1602 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
1605 final var property = new ComponentInstanceProperty(curPropertyDef, value, null);
1606 String validatePropValue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
1607 property.setValue(validatePropValue);
1608 property.setToscaFunction(propertyInfo.getToscaFunction());
1609 if (!getInputs.isEmpty()) {
1610 final List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1611 for (final GetInputValueDataDefinition getInput : getInputs) {
1612 final List<InputDefinition> inputs = component.getInputs();
1613 if (inputs == null || inputs.isEmpty()) {
1614 log.debug("Failed to add property {} to instance. Inputs list is empty ", property);
1615 serviceBusinessLogic.rollbackWithException(ActionStatus.INPUTS_NOT_FOUND,
1616 property.getGetInputValues().stream().map(GetInputValueDataDefinition::getInputName).collect(toList()).toString());
1618 InputDefinition input = serviceImportParseLogic.findInputByName(inputs, getInput);
1619 getInput.setInputId(input.getUniqueId());
1620 getInputValues.add(getInput);
1621 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
1622 if (getInputIndex != null) {
1623 input = serviceImportParseLogic.findInputByName(inputs, getInputIndex);
1624 getInputIndex.setInputId(input.getUniqueId());
1625 getInputValues.add(getInputIndex);
1628 property.setGetInputValues(getInputValues);
1630 instPropList.add(property);
1631 currPropertiesMap.remove(property.getName());
1634 if (!currPropertiesMap.isEmpty()) {
1635 for (PropertyDefinition value : currPropertiesMap.values()) {
1636 instPropList.add(new ComponentInstanceProperty(value));
1639 instProperties.put(currentCompInstance.getUniqueId(), instPropList);
1640 return componentsUtils.getResponseFormat(ActionStatus.OK);
1643 protected void processComponentInstanceCapabilities(Map<String, DataTypeDefinition> allDataTypes,
1644 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
1645 UploadComponentInstanceInfo uploadComponentInstanceInfo,
1646 ComponentInstance currentCompInstance, Resource originResource) {
1647 log.debug("enter processComponentInstanceCapabilities");
1648 Map<String, List<CapabilityDefinition>> originCapabilities;
1649 if (MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities())) {
1650 originCapabilities = new HashMap<>();
1651 Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
1652 originResource.getCapabilities().forEach((k, v) -> serviceImportParseLogic.addCapabilities(originCapabilities, k, v));
1653 uploadComponentInstanceInfo.getCapabilities().values()
1654 .forEach(l -> serviceImportParseLogic.addCapabilitiesProperties(newPropertiesMap, l));
1655 updateCapabilityPropertiesValues(allDataTypes, originCapabilities, newPropertiesMap);
1657 originCapabilities = originResource.getCapabilities();
1659 instCapabilties.put(currentCompInstance, originCapabilities);
1662 protected void updateCapabilityPropertiesValues(Map<String, DataTypeDefinition> allDataTypes,
1663 Map<String, List<CapabilityDefinition>> originCapabilities,
1664 Map<String, Map<String, UploadPropInfo>> newPropertiesMap) {
1665 originCapabilities.values().stream().flatMap(Collection::stream).filter(c -> newPropertiesMap.containsKey(c.getName()))
1666 .forEach(c -> updatePropertyValues(c.getProperties(), newPropertiesMap.get(c.getName()), allDataTypes));
1669 protected void updatePropertyValues(List<ComponentInstanceProperty> properties, Map<String, UploadPropInfo> newProperties,
1670 Map<String, DataTypeDefinition> allDataTypes) {
1671 properties.forEach(p -> updatePropertyValue(p, newProperties.get(p.getName()), allDataTypes));
1674 protected String updatePropertyValue(ComponentInstanceProperty property, UploadPropInfo propertyInfo,
1675 Map<String, DataTypeDefinition> allDataTypes) {
1676 String value = null;
1677 List<GetInputValueDataDefinition> getInputs = null;
1678 boolean isValidate = true;
1679 if (null != propertyInfo && propertyInfo.getValue() != null) {
1680 getInputs = propertyInfo.getGet_input();
1681 isValidate = getInputs == null || getInputs.isEmpty();
1683 value = getPropertyJsonStringValue(propertyInfo.getValue(), property.getType());
1685 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
1688 property.setValue(value);
1689 return serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
1692 protected Resource getOriginResource(String yamlName, Map<String, Resource> originCompMap, ComponentInstance currentCompInstance) {
1693 Resource originResource;
1694 log.debug("after enter ServiceImportBusinessLogic processComponentInstance, enter getOriginResource");
1695 if (!originCompMap.containsKey(currentCompInstance.getComponentUid())) {
1696 Either<Resource, StorageOperationStatus> getOriginResourceRes = toscaOperationFacade
1697 .getToscaFullElement(currentCompInstance.getComponentUid());
1698 if (getOriginResourceRes.isRight()) {
1699 ResponseFormat responseFormat = componentsUtils
1700 .getResponseFormat(componentsUtils.convertFromStorageResponse(getOriginResourceRes.right().value()), yamlName);
1701 throw new ComponentException(responseFormat);
1703 originResource = getOriginResourceRes.left().value();
1704 originCompMap.put(originResource.getUniqueId(), originResource);
1706 originResource = originCompMap.get(currentCompInstance.getComponentUid());
1708 return originResource;
1711 protected Either<Resource, StorageOperationStatus> updateCalculatedCapReqWithSubstitutionMappings(Resource resource,
1712 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1713 Either<Resource, StorageOperationStatus> updateRes = null;
1714 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities = new HashMap<>();
1715 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements = new HashMap<>();
1716 StorageOperationStatus status = toscaOperationFacade.deleteAllCalculatedCapabilitiesRequirements(resource.getUniqueId());
1717 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
1718 log.debug("Failed to delete all calculated capabilities and requirements of resource {} upon update. Status is {}",
1719 resource.getUniqueId(), status);
1720 updateRes = Either.right(status);
1722 if (updateRes == null) {
1723 fillUpdatedInstCapabilitiesRequirements(resource.getComponentInstances(), uploadResInstancesMap, updatedInstCapabilities,
1724 updatedInstRequirements);
1725 status = toscaOperationFacade.associateOrAddCalculatedCapReq(updatedInstCapabilities, updatedInstRequirements, resource);
1726 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
1727 updateRes = Either.right(status);
1730 if (updateRes == null) {
1731 updateRes = Either.left(resource);
1736 protected void fillUpdatedInstCapabilitiesRequirements(List<ComponentInstance> componentInstances,
1737 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1738 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities,
1739 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements) {
1740 componentInstances.stream().forEach(i -> {
1741 fillUpdatedInstCapabilities(updatedInstCapabilities, i, uploadResInstancesMap.get(i.getName()).getCapabilitiesNamesToUpdate());
1742 fillUpdatedInstRequirements(updatedInstRequirements, i, uploadResInstancesMap.get(i.getName()).getRequirementsNamesToUpdate());
1746 protected void fillUpdatedInstCapabilities(Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilties,
1747 ComponentInstance instance, Map<String, String> capabilitiesNamesToUpdate) {
1748 Map<String, List<CapabilityDefinition>> updatedCapabilities = new HashMap<>();
1749 Set<String> updatedCapNames = new HashSet<>();
1750 if (MapUtils.isNotEmpty(capabilitiesNamesToUpdate)) {
1751 for (Map.Entry<String, List<CapabilityDefinition>> requirements : instance.getCapabilities().entrySet()) {
1752 updatedCapabilities.put(requirements.getKey(), requirements.getValue().stream().filter(
1753 c -> capabilitiesNamesToUpdate.containsKey(c.getName()) && !updatedCapNames.contains(capabilitiesNamesToUpdate.get(c.getName())))
1755 c.setParentName(c.getName());
1756 c.setName(capabilitiesNamesToUpdate.get(c.getName()));
1757 updatedCapNames.add(c.getName());
1759 }).collect(toList()));
1762 if (MapUtils.isNotEmpty(updatedCapabilities)) {
1763 updatedInstCapabilties.put(instance, updatedCapabilities);
1767 protected void fillUpdatedInstRequirements(Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements,
1768 ComponentInstance instance, Map<String, String> requirementsNamesToUpdate) {
1769 Map<String, List<RequirementDefinition>> updatedRequirements = new HashMap<>();
1770 Set<String> updatedReqNames = new HashSet<>();
1771 if (MapUtils.isNotEmpty(requirementsNamesToUpdate)) {
1772 for (Map.Entry<String, List<RequirementDefinition>> requirements : instance.getRequirements().entrySet()) {
1773 updatedRequirements.put(requirements.getKey(), requirements.getValue().stream().filter(
1774 r -> requirementsNamesToUpdate.containsKey(r.getName()) && !updatedReqNames.contains(requirementsNamesToUpdate.get(r.getName())))
1776 r.setParentName(r.getName());
1777 r.setName(requirementsNamesToUpdate.get(r.getName()));
1778 updatedReqNames.add(r.getName());
1780 }).collect(toList()));
1783 if (MapUtils.isNotEmpty(updatedRequirements)) {
1784 updatedInstRequirements.put(instance, updatedRequirements);
1788 protected void addRelationsToRI(String yamlName, Service service, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1789 List<ComponentInstance> componentInstancesList, List<RequirementCapabilityRelDef> relations) {
1790 for (Map.Entry<String, UploadComponentInstanceInfo> entry : uploadResInstancesMap.entrySet()) {
1791 UploadComponentInstanceInfo uploadComponentInstanceInfo = entry.getValue();
1792 ComponentInstance currentCompInstance = null;
1793 for (ComponentInstance compInstance : componentInstancesList) {
1794 if (compInstance.getName().equals(uploadComponentInstanceInfo.getName())) {
1795 currentCompInstance = compInstance;
1799 if (currentCompInstance == null) {
1800 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), service.getUniqueId());
1801 BeEcompErrorManager.getInstance()
1802 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, service.getUniqueId(),
1803 BeEcompErrorManager.ErrorSeverity.ERROR);
1804 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1805 throw new ComponentException(responseFormat);
1807 ResponseFormat addRelationToRiRes = addRelationToRI(yamlName, service, entry.getValue(), relations);
1808 if (addRelationToRiRes.getStatus() != 200) {
1809 throw new ComponentException(addRelationToRiRes);
1814 protected ResponseFormat addRelationToRI(String yamlName, Service service, UploadComponentInstanceInfo nodesInfoValue,
1815 List<RequirementCapabilityRelDef> relations) {
1816 List<ComponentInstance> componentInstancesList = service.getComponentInstances();
1817 ComponentInstance currentCompInstance = null;
1818 for (ComponentInstance compInstance : componentInstancesList) {
1819 if (compInstance.getName().equals(nodesInfoValue.getName())) {
1820 currentCompInstance = compInstance;
1824 if (currentCompInstance == null) {
1825 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, nodesInfoValue.getName(), service.getUniqueId());
1826 BeEcompErrorManager.getInstance()
1827 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + nodesInfoValue.getName() + IN_RESOURCE, service.getUniqueId(),
1828 BeEcompErrorManager.ErrorSeverity.ERROR);
1829 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1831 String resourceInstanceId = currentCompInstance.getUniqueId();
1832 Map<String, List<UploadReqInfo>> regMap = nodesInfoValue.getRequirements();
1833 if (regMap != null) {
1834 Iterator<Map.Entry<String, List<UploadReqInfo>>> nodesRegValue = regMap.entrySet().iterator();
1835 while (nodesRegValue.hasNext()) {
1836 Map.Entry<String, List<UploadReqInfo>> nodesRegInfoEntry = nodesRegValue.next();
1837 List<UploadReqInfo> uploadRegInfoList = nodesRegInfoEntry.getValue();
1838 for (UploadReqInfo uploadRegInfo : uploadRegInfoList) {
1839 log.debug("Going to create relation {}", uploadRegInfo.getName());
1840 String regName = uploadRegInfo.getName();
1841 RequirementCapabilityRelDef regCapRelDef = new RequirementCapabilityRelDef();
1842 regCapRelDef.setFromNode(resourceInstanceId);
1843 log.debug("try to find available requirement {} ", regName);
1844 Either<RequirementDefinition, ResponseFormat> eitherReqStatus = serviceImportParseLogic
1845 .findAvailableRequirement(regName, yamlName, nodesInfoValue, currentCompInstance, uploadRegInfo.getCapabilityName());
1846 if (eitherReqStatus.isRight()) {
1847 log.debug("failed to find available requirement {} status is {}", regName, eitherReqStatus.right().value());
1848 return eitherReqStatus.right().value();
1850 RequirementDefinition validReq = eitherReqStatus.left().value();
1851 List<CapabilityRequirementRelationship> reqAndRelationshipPairList = regCapRelDef.getRelationships();
1852 if (reqAndRelationshipPairList == null) {
1853 reqAndRelationshipPairList = new ArrayList<>();
1855 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1856 reqAndRelationshipPair.setRequirement(regName);
1857 reqAndRelationshipPair.setRequirementOwnerId(validReq.getOwnerId());
1858 reqAndRelationshipPair.setRequirementUid(validReq.getUniqueId());
1859 RelationshipImpl relationship = new RelationshipImpl();
1860 relationship.setType(validReq.getCapability());
1861 reqAndRelationshipPair.setRelationships(relationship);
1862 ComponentInstance currentCapCompInstance = null;
1863 for (ComponentInstance compInstance : componentInstancesList) {
1864 if (compInstance.getName().equals(uploadRegInfo.getNode())) {
1865 currentCapCompInstance = compInstance;
1869 if (currentCapCompInstance == null) {
1870 log.debug("The component instance with name {} not found on resource {} ", uploadRegInfo.getNode(), service.getUniqueId());
1871 BeEcompErrorManager.getInstance()
1872 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadRegInfo.getNode() + IN_RESOURCE, service.getUniqueId(),
1873 BeEcompErrorManager.ErrorSeverity.ERROR);
1874 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1876 regCapRelDef.setToNode(currentCapCompInstance.getUniqueId());
1877 log.debug("try to find aviable Capability req name is {} ", validReq.getName());
1878 CapabilityDefinition aviableCapForRel = serviceImportParseLogic
1879 .findAvailableCapabilityByTypeOrName(validReq, currentCapCompInstance, uploadRegInfo);
1880 if (aviableCapForRel == null) {
1881 BeEcompErrorManager.getInstance().logInternalDataError(
1882 "aviable capability was not found. req name is " + validReq.getName() + " component instance is " + currentCapCompInstance
1883 .getUniqueId(), service.getUniqueId(), BeEcompErrorManager.ErrorSeverity.ERROR);
1884 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1886 reqAndRelationshipPair.setCapability(aviableCapForRel.getName());
1887 reqAndRelationshipPair.setCapabilityUid(aviableCapForRel.getUniqueId());
1888 reqAndRelationshipPair.setCapabilityOwnerId(aviableCapForRel.getOwnerId());
1889 CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship();
1890 capReqRel.setRelation(reqAndRelationshipPair);
1891 if (StringUtils.isNotEmpty(uploadRegInfo.getRelationshipTemplate())) {
1892 capReqRel.setOperations(getOperations(nodesInfoValue.getOperations(), uploadRegInfo.getRelationshipTemplate()));
1894 reqAndRelationshipPairList.add(capReqRel);
1895 regCapRelDef.setRelationships(reqAndRelationshipPairList);
1896 relations.add(regCapRelDef);
1900 return componentsUtils.getResponseFormat(ActionStatus.OK, yamlName);
1903 private List<OperationUi> getOperations(final Map<String, List<OperationUi>> operations, final String relationshipTemplate) {
1904 final List<OperationUi> operationUiList = new ArrayList<>();
1905 operations.forEach((operationKey, operationValues) -> {
1906 if (operationKey.equals(relationshipTemplate)) {
1907 operationUiList.addAll(operationValues);
1910 return operationUiList;
1913 protected Service getResourceAfterCreateRelations(Service service) {
1914 ComponentParametersView parametersView = serviceImportParseLogic.getComponentFilterAfterCreateRelations();
1915 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId(), parametersView);
1916 if (eitherGetResource.isRight()) {
1917 serviceImportParseLogic.throwComponentExceptionByResource(eitherGetResource.right().value(), service);
1919 return eitherGetResource.left().value();
1922 protected Service createServiceInstances(String yamlName, Service service, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1923 Map<String, Resource> nodeNamespaceMap) {
1924 Either<Resource, ResponseFormat> eitherResource = null;
1925 log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
1926 if (MapUtils.isEmpty(uploadResInstancesMap)) { // PNF can have no resource instances
1927 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
1928 throw new ComponentException(responseFormat);
1930 Map<String, Resource> existingNodeTypeMap = new HashMap<>();
1931 if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
1932 nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v));
1934 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1935 uploadResInstancesMap.values()
1936 .forEach(i -> createAndAddResourceInstance(i, yamlName, service, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap));
1937 if (MapUtils.isNotEmpty(resourcesInstancesMap)) {
1939 toscaOperationFacade.associateComponentInstancesToComponent(service, resourcesInstancesMap, false, false);
1940 } catch (StorageException exp) {
1941 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
1942 log.debug("Failed to add component instances to container component {}", service.getName());
1943 ResponseFormat responseFormat = componentsUtils
1944 .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
1945 eitherResource = Either.right(responseFormat);
1946 throw new ComponentException(eitherResource.right().value());
1950 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade
1951 .getToscaElement(service.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter());
1952 log.debug("*************finished to get resource {}", service.getUniqueId());
1953 if (eitherGetResource.isRight()) {
1954 ResponseFormat responseFormat = componentsUtils
1955 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service,
1956 ComponentTypeEnum.SERVICE);
1957 throw new ComponentException(responseFormat);
1959 if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances())) { // PNF can have no resource instances
1960 log.debug("Error when create resource instance from csar. ComponentInstances list empty");
1961 BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty");
1962 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
1964 return eitherGetResource.left().value();
1967 protected void createAndAddResourceInstance(UploadComponentInstanceInfo uploadComponentInstanceInfo, String yamlName, Component component,
1968 Map<String, Resource> nodeNamespaceMap, Map<String, Resource> existingnodeTypeMap,
1969 Map<ComponentInstance, Resource> resourcesInstancesMap) {
1970 log.debug("*************Going to create resource instances {}", uploadComponentInstanceInfo.getName());
1972 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
1973 uploadComponentInstanceInfo.setType(nodeNamespaceMap.get(uploadComponentInstanceInfo.getType()).getToscaResourceName());
1975 Resource refResource = validateResourceInstanceBeforeCreate(yamlName, uploadComponentInstanceInfo, existingnodeTypeMap);
1976 ComponentInstance componentInstance = new ComponentInstance();
1977 componentInstance.setComponentUid(refResource.getUniqueId());
1978 Collection<String> directives = uploadComponentInstanceInfo.getDirectives();
1979 if (directives != null && !directives.isEmpty()) {
1980 componentInstance.setDirectives(new ArrayList<>(directives));
1982 UploadNodeFilterInfo uploadNodeFilterInfo = uploadComponentInstanceInfo.getUploadNodeFilterInfo();
1983 if (uploadNodeFilterInfo != null) {
1985 .setNodeFilter(new CINodeFilterUtils().getNodeFilterDataDefinition(uploadNodeFilterInfo, componentInstance.getUniqueId()));
1987 ComponentTypeEnum containerComponentType = component.getComponentType();
1988 NodeTypeEnum containerNodeType = containerComponentType.getNodeType();
1989 if (containerNodeType.equals(NodeTypeEnum.Resource) && MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities()) && MapUtils
1990 .isNotEmpty(refResource.getCapabilities())) {
1991 serviceImportParseLogic.setCapabilityNamesTypes(refResource.getCapabilities(), uploadComponentInstanceInfo.getCapabilities());
1992 Map<String, List<CapabilityDefinition>> validComponentInstanceCapabilities = serviceImportParseLogic
1993 .getValidComponentInstanceCapabilities(refResource.getUniqueId(), refResource.getCapabilities(),
1994 uploadComponentInstanceInfo.getCapabilities());
1995 componentInstance.setCapabilities(validComponentInstanceCapabilities);
1997 if (!existingnodeTypeMap.containsKey(uploadComponentInstanceInfo.getType())) {
1998 ResponseFormat responseFormat = componentsUtils
1999 .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(),
2000 uploadComponentInstanceInfo.getType());
2001 throw new ComponentException(responseFormat);
2003 Resource origResource = existingnodeTypeMap.get(uploadComponentInstanceInfo.getType());
2004 componentInstance.setName(uploadComponentInstanceInfo.getName());
2005 componentInstance.setIcon(origResource.getIcon());
2006 resourcesInstancesMap.put(componentInstance, origResource);
2007 } catch (Exception e) {
2008 throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
2012 protected Resource validateResourceInstanceBeforeCreate(String yamlName, UploadComponentInstanceInfo uploadComponentInstanceInfo,
2013 Map<String, Resource> nodeNamespaceMap) {
2014 Resource refResource;
2016 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
2017 refResource = nodeNamespaceMap.get(uploadComponentInstanceInfo.getType());
2019 Either<Resource, StorageOperationStatus> findResourceEither = toscaOperationFacade
2020 .getLatestResourceByToscaResourceName(uploadComponentInstanceInfo.getType());
2021 if (findResourceEither.isRight()) {
2022 ResponseFormat responseFormat = componentsUtils
2023 .getResponseFormat(componentsUtils.convertFromStorageResponse(findResourceEither.right().value()));
2024 throw new ComponentException(responseFormat);
2026 refResource = findResourceEither.left().value();
2027 nodeNamespaceMap.put(refResource.getToscaResourceName(), refResource);
2029 String componentState = refResource.getComponentMetadataDefinition().getMetadataDataDefinition().getState();
2030 if (componentState.equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
2031 ResponseFormat responseFormat = componentsUtils
2032 .getResponseFormat(ActionStatus.ILLEGAL_COMPONENT_STATE, refResource.getComponentType().getValue(), refResource.getName(),
2034 throw new ComponentException(responseFormat);
2036 if (!ModelConverter.isAtomicComponent(refResource) && refResource.getResourceType() != ResourceTypeEnum.VF) {
2037 log.debug("validateResourceInstanceBeforeCreate - ref resource type is ", refResource.getResourceType());
2038 ResponseFormat responseFormat = componentsUtils
2039 .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(),
2040 uploadComponentInstanceInfo.getType());
2041 throw new ComponentException(responseFormat);
2044 } catch (Exception e) {
2045 throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
2049 protected void handleServiceNodeTypes(String yamlName, Service service, String topologyTemplateYaml, boolean needLock,
2050 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2051 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo,
2052 CsarInfo csarInfo, String nodeName) {
2054 for (Map.Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
2055 boolean isResourceNotExisted = validateResourceNotExisted(nodeTypeEntry.getKey());
2056 if (nodeTypeEntry.getValue().isNested() && isResourceNotExisted) {
2057 handleNestedVF(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
2058 nodeTypeEntry.getKey());
2059 log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
2062 Map<String, Object> mappedToscaTemplate = null;
2063 if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo
2064 .containsKey(nodeName)) {
2065 mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
2067 if (MapUtils.isEmpty(mappedToscaTemplate)) {
2068 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
2070 createResourcesFromYamlNodeTypesList(yamlName, service, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle,
2071 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
2072 } catch (ComponentException | StorageException e) {
2074 } catch (Exception e) {
2075 log.debug("Exception occured when handleServiceNodeTypes, error is:{}", e.getMessage(), e);
2076 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2080 protected boolean validateResourceNotExisted(String type) {
2082 Either<Resource, StorageOperationStatus> latestResource = toscaOperationFacade.getLatestResourceByToscaResourceName(type);
2083 return latestResource.isRight();
2084 } catch (Exception e) {
2085 log.debug("Exception occured when validateResourceNotExisted, error is:{}", e.getMessage(), e);
2086 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2090 protected Resource handleNestedVF(Service service,
2091 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2092 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
2095 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
2096 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
2097 createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
2099 log.debug("************* Finished to create node types from yaml {}", yamlName);
2100 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
2101 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
2102 return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
2104 return new Resource();
2105 } catch (Exception e) {
2106 log.debug("Exception occured when handleNestedVF, error is:{}", e.getMessage(), e);
2107 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2111 protected Resource handleComplexVfc(
2112 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2113 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName) {
2115 Resource oldComplexVfc = null;
2116 Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(csarInfo, nodeName, nodesInfo);
2117 Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
2118 .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
2119 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
2120 oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
2121 serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), nodeName)
2124 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
2125 log.debug("Failed to fetch previous complex VFC by tosca resource name {}. Status is {}. ", newComplexVfc.getToscaResourceName(),
2126 oldComplexVfcRes.right().value());
2127 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2128 } else if (oldComplexVfcRes.isLeft()) {
2129 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
2130 Either<Boolean, ResponseFormat> eitherValidation = serviceImportParseLogic
2131 .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc,
2132 ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
2133 if (eitherValidation.isLeft()) {
2134 oldComplexVfc = oldComplexVfcRes.left().value();
2137 newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc,
2139 csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
2140 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
2141 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR);
2142 log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
2143 final Resource result = serviceImportParseLogic
2144 .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true);
2145 csarInfo.getCreatedNodes().put(nodeName, result);
2146 csarInfo.removeNodeFromQueue();
2148 } catch (Exception e) {
2149 log.debug("Exception occured when handleComplexVfc, error is:{}", e.getMessage(), e);
2150 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2154 protected Resource handleComplexVfc(
2155 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2156 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName,
2157 Resource oldComplexVfc, Resource newComplexVfc) {
2158 Resource handleComplexVfcRes;
2160 Map<String, Object> mappedToscaTemplate = nodesInfo.get(nodeName).getMappedToscaTemplate();
2161 String yamlContent = new String(csarInfo.getCsar().get(yamlName));
2162 Map<String, NodeTypeInfo> newNodeTypesInfo = nodesInfo.entrySet().stream()
2163 .collect(toMap(Map.Entry::getKey, e -> e.getValue().getUnmarkedCopy()));
2164 CsarInfo.markNestedVfc(mappedToscaTemplate, newNodeTypesInfo);
2165 if (oldComplexVfc == null) {
2166 handleComplexVfcRes = createResourceFromYaml(newComplexVfc, yamlContent, yamlName, newNodeTypesInfo, csarInfo, nodesArtifactsToHandle,
2167 false, true, nodeName);
2169 handleComplexVfcRes = updateResourceFromYaml(oldComplexVfc, newComplexVfc, AuditingActionEnum.UPDATE_RESOURCE_METADATA,
2170 createdArtifacts, yamlContent, yamlName, csarInfo, newNodeTypesInfo, nodesArtifactsToHandle, nodeName, true);
2172 return handleComplexVfcRes;
2173 } catch (Exception e) {
2174 log.debug("Exception occured when handleComplexVfc, error is:{}", e.getMessage(), e);
2175 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2179 protected Resource updateResourceFromYaml(Resource oldRresource, Resource newRresource, AuditingActionEnum actionEnum,
2180 List<ArtifactDefinition> createdArtifacts, String yamlFileName, String yamlFileContent,
2181 CsarInfo csarInfo, Map<String, NodeTypeInfo> nodeTypesInfo,
2182 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2183 String nodeName, boolean isNested) {
2184 boolean inTransaction = true;
2185 boolean shouldLock = false;
2186 Resource preparedResource = null;
2187 ParsedToscaYamlInfo uploadComponentInstanceInfoMap = null;
2189 uploadComponentInstanceInfoMap = csarBusinessLogic
2190 .getParsedToscaYamlInfo(yamlFileContent, yamlFileName, nodeTypesInfo, csarInfo, nodeName, oldRresource);
2191 Map<String, UploadComponentInstanceInfo> instances = uploadComponentInstanceInfoMap.getInstances();
2192 if (MapUtils.isEmpty(instances) && newRresource.getResourceType() != ResourceTypeEnum.PNF) {
2193 throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlFileName);
2195 preparedResource = updateExistingResourceByImport(newRresource, oldRresource, csarInfo.getModifier(), inTransaction, shouldLock,
2197 log.trace("YAML topology file found in CSAR, file name: {}, contents: {}", yamlFileName, yamlFileContent);
2198 serviceImportParseLogic.handleResourceGenericType(preparedResource);
2199 handleNodeTypes(yamlFileName, preparedResource, yamlFileContent, shouldLock, nodeTypesArtifactsToHandle, createdArtifacts, nodeTypesInfo,
2200 csarInfo, nodeName);
2201 preparedResource = serviceImportParseLogic.createInputsOnResource(preparedResource, uploadComponentInstanceInfoMap.getInputs());
2202 preparedResource = createResourceInstances(yamlFileName, preparedResource, instances, csarInfo.getCreatedNodes());
2203 preparedResource = createResourceInstancesRelations(csarInfo.getModifier(), yamlFileName, preparedResource, instances);
2204 } catch (ComponentException e) {
2205 ResponseFormat responseFormat =
2206 e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
2207 log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat);
2209 .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum);
2211 } catch (StorageException e) {
2212 ResponseFormat responseFormat = componentsUtils
2213 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
2214 log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat);
2216 .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum);
2219 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic.validateUpdateVfGroupNames(
2220 uploadComponentInstanceInfoMap.getGroups(), preparedResource.getSystemName());
2221 if (validateUpdateVfGroupNamesRes.isRight()) {
2222 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
2224 Map<String, GroupDefinition> groups;
2225 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
2226 groups = validateUpdateVfGroupNamesRes.left().value();
2228 groups = uploadComponentInstanceInfoMap.getGroups();
2230 serviceImportParseLogic.handleGroupsProperties(preparedResource, groups);
2231 preparedResource = serviceImportParseLogic.updateGroupsOnResource(preparedResource, groups);
2232 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToHandle);
2233 Either<Resource, ResponseFormat> updateArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE,
2234 createdArtifacts, yamlFileName, csarInfo, preparedResource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
2235 if (updateArtifactsEither.isRight()) {
2236 log.debug("failed to update artifacts {}", updateArtifactsEither.right().value());
2237 throw new ComponentException(updateArtifactsEither.right().value());
2239 preparedResource = serviceImportParseLogic.getResourceWithGroups(updateArtifactsEither.left().value().getUniqueId());
2240 ActionStatus mergingPropsAndInputsStatus = resourceDataMergeBusinessLogic.mergeResourceEntities(oldRresource, preparedResource);
2241 if (mergingPropsAndInputsStatus != ActionStatus.OK) {
2242 ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(mergingPropsAndInputsStatus, preparedResource);
2243 throw new ComponentException(responseFormat);
2245 compositionBusinessLogic.setPositionsForComponentInstances(preparedResource, csarInfo.getModifier().getUserId());
2246 return preparedResource;
2249 protected Resource createResourceFromYaml(Resource resource, String topologyTemplateYaml, String yamlName,
2250 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
2251 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
2252 boolean shouldLock, boolean inTransaction, String nodeName) {
2253 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
2254 Resource createdResource;
2256 ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic
2257 .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, resource);
2258 if (MapUtils.isEmpty(parsedToscaYamlInfo.getInstances()) && resource.getResourceType() != ResourceTypeEnum.PNF) {
2259 throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2261 log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", resource.getName());
2262 createdResource = createResourceAndRIsFromYaml(yamlName, resource, parsedToscaYamlInfo, AuditingActionEnum.IMPORT_RESOURCE, false,
2263 createdArtifacts, topologyTemplateYaml, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName);
2264 log.debug("#createResourceFromYaml - The resource {} has been created ", resource.getName());
2265 } catch (ComponentException e) {
2266 ResponseFormat responseFormat =
2267 e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
2268 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
2270 } catch (StorageException e) {
2271 ResponseFormat responseFormat = componentsUtils
2272 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
2273 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
2276 return createdResource;
2279 protected Resource createResourceAndRIsFromYaml(String yamlName, Resource resource, ParsedToscaYamlInfo parsedToscaYamlInfo,
2280 AuditingActionEnum actionEnum, boolean isNormative, List<ArtifactDefinition> createdArtifacts,
2281 String topologyTemplateYaml, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
2282 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
2283 boolean shouldLock, boolean inTransaction, String nodeName) {
2284 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
2286 Either<Boolean, ResponseFormat> lockResult = serviceBusinessLogic
2287 .lockComponentByName(resource.getSystemName(), resource, CREATE_RESOURCE);
2288 if (lockResult.isRight()) {
2289 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2290 throw new ComponentException(lockResult.right().value());
2292 log.debug("name is locked {} status = {}", resource.getSystemName(), lockResult);
2295 log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
2296 Resource genericResource = serviceBusinessLogic.fetchAndSetDerivedFromGenericType(resource);
2297 resource = createResourceTransaction(resource, csarInfo.getModifier(), isNormative);
2298 log.trace("************* Going to add inputs from yaml {}", yamlName);
2299 Map<String, Object> yamlMap = ImportUtils.loadYamlAsStrictMap(csarInfo.getMainTemplateContent());
2300 Map<String, Object> metadata = (Map<String, Object>) yamlMap.get("metadata");
2301 String type = (String) metadata.get("type");
2302 if (resource.shouldGenerateInputs() && !"Service".equalsIgnoreCase(type)) {
2303 serviceBusinessLogic.generateAndAddInputsFromGenericTypeProperties(resource, genericResource);
2305 Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
2306 resource = serviceImportParseLogic.createInputsOnResource(resource, inputs);
2307 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances();
2308 resource = createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap, topologyTemplateYaml,
2309 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName);
2310 log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName);
2311 // validate update vf module group names
2312 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic.validateUpdateVfGroupNames(
2313 parsedToscaYamlInfo.getGroups(), resource.getSystemName());
2314 if (validateUpdateVfGroupNamesRes.isRight()) {
2315 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2316 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
2318 Map<String, GroupDefinition> groups;
2319 log.trace("************* Going to add groups from yaml {}", yamlName);
2320 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
2321 groups = validateUpdateVfGroupNamesRes.left().value();
2323 groups = parsedToscaYamlInfo.getGroups();
2325 Either<Resource, ResponseFormat> createGroupsOnResource = createGroupsOnResource(resource, groups);
2326 if (createGroupsOnResource.isRight()) {
2327 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2328 throw new ComponentException(createGroupsOnResource.right().value());
2330 resource = createGroupsOnResource.left().value();
2331 log.trace("************* Going to add artifacts from yaml {}", yamlName);
2332 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
2333 Either<Resource, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
2334 createdArtifacts, yamlName, csarInfo, resource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
2335 if (createArtifactsEither.isRight()) {
2336 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2337 throw new ComponentException(createArtifactsEither.right().value());
2339 resource = serviceImportParseLogic.getResourceWithGroups(createArtifactsEither.left().value().getUniqueId());
2340 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.CREATED);
2341 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, actionEnum);
2342 ASDCKpiApi.countCreatedResourcesKPI();
2344 } catch (ComponentException | StorageException e) {
2345 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
2348 if (!inTransaction) {
2349 janusGraphDao.commit();
2352 graphLockOperation.unlockComponentByName(resource.getSystemName(), resource.getUniqueId(), NodeTypeEnum.Resource);
2357 protected Either<Resource, ResponseFormat> createGroupsOnResource(Resource resource, Map<String, GroupDefinition> groups) {
2358 if (groups != null && !groups.isEmpty()) {
2359 List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, resource);
2360 serviceImportParseLogic.handleGroupsProperties(resource, groups);
2361 serviceImportParseLogic.fillGroupsFinalFields(groupsAsList);
2362 Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic.createGroups(resource, groupsAsList, true);
2363 if (createGroups.isRight()) {
2364 return Either.right(createGroups.right().value());
2367 return Either.left(resource);
2369 Either<Resource, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
2370 if (updatedResource.isRight()) {
2371 ResponseFormat responseFormat = componentsUtils
2372 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), resource);
2373 return Either.right(responseFormat);
2375 return Either.left(updatedResource.left().value());
2378 protected List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups, Resource component) {
2379 List<GroupDefinition> result = new ArrayList<>();
2380 List<ComponentInstance> componentInstances = component.getComponentInstances();
2381 if (groups != null) {
2382 for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
2383 String groupName = entry.getKey();
2384 GroupDefinition groupDefinition = entry.getValue();
2385 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
2386 updatedGroupDefinition.setMembers(null);
2387 Map<String, String> members = groupDefinition.getMembers();
2388 if (members != null) {
2389 updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
2391 result.add(updatedGroupDefinition);
2397 protected void updateGroupMembers(Map<String, GroupDefinition> groups, GroupDefinition updatedGroupDefinition, Resource component,
2398 List<ComponentInstance> componentInstances, String groupName, Map<String, String> members) {
2399 Set<String> compInstancesNames = members.keySet();
2400 if (CollectionUtils.isEmpty(componentInstances)) {
2401 String membersAstString = compInstancesNames.stream().collect(joining(","));
2402 log.debug("The members: {}, in group: {}, cannot be found in component {}. There are no component instances.", membersAstString,
2403 groupName, component.getNormalizedName());
2404 throw new ComponentException(componentsUtils
2405 .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(),
2406 serviceImportParseLogic.getComponentTypeForResponse(component)));
2408 Map<String, String> memberNames = componentInstances.stream().collect(toMap(ComponentInstance::getName, ComponentInstance::getUniqueId));
2409 memberNames.putAll(groups.keySet().stream().collect(toMap(g -> g, g -> "")));
2410 Map<String, String> relevantInstances = memberNames.entrySet().stream().filter(n -> compInstancesNames.contains(n.getKey()))
2411 .collect(toMap(Map.Entry::getKey, Map.Entry::getValue));
2412 if (relevantInstances == null || relevantInstances.size() != compInstancesNames.size()) {
2413 List<String> foundMembers = new ArrayList<>();
2414 if (relevantInstances != null) {
2415 foundMembers = relevantInstances.keySet().stream().collect(toList());
2417 compInstancesNames.removeAll(foundMembers);
2418 String membersAstString = compInstancesNames.stream().collect(joining(","));
2419 throw new ComponentException(componentsUtils
2420 .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(),
2421 serviceImportParseLogic.getComponentTypeForResponse(component)));
2423 updatedGroupDefinition.setMembers(relevantInstances);
2426 protected Resource createResourceTransaction(Resource resource, User user, boolean isNormative) {
2427 Either<Boolean, StorageOperationStatus> eitherValidation = toscaOperationFacade
2428 .validateComponentNameExists(resource.getName(), resource.getResourceType(), resource.getComponentType());
2429 if (eitherValidation.isRight()) {
2430 ResponseFormat errorResponse = componentsUtils
2431 .getResponseFormat(componentsUtils.convertFromStorageResponse(eitherValidation.right().value()));
2432 throw new ComponentException(errorResponse);
2434 if (Boolean.TRUE.equals(eitherValidation.left().value())) {
2435 log.debug("resource with name: {}, already exists", resource.getName());
2436 ResponseFormat errorResponse = componentsUtils
2437 .getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resource.getName());
2438 throw new ComponentException(errorResponse);
2440 log.debug("send resource {} to dao for create", resource.getName());
2441 serviceImportParseLogic.createArtifactsPlaceHolderData(resource, user);
2443 log.debug("enrich resource with creator, version and state");
2444 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2445 resource.setVersion(INITIAL_VERSION);
2446 resource.setHighestVersion(true);
2447 if (resource.getResourceType() != null && resource.getResourceType() != ResourceTypeEnum.VF) {
2448 resource.setAbstract(false);
2451 return toscaOperationFacade.createToscaComponent(resource).left()
2452 .on(r -> serviceImportParseLogic.throwComponentExceptionByResource(r, resource));
2455 protected ImmutablePair<Resource, ActionStatus> updateExistingResourceByImport(Resource newResource, Resource oldResource, User user,
2456 boolean inTransaction, boolean needLock, boolean isNested) {
2457 String lockedResourceId = oldResource.getUniqueId();
2458 log.debug("found resource: name={}, id={}, version={}, state={}", oldResource.getName(), lockedResourceId, oldResource.getVersion(),
2459 oldResource.getLifecycleState());
2460 ImmutablePair<Resource, ActionStatus> resourcePair = null;
2462 serviceBusinessLogic.lockComponent(lockedResourceId, oldResource, needLock, "Update Resource by Import");
2463 oldResource = serviceImportParseLogic.prepareResourceForUpdate(oldResource, newResource, user, inTransaction, false);
2464 serviceImportParseLogic.mergeOldResourceMetadataWithNew(oldResource, newResource);
2465 serviceImportParseLogic.validateResourceFieldsBeforeUpdate(oldResource, newResource, inTransaction, isNested);
2466 serviceImportParseLogic.validateCapabilityTypesCreate(user, serviceImportParseLogic.getCapabilityTypeOperation(), newResource,
2467 AuditingActionEnum.IMPORT_RESOURCE, inTransaction);
2468 createNewResourceToOldResource(newResource, oldResource, user);
2469 Either<Resource, StorageOperationStatus> overrideResource = toscaOperationFacade.overrideComponent(newResource, oldResource);
2470 if (overrideResource.isRight()) {
2471 ResponseFormat responseFormat = new ResponseFormat();
2472 serviceBusinessLogic.throwComponentException(responseFormat);
2474 log.debug("Resource updated successfully!!!");
2475 resourcePair = new ImmutablePair<>(overrideResource.left().value(), ActionStatus.OK);
2476 return resourcePair;
2478 if (resourcePair == null) {
2479 BeEcompErrorManager.getInstance().logBeSystemError("Change LifecycleState - Certify");
2480 janusGraphDao.rollback();
2481 } else if (!inTransaction) {
2482 janusGraphDao.commit();
2485 log.debug("unlock resource {}", lockedResourceId);
2486 graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource);
2491 protected void createNewResourceToOldResource(Resource newResource, Resource oldResource, User user) {
2492 newResource.setContactId(newResource.getContactId().toLowerCase());
2493 newResource.setCreatorUserId(user.getUserId());
2494 newResource.setCreatorFullName(user.getFullName());
2495 newResource.setLastUpdaterUserId(user.getUserId());
2496 newResource.setLastUpdaterFullName(user.getFullName());
2497 newResource.setUniqueId(oldResource.getUniqueId());
2498 newResource.setVersion(oldResource.getVersion());
2499 newResource.setInvariantUUID(oldResource.getInvariantUUID());
2500 newResource.setLifecycleState(oldResource.getLifecycleState());
2501 newResource.setUUID(oldResource.getUUID());
2502 newResource.setNormalizedName(oldResource.getNormalizedName());
2503 newResource.setSystemName(oldResource.getSystemName());
2504 if (oldResource.getCsarUUID() != null) {
2505 newResource.setCsarUUID(oldResource.getCsarUUID());
2507 if (oldResource.getCsarVersionId() != null) {
2508 newResource.setCsarVersionId(oldResource.getCsarVersionId());
2510 if (oldResource.getImportedToscaChecksum() != null) {
2511 newResource.setImportedToscaChecksum(oldResource.getImportedToscaChecksum());
2513 if (newResource.getDerivedFromGenericType() == null || newResource.getDerivedFromGenericType().isEmpty()) {
2514 newResource.setDerivedFromGenericType(oldResource.getDerivedFromGenericType());
2516 if (newResource.getDerivedFromGenericVersion() == null || newResource.getDerivedFromGenericVersion().isEmpty()) {
2517 newResource.setDerivedFromGenericVersion(oldResource.getDerivedFromGenericVersion());
2519 if (newResource.getToscaArtifacts() == null || newResource.getToscaArtifacts().isEmpty()) {
2520 serviceBusinessLogic.setToscaArtifactsPlaceHolders(newResource, user);
2522 if (newResource.getInterfaces() == null || newResource.getInterfaces().isEmpty()) {
2523 newResource.setInterfaces(oldResource.getInterfaces());
2525 if (CollectionUtils.isEmpty(newResource.getProperties())) {
2526 newResource.setProperties(oldResource.getProperties());
2528 if (newResource.getModel() == null) {
2529 newResource.setModel(oldResource.getModel());
2533 protected Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Service service, Map<String, Object> mappedToscaTemplate,
2535 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2536 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
2537 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
2539 Either<String, ImportUtils.ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
2540 TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
2541 if (toscaVersion.isRight()) {
2542 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
2544 Map<String, Object> mapToConvert = new HashMap<>();
2545 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value());
2546 Map<String, Object> nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate);
2547 createNodeTypes(yamlName, service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
2548 mapToConvert, nodeTypes);
2549 return csarInfo.getCreatedNodes();
2550 } catch (Exception e) {
2551 log.debug("Exception occured when createResourcesFromYamlNodeTypesList,error is:{}", e.getMessage(), e);
2552 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2556 protected void createNodeTypes(String yamlName, Service service, boolean needLock,
2557 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2558 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
2559 Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
2560 Iterator<Map.Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet().iterator();
2561 Resource vfcCreated = null;
2562 while (nodesNameValueIter.hasNext()) {
2563 Map.Entry<String, Object> nodeType = nodesNameValueIter.next();
2564 String nodeTypeKey = nodeType.getKey();
2565 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle =
2566 nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeTypeKey);
2567 if (nodeTypesInfo.containsKey(nodeTypeKey)) {
2568 vfcCreated = handleNestedVfc(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
2570 log.trace("************* Finished to handle nested vfc {}", nodeTypeKey);
2571 } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames()
2572 .containsKey(nodeTypeKey)) {
2573 ImmutablePair<Resource, ActionStatus> resourceCreated = serviceImportParseLogic
2574 .createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(), mapToConvert, service, needLock,
2575 nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true);
2576 log.debug("************* Finished to create node {}", nodeTypeKey);
2577 vfcCreated = resourceCreated.getLeft();
2578 csarInfo.getCreatedNodesToscaResourceNames().put(nodeTypeKey, vfcCreated.getName());
2580 if (vfcCreated != null) {
2581 csarInfo.getCreatedNodes().put(nodeTypeKey, vfcCreated);
2583 mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());