2 * Copyright (C) 2020 CMCC, Inc. and others. All rights reserved.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
16 package org.openecomp.sdc.be.components.impl;
18 import static java.util.stream.Collectors.joining;
19 import static java.util.stream.Collectors.toList;
20 import static java.util.stream.Collectors.toMap;
21 import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
22 import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaMapElement;
23 import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaStringElement;
24 import static org.openecomp.sdc.be.components.impl.ImportUtils.getPropertyJsonStringValue;
25 import static org.openecomp.sdc.be.tosca.CsarUtils.VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN;
27 import com.google.gson.Gson;
28 import com.google.gson.JsonElement;
29 import com.google.gson.JsonObject;
30 import com.google.gson.JsonParser;
31 import fj.data.Either;
32 import java.util.ArrayList;
33 import java.util.Collection;
34 import java.util.Collections;
35 import java.util.EnumMap;
36 import java.util.HashMap;
37 import java.util.HashSet;
38 import java.util.Iterator;
39 import java.util.LinkedHashMap;
40 import java.util.List;
42 import java.util.Map.Entry;
43 import java.util.Optional;
45 import java.util.TreeSet;
46 import java.util.concurrent.atomic.AtomicBoolean;
47 import java.util.concurrent.atomic.AtomicReference;
48 import java.util.regex.Pattern;
49 import java.util.stream.Collectors;
52 import org.apache.commons.collections.CollectionUtils;
53 import org.apache.commons.collections.MapUtils;
54 import org.apache.commons.lang3.StringUtils;
55 import org.apache.commons.lang3.tuple.ImmutablePair;
56 import org.json.simple.JSONObject;
57 import org.openecomp.sdc.be.components.csar.CsarArtifactsAndGroupsBusinessLogic;
58 import org.openecomp.sdc.be.components.csar.CsarBusinessLogic;
59 import org.openecomp.sdc.be.components.csar.CsarInfo;
60 import org.openecomp.sdc.be.components.csar.ServiceCsarInfo;
61 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
62 import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
63 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
64 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
65 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
66 import org.openecomp.sdc.be.components.impl.model.ToscaTypeImportData;
67 import org.openecomp.sdc.be.components.impl.utils.CINodeFilterUtils;
68 import org.openecomp.sdc.be.components.impl.utils.CreateServiceFromYamlParameter;
69 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
70 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
71 import org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic;
72 import org.openecomp.sdc.be.config.BeEcompErrorManager;
73 import org.openecomp.sdc.be.config.ConfigurationManager;
74 import org.openecomp.sdc.be.dao.api.ActionStatus;
75 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
76 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
77 import org.openecomp.sdc.be.datamodel.utils.ArtifactUtils;
78 import org.openecomp.sdc.be.datatypes.elements.CustomYamlFunction;
79 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
80 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
81 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
82 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
83 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
84 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
85 import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition;
86 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
87 import org.openecomp.sdc.be.datatypes.elements.SubPropertyToscaFunction;
88 import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterPropertyDataDefinition;
89 import org.openecomp.sdc.be.datatypes.elements.ToscaGetFunctionDataDefinition;
90 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
91 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
92 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
93 import org.openecomp.sdc.be.datatypes.tosca.ToscaGetFunctionType;
94 import org.openecomp.sdc.be.impl.ComponentsUtils;
95 import org.openecomp.sdc.be.info.NodeTypeInfoToUpdateArtifacts;
96 import org.openecomp.sdc.be.model.ArtifactDefinition;
97 import org.openecomp.sdc.be.model.ArtifactTypeDefinition;
98 import org.openecomp.sdc.be.model.AttributeDefinition;
99 import org.openecomp.sdc.be.model.CapabilityDefinition;
100 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
101 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
102 import org.openecomp.sdc.be.model.Component;
103 import org.openecomp.sdc.be.model.ComponentInstance;
104 import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
105 import org.openecomp.sdc.be.model.ComponentInstanceInput;
106 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
107 import org.openecomp.sdc.be.model.ComponentParametersView;
108 import org.openecomp.sdc.be.model.DataTypeDefinition;
109 import org.openecomp.sdc.be.model.DistributionStatusEnum;
110 import org.openecomp.sdc.be.model.GroupDefinition;
111 import org.openecomp.sdc.be.model.GroupTypeDefinition;
112 import org.openecomp.sdc.be.model.InputDefinition;
113 import org.openecomp.sdc.be.model.InterfaceDefinition;
114 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
115 import org.openecomp.sdc.be.model.LifecycleStateEnum;
116 import org.openecomp.sdc.be.model.NodeTypeDefinition;
117 import org.openecomp.sdc.be.model.NodeTypeInfo;
118 import org.openecomp.sdc.be.model.NodeTypeMetadata;
119 import org.openecomp.sdc.be.model.NodeTypesMetadataList;
120 import org.openecomp.sdc.be.model.Operation;
121 import org.openecomp.sdc.be.model.OutputDefinition;
122 import org.openecomp.sdc.be.model.ParsedToscaYamlInfo;
123 import org.openecomp.sdc.be.model.PolicyDefinition;
124 import org.openecomp.sdc.be.model.PropertyDefinition;
125 import org.openecomp.sdc.be.model.RelationshipImpl;
126 import org.openecomp.sdc.be.model.RelationshipInfo;
127 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
128 import org.openecomp.sdc.be.model.RequirementDefinition;
129 import org.openecomp.sdc.be.model.Resource;
130 import org.openecomp.sdc.be.model.Service;
131 import org.openecomp.sdc.be.model.UploadAttributeInfo;
132 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
133 import org.openecomp.sdc.be.model.UploadInterfaceInfo;
134 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
135 import org.openecomp.sdc.be.model.UploadPropInfo;
136 import org.openecomp.sdc.be.model.UploadReqInfo;
137 import org.openecomp.sdc.be.model.UploadResourceInfo;
138 import org.openecomp.sdc.be.model.User;
139 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
140 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
141 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
142 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
143 import org.openecomp.sdc.be.model.normatives.ToscaTypeMetadata;
144 import org.openecomp.sdc.be.model.operations.StorageException;
145 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
146 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
147 import org.openecomp.sdc.be.model.operations.impl.ArtifactTypeOperation;
148 import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
149 import org.openecomp.sdc.be.model.operations.impl.GroupTypeOperation;
150 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
151 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
152 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
153 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
154 import org.openecomp.sdc.be.tosca.CsarUtils;
155 import org.openecomp.sdc.be.tosca.ToscaExportHandler;
156 import org.openecomp.sdc.be.ui.model.OperationUi;
157 import org.openecomp.sdc.be.utils.TypeUtils;
158 import org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum;
159 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
160 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
161 import org.openecomp.sdc.common.api.Constants;
162 import org.openecomp.sdc.common.datastructure.Wrapper;
163 import org.openecomp.sdc.common.kpi.api.ASDCKpiApi;
164 import org.openecomp.sdc.common.log.wrappers.Logger;
165 import org.openecomp.sdc.common.util.ValidationUtils;
166 import org.openecomp.sdc.exception.ResponseFormat;
167 import org.springframework.beans.factory.annotation.Autowired;
168 import org.yaml.snakeyaml.Yaml;
172 @org.springframework.stereotype.Component("serviceImportBusinessLogic")
173 public class ServiceImportBusinessLogic {
175 protected static final String CREATE_RESOURCE = "Create Resource";
176 private static final String INITIAL_VERSION = "0.1";
177 private static final String IN_RESOURCE = " in resource {} ";
178 private static final String COMPONENT_INSTANCE_WITH_NAME = "component instance with name ";
179 private static final String COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE = "component instance with name {} in resource {} ";
180 private static final String CERTIFICATION_ON_IMPORT = "certification on import";
181 private static final String VALIDATE_DERIVED_BEFORE_UPDATE = "validate derived before update";
182 private static final String PLACE_HOLDER_RESOURCE_TYPES = "validForResourceTypes";
183 private static final String CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES = "Create Resource - validateCapabilityTypesCreate";
184 private static final String CATEGORY_IS_EMPTY = "Resource category is empty";
185 private static final Logger log = Logger.getLogger(ServiceImportBusinessLogic.class);
187 private final ComponentsUtils componentsUtils;
188 private final ToscaOperationFacade toscaOperationFacade;
189 private final ServiceBusinessLogic serviceBusinessLogic;
190 private final CsarBusinessLogic csarBusinessLogic;
191 private final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic;
192 private final LifecycleBusinessLogic lifecycleBusinessLogic;
193 private final CompositionBusinessLogic compositionBusinessLogic;
194 private final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic;
195 private final ServiceImportParseLogic serviceImportParseLogic;
196 private final GroupBusinessLogic groupBusinessLogic;
197 private final PolicyBusinessLogic policyBusinessLogic;
198 private final ResourceImportManager resourceImportManager;
199 private final JanusGraphDao janusGraphDao;
200 private final ArtifactsBusinessLogic artifactsBusinessLogic;
201 private final ArtifactTypeImportManager artifactTypeImportManager;
202 private final IGraphLockOperation graphLockOperation;
203 private final ToscaFunctionService toscaFunctionService;
204 private final DataTypeBusinessLogic dataTypeBusinessLogic;
205 private ApplicationDataTypeCache applicationDataTypeCache;
206 private final ArtifactTypeOperation artifactTypeOperation;
208 private final GroupTypeImportManager groupTypeImportManager;
209 private final GroupTypeOperation groupTypeOperation;
210 private InterfaceLifecycleOperation interfaceLifecycleTypeOperation;
211 private InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager;
213 private final CapabilityTypeImportManager capabilityTypeImportManager;
214 private final CapabilityTypeOperation capabilityTypeOperation;
216 public ServiceImportBusinessLogic(final GroupBusinessLogic groupBusinessLogic, final ArtifactsBusinessLogic artifactsBusinessLogic,
217 final ComponentsUtils componentsUtils, final ToscaOperationFacade toscaOperationFacade,
218 final ServiceBusinessLogic serviceBusinessLogic, final CsarBusinessLogic csarBusinessLogic,
219 final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic,
220 final LifecycleBusinessLogic lifecycleBusinessLogic, final CompositionBusinessLogic compositionBusinessLogic,
221 final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic,
222 final ServiceImportParseLogic serviceImportParseLogic, final PolicyBusinessLogic policyBusinessLogic,
223 final ResourceImportManager resourceImportManager, final JanusGraphDao janusGraphDao,
224 final IGraphLockOperation graphLockOperation, final ToscaFunctionService toscaFunctionService,
225 final DataTypeBusinessLogic dataTypeBusinessLogic, final ArtifactTypeOperation artifactTypeOperation,
226 final ArtifactTypeImportManager artifactTypeImportManager, final GroupTypeImportManager groupTypeImportManager,
227 final GroupTypeOperation groupTypeOperation,
228 final InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
229 final InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager,
230 final CapabilityTypeImportManager capabilityTypeImportManager,
231 final CapabilityTypeOperation capabilityTypeOperation) {
232 this.componentsUtils = componentsUtils;
233 this.toscaOperationFacade = toscaOperationFacade;
234 this.serviceBusinessLogic = serviceBusinessLogic;
235 this.csarBusinessLogic = csarBusinessLogic;
236 this.csarArtifactsAndGroupsBusinessLogic = csarArtifactsAndGroupsBusinessLogic;
237 this.lifecycleBusinessLogic = lifecycleBusinessLogic;
238 this.compositionBusinessLogic = compositionBusinessLogic;
239 this.resourceDataMergeBusinessLogic = resourceDataMergeBusinessLogic;
240 this.serviceImportParseLogic = serviceImportParseLogic;
241 this.groupBusinessLogic = groupBusinessLogic;
242 this.policyBusinessLogic = policyBusinessLogic;
243 this.resourceImportManager = resourceImportManager;
244 this.janusGraphDao = janusGraphDao;
245 this.artifactsBusinessLogic = artifactsBusinessLogic;
246 this.graphLockOperation = graphLockOperation;
247 this.toscaFunctionService = toscaFunctionService;
248 this.dataTypeBusinessLogic = dataTypeBusinessLogic;
249 this.artifactTypeOperation = artifactTypeOperation;
250 this.artifactTypeImportManager = artifactTypeImportManager;
251 this.groupTypeImportManager = groupTypeImportManager;
252 this.groupTypeOperation = groupTypeOperation;
253 this.interfaceLifecycleTypeOperation = interfaceLifecycleTypeOperation;
254 this.interfaceLifecycleTypeImportManager = interfaceLifecycleTypeImportManager;
255 this.capabilityTypeImportManager = capabilityTypeImportManager;
256 this.capabilityTypeOperation = capabilityTypeOperation;
260 public void setApplicationDataTypeCache(ApplicationDataTypeCache applicationDataTypeCache) {
261 this.applicationDataTypeCache = applicationDataTypeCache;
264 public Service createService(Service service, AuditingActionEnum auditingAction, User user, Map<String, byte[]> csarUIPayload,
265 String payloadName) {
266 log.debug("enter createService");
267 service.setCreatorUserId(user.getUserId());
268 service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
269 service.setVersion(INITIAL_VERSION);
270 service.setConformanceLevel(ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel());
271 service.setDistributionStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
273 final var serviceBeforeCreate = serviceBusinessLogic.validateServiceBeforeCreate(service, user, auditingAction);
274 if (serviceBeforeCreate.isRight()) {
275 throw new ComponentException(ActionStatus.GENERAL_ERROR);
277 log.debug("enter createService,validateServiceBeforeCreate success");
278 String csarUUID = payloadName == null ? service.getCsarUUID() : payloadName;
279 log.debug("enter createService,get csarUUID:{}", csarUUID);
280 csarBusinessLogic.validateCsarBeforeCreate(service, csarUUID);
281 log.debug("CsarUUID is {} - going to create resource from CSAR", csarUUID);
282 return createServiceFromCsar(service, user, csarUIPayload, csarUUID);
283 } catch (final ComponentException e) {
284 log.debug("Exception occurred when createService: {}", e.getMessage(), e);
286 } catch (final Exception e) {
287 log.debug("Exception occurred when createService: {}", e.getMessage(), e);
288 throw new ComponentException(ActionStatus.GENERAL_ERROR);
292 protected Service createServiceFromCsar(Service service, User user, Map<String, byte[]> csarUIPayload, String csarUUID) {
293 log.trace("************* created successfully from YAML, resource TOSCA ");
295 final ServiceCsarInfo csarInfo = csarBusinessLogic.getCsarInfo(service, null, user, csarUIPayload, csarUUID);
296 final String serviceModel = service.getModel();
297 final Map<String, Object> dataTypesToCreate = getDatatypesToCreate(serviceModel, csarInfo);
298 if (MapUtils.isNotEmpty(dataTypesToCreate)) {
299 dataTypeBusinessLogic.createDataTypeFromYaml(new Yaml().dump(dataTypesToCreate), serviceModel, true);
300 dataTypesToCreate.keySet().forEach(key ->
301 applicationDataTypeCache.reload(serviceModel, UniqueIdBuilder.buildDataTypeUid(serviceModel, key))
305 final Map<String, Object> artifactTypesToCreate = getArtifactTypesToCreate(serviceModel, csarInfo);
306 if (MapUtils.isNotEmpty(artifactTypesToCreate)) {
307 artifactTypeImportManager.createArtifactTypes(new Yaml().dump(artifactTypesToCreate), serviceModel, true);
310 final List<NodeTypeDefinition> nodeTypesToCreate = getNodeTypesToCreate(serviceModel, csarInfo);
311 if (CollectionUtils.isNotEmpty(nodeTypesToCreate)) {
312 createNodeTypes(nodeTypesToCreate, serviceModel, csarInfo.getModifier());
315 final Map<String, Object> groupTypesToCreate = getGroupTypesToCreate(serviceModel, csarInfo);
316 if (MapUtils.isNotEmpty(groupTypesToCreate)) {
317 final Map<String, ToscaTypeMetadata> toscaTypeMetadata = fillToscaTypeMetadata(groupTypesToCreate);
318 final ToscaTypeImportData toscaTypeImportData = new ToscaTypeImportData(new Yaml().dump(groupTypesToCreate), toscaTypeMetadata);
319 groupTypeImportManager.createGroupTypes(toscaTypeImportData, serviceModel, true);
322 final Map<String, Object> interfaceTypesToCreate = getInterfaceTypesToCreate(serviceModel, csarInfo);
323 if (MapUtils.isNotEmpty(interfaceTypesToCreate)) {
324 interfaceLifecycleTypeImportManager.createLifecycleTypes(new Yaml().dump(interfaceTypesToCreate), serviceModel, true);
327 final Map<String, Object> capabilityTypesToCreate = getCapabilityTypesToCreate(serviceModel, csarInfo);
329 if (MapUtils.isNotEmpty(capabilityTypesToCreate)) {
330 capabilityTypeImportManager.createCapabilityTypes(new Yaml().dump(capabilityTypesToCreate), serviceModel, true);
333 Map<String, NodeTypeInfo> nodeTypesInfo = csarInfo.extractTypesInfo();
334 Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandleRes
335 = serviceImportParseLogic.findNodeTypesArtifactsToHandle(nodeTypesInfo, csarInfo, service);
336 if (findNodeTypesArtifactsToHandleRes.isRight()) {
337 log.debug("failed to find node types for update with artifacts during import csar {}. ", csarInfo.getCsarUUID());
338 throw new ComponentException(findNodeTypesArtifactsToHandleRes.right().value());
340 return createServiceFromYaml(service, csarInfo.getMainTemplateContent(), csarInfo.getMainTemplateName(), nodeTypesInfo, csarInfo,
341 findNodeTypesArtifactsToHandleRes.left().value(), true, false, null, user.getUserId());
342 } catch (final ComponentException e) {
343 log.debug("Exception occurred when createServiceFromCsar,error is:{}", e.getMessage(), e);
345 } catch (final Exception e) {
346 log.debug("Exception occurred when createServiceFromCsar,error is:{}", e.getMessage(), e);
347 throw new ComponentException(ActionStatus.GENERAL_ERROR);
351 private Map<String, ToscaTypeMetadata> fillToscaTypeMetadata(final Map<String, Object> groupTypesToCreate) {
352 final Map<String, ToscaTypeMetadata> toscaTypeMetadata = new HashMap<>();
353 groupTypesToCreate.entrySet().forEach(entry -> {
354 final ToscaTypeMetadata metadata = new ToscaTypeMetadata();
355 metadata.setIcon(getIconFromGroupType(entry.getValue()));
356 metadata.setDisplayName(extractDisplayName(entry.getKey()));
357 toscaTypeMetadata.put(entry.getKey(), metadata);
359 return toscaTypeMetadata;
362 private String extractDisplayName(final String key) {
363 final String[] split = key.split("\\.");
364 return split[split.length - 1];
367 private String getIconFromGroupType(final Object value) {
368 final Either<GroupTypeDefinition, StorageOperationStatus> groupType = groupTypeOperation.getLatestGroupTypeByType(
369 (String) ((LinkedHashMap) value).get(ToscaTagNamesEnum.DERIVED_FROM.getElementName()), null);
370 if (groupType.isLeft()) {
371 return groupType.left().value().getIcon();
376 private Map<String, Object> getGroupTypesToCreate(final String model, final CsarInfo csarInfo) {
377 final Map<String, Object> groupTypesToCreate = new HashMap<>();
378 final Map<String, Object> groupTypes = csarInfo.getGroupTypes();
379 if (MapUtils.isNotEmpty(groupTypes)) {
380 for (final Entry<String, Object> entry : groupTypes.entrySet()) {
381 final Either<GroupTypeDefinition, StorageOperationStatus> result
382 = groupTypeOperation.getGroupTypeByUid(UniqueIdBuilder.buildGroupTypeUid(model, entry.getKey(), "1.0"));
383 if (result.isRight() && result.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
384 groupTypesToCreate.put(entry.getKey(), entry.getValue());
385 log.info("Deploying new group type {} to model {} from package {}", entry.getKey(), model, csarInfo.getCsarUUID());
389 return groupTypesToCreate;
392 private Map<String, Object> getCapabilityTypesToCreate(final String model, final CsarInfo csarInfo) {
393 final Map<String, Object> capabilityTypesToCreate = new HashMap<>();
394 final Map<String, Object> capabilityTypes = csarInfo.getCapabilityTypes();
395 if (MapUtils.isNotEmpty(capabilityTypes)) {
396 for (final Entry<String, Object> entry : capabilityTypes.entrySet()) {
397 final Either<CapabilityTypeDefinition, StorageOperationStatus> result
398 = capabilityTypeOperation.getCapabilityType(UniqueIdBuilder.buildCapabilityTypeUid(model, entry.getKey()));
399 if (result.isRight() && result.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
400 capabilityTypesToCreate.put(entry.getKey(), entry.getValue());
401 log.info("Deploying new capability type {} to model {} from package {}", entry.getKey(), model, csarInfo.getCsarUUID());
405 return capabilityTypesToCreate;
408 private Map<String, Object> getDatatypesToCreate(final String model, final CsarInfo csarInfo) {
409 final Map<String, Object> dataTypesToCreate = new HashMap<>();
411 for (final Entry<String, Object> dataTypeEntry : csarInfo.getDataTypes().entrySet()) {
412 final Either<DataTypeDefinition, JanusGraphOperationStatus> result = applicationDataTypeCache.get(model,
413 UniqueIdBuilder.buildDataTypeUid(model, dataTypeEntry.getKey()));
414 if (result.isRight() && result.right().value().equals(JanusGraphOperationStatus.NOT_FOUND)) {
415 dataTypesToCreate.put(dataTypeEntry.getKey(), dataTypeEntry.getValue());
416 log.info("Deploying unknown type {} to model {} from package {}", dataTypeEntry.getKey(), model, csarInfo.getCsarUUID());
418 if (hasNewProperties(result, (Map<String, Map<String, Object>>) dataTypeEntry.getValue())) {
419 dataTypesToCreate.put(dataTypeEntry.getKey(), dataTypeEntry.getValue());
420 log.info("Deploying new version of type {} to model {} from package {}", dataTypeEntry.getKey(), model, csarInfo.getCsarUUID());
423 return dataTypesToCreate;
426 private Map<String, Object> getArtifactTypesToCreate(final String model, final CsarInfo csarInfo) {
427 final Map<String, Object> artifactTypesToCreate = new HashMap<>();
428 final Map<String, Object> artifactTypesMap = csarInfo.getArtifactTypes();
429 if (MapUtils.isNotEmpty(artifactTypesMap)) {
430 for (final Entry<String, Object> artifactTypeEntry : artifactTypesMap.entrySet()) {
431 final Either<ArtifactTypeDefinition, StorageOperationStatus> result =
432 artifactTypeOperation.getArtifactTypeByUid(UniqueIdBuilder.buildArtifactTypeUid(model, artifactTypeEntry.getKey()));
433 if (result.isRight() && StorageOperationStatus.NOT_FOUND.equals(result.right().value())) {
434 artifactTypesToCreate.put(artifactTypeEntry.getKey(), artifactTypeEntry.getValue());
435 log.info("Deploying new artifact type={}, to model={}, from package={}",
436 artifactTypeEntry.getKey(), model, csarInfo.getCsarUUID());
440 return artifactTypesToCreate;
443 private Map<String, Object> getInterfaceTypesToCreate(final String model, final CsarInfo csarInfo) {
444 final Map<String, Object> interfaceTypesToCreate = new HashMap<>();
445 Map<String, Object> interfacetypeMap = csarInfo.getInterfaceTypes();
447 interfacetypeMap.entrySet().forEach(interfacetypeDef -> {
448 Either<InterfaceDefinition, StorageOperationStatus> interfaceDefinition =
449 interfaceLifecycleTypeOperation.getInterface(UniqueIdBuilder.buildInterfaceTypeUid(model, interfacetypeDef.getKey()));
450 if (interfaceDefinition.isRight() && interfaceDefinition.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
451 interfaceTypesToCreate.put(interfacetypeDef.getKey(), interfacetypeDef.getValue());
454 return interfaceTypesToCreate;
457 private boolean hasNewProperties(final Either<DataTypeDefinition, JanusGraphOperationStatus> result,
458 final Map<String, Map<String, Object>> dataType) {
459 return result.isLeft() && dataType.containsKey("properties") && result.left().value().getProperties() != null
460 && result.left().value().getProperties().size() != dataType.get("properties").size();
463 private void createNodeTypes(List<NodeTypeDefinition> nodeTypesToCreate, String model, User user) {
464 NodeTypesMetadataList nodeTypesMetadataList = new NodeTypesMetadataList();
465 List<NodeTypeMetadata> nodeTypeMetadataList = new ArrayList<>();
466 final Map<String, Object> allTypesToCreate = new HashMap<>();
467 nodeTypesToCreate.forEach(nodeType -> {
468 allTypesToCreate.put(nodeType.getMappedNodeType().getKey(), nodeType.getMappedNodeType().getValue());
469 nodeTypeMetadataList.add(nodeType.getNodeTypeMetadata());
471 nodeTypesMetadataList.setNodeMetadataList(nodeTypeMetadataList);
472 resourceImportManager.importAllNormativeResource(allTypesToCreate, nodeTypesMetadataList, user, model, true, false);
475 private List<NodeTypeDefinition> getNodeTypesToCreate(final String model, final ServiceCsarInfo csarInfo) {
476 List<NodeTypeDefinition> namesOfNodeTypesToCreate = new ArrayList<>();
478 for (final NodeTypeDefinition nodeTypeDefinition : csarInfo.getNodeTypesUsed()) {
479 Either<Component, StorageOperationStatus> result = toscaOperationFacade
480 .getLatestByToscaResourceName(nodeTypeDefinition.getMappedNodeType().getKey(), model);
481 if (result.isRight() && result.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
482 namesOfNodeTypesToCreate.add(nodeTypeDefinition);
483 } else if (result.isLeft()) {
484 Resource latestResource = (Resource) result.left().value();
485 Entry<String, Object> existingMappedToscaTemplate = getResourceToscaTemplate(latestResource.getUniqueId(),
486 latestResource.getToscaArtifacts().get(ToscaExportHandler.ASSET_TOSCA_TEMPLATE), csarInfo.getModifier().getUserId());
487 Map<String, Object> newMappedToscaTemplate = (Map<String, Object>) nodeTypeDefinition.getMappedNodeType().getValue();
488 Map<String, Object> combinedMappedToscaTemplate =
489 getNewChangesToToscaTemplate(newMappedToscaTemplate, (Map<String, Object>) existingMappedToscaTemplate.getValue());
490 if (!combinedMappedToscaTemplate.equals(existingMappedToscaTemplate.getValue())) {
491 if (latestResource.getComponentMetadataDefinition().getMetadataDataDefinition().isNormative()) {
492 nodeTypeDefinition.getNodeTypeMetadata().setNormative(true);
494 existingMappedToscaTemplate.setValue(combinedMappedToscaTemplate);
495 nodeTypeDefinition.setMappedNodeType(existingMappedToscaTemplate);
496 namesOfNodeTypesToCreate.add(nodeTypeDefinition);
500 return namesOfNodeTypesToCreate;
503 private Entry<String, Object> getResourceToscaTemplate(String uniqueId, ArtifactDefinition assetToscaTemplate, String userId) {
504 String assetToToscaTemplate = assetToscaTemplate.getUniqueId();
505 ImmutablePair<String, byte[]> toscaTemplate = artifactsBusinessLogic.
506 handleDownloadRequestById(uniqueId, assetToToscaTemplate, userId, ComponentTypeEnum.RESOURCE, null, null);
507 Map<String, Object> mappedToscaTemplate = new Yaml().load(new String(toscaTemplate.right));
508 Either<Map<String, Object>, ImportUtils.ResultStatusEnum> eitherNodeTypes =
509 findFirstToscaMapElement(mappedToscaTemplate, TypeUtils.ToscaTagNamesEnum.NODE_TYPES);
510 if (eitherNodeTypes.isRight()) {
511 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
513 return eitherNodeTypes.left().value().entrySet().iterator().next();
516 private Map<String, Object> getNewChangesToToscaTemplate(Map<String, Object> newMappedToscaTemplate,
517 Map<String, Object> existingMappedToscaTemplate) {
518 Map<String, Object> combinedMappedToscaTemplate = new HashMap<>(existingMappedToscaTemplate);
519 combinePropertiesIntoToscaTemplate((Map<String, Object>) newMappedToscaTemplate.get("properties"),
520 (Map<String, Object>) existingMappedToscaTemplate.get("properties"), combinedMappedToscaTemplate);
521 combineAttributesIntoToscaTemplate((Map<String, Object>) newMappedToscaTemplate.get("attributes"),
522 (Map<String, Object>) existingMappedToscaTemplate.get("attributes"), combinedMappedToscaTemplate);
523 combineRequirementsIntoToscaTemplate((List<Map<String, Object>>) newMappedToscaTemplate.get("requirements"),
524 (List<Map<String, Object>>) existingMappedToscaTemplate.get("requirements"), combinedMappedToscaTemplate);
525 combineCapabilitiesIntoToscaTemplate((Map<String, Object>) newMappedToscaTemplate.get("capabilities"),
526 (Map<String, Object>) existingMappedToscaTemplate.get("capabilities"), combinedMappedToscaTemplate);
527 combineInterfacesIntoToscaTemplate((Map<String, Map<String, Object>>) newMappedToscaTemplate.get("interfaces"),
528 (Map<String, Map<String, Object>>) existingMappedToscaTemplate.get("interfaces"), combinedMappedToscaTemplate);
529 return combinedMappedToscaTemplate;
532 private void combineInterfacesIntoToscaTemplate(Map<String, Map<String, Object>> newInterfaces,
533 Map<String, Map<String, Object>> existingInterfaces,
534 Map<String, Object> combinedMappedToscaTemplate) {
535 Map<String, Map<String, Object>> combinedInterfaces = combineAdditionalInterfaces(existingInterfaces, newInterfaces);
536 if ((MapUtils.isEmpty(existingInterfaces) && MapUtils.isNotEmpty(combinedInterfaces))
537 || (MapUtils.isNotEmpty(existingInterfaces) && !existingInterfaces.equals(combinedInterfaces))) {
538 combinedMappedToscaTemplate.put("interfaces", combinedInterfaces);
542 private void combineCapabilitiesIntoToscaTemplate(Map<String, Object> newCapabilities, Map<String, Object> existingCapabilities,
543 Map<String, Object> combinedMappedToscaTemplate) {
544 Map<String, Object> combinedCapabilities = combineEntries(newCapabilities, existingCapabilities);
545 if ((MapUtils.isEmpty(existingCapabilities) && MapUtils.isNotEmpty(combinedCapabilities)) ||
546 (MapUtils.isNotEmpty(existingCapabilities) && !combinedCapabilities.equals(existingCapabilities))) {
547 combinedMappedToscaTemplate.put("capabilities", combinedCapabilities);
551 private void combineRequirementsIntoToscaTemplate(List<Map<String, Object>> newRequirements, List<Map<String, Object>> existingRequirements,
552 Map<String, Object> combinedMappedToscaTemplate) {
553 List<Map<String, Object>> combinedRequirements = combineAdditionalRequirements(newRequirements, existingRequirements);
554 if ((CollectionUtils.isEmpty(existingRequirements) && CollectionUtils.isNotEmpty(combinedRequirements))
555 || (CollectionUtils.isNotEmpty(existingRequirements) && !combinedRequirements.equals(existingRequirements))) {
556 combinedMappedToscaTemplate.put("requirements", combinedRequirements);
560 private void combineAttributesIntoToscaTemplate(Map<String, Object> newAttributes, Map<String, Object> existingAttributes,
561 Map<String, Object> combinedMappedToscaTemplate) {
562 Map<String, Object> combinedAttributes = combineEntries(newAttributes, existingAttributes);
563 if ((MapUtils.isEmpty(existingAttributes) && MapUtils.isNotEmpty(combinedAttributes)) ||
564 (MapUtils.isNotEmpty(existingAttributes) && !combinedAttributes.equals(existingAttributes))) {
565 combinedMappedToscaTemplate.put("attributes", combinedAttributes);
569 private void combinePropertiesIntoToscaTemplate(Map<String, Object> newProperties, Map<String, Object> existingProperties,
570 Map<String, Object> combinedMappedToscaTemplate) {
571 Map<String, Object> combinedProperties = combineEntries(newProperties, existingProperties);
572 if ((MapUtils.isEmpty(existingProperties) && MapUtils.isNotEmpty(combinedProperties)) ||
573 (MapUtils.isNotEmpty(existingProperties) && !combinedProperties.equals(existingProperties))) {
574 combinedMappedToscaTemplate.put("properties", combinedProperties);
578 private Map<String, Map<String, Object>> combineAdditionalInterfaces(Map<String, Map<String, Object>> existingInterfaces,
579 Map<String, Map<String, Object>> newInterfaces) {
580 if (MapUtils.isEmpty(newInterfaces)) {
581 newInterfaces = new HashMap<>();
583 Map<String, Map<String, Object>> combinedEntries = new HashMap<>(newInterfaces);
584 if (MapUtils.isEmpty(existingInterfaces)) {
585 return combinedEntries;
587 existingInterfaces.entrySet().forEach(interfaceDef -> {
588 combinedEntries.entrySet().stream().filter((interFace) -> interFace.getValue().get("type").equals((interfaceDef.getValue()).get("type")))
589 .findFirst().ifPresentOrElse((interFace) -> {
590 interFace.getValue().putAll(interfaceDef.getValue());
592 combinedEntries.put(interfaceDef.getKey(), interfaceDef.getValue());
595 return combinedEntries;
598 private List<Map<String, Object>> combineAdditionalRequirements(List<Map<String, Object>> newReqs,
599 List<Map<String, Object>> existingResourceReqs) {
600 if (CollectionUtils.isEmpty(existingResourceReqs)) {
601 existingResourceReqs = new ArrayList<>();
603 Set<Map<String, Object>> combinedReqs = new TreeSet<>((map1, map2) ->
604 map1.keySet().equals(map2.keySet()) ? 0 : map1.keySet().iterator().next().compareTo(map2.keySet().iterator().next()));
605 combinedReqs.addAll(existingResourceReqs);
606 if (CollectionUtils.isEmpty(newReqs)) {
607 return new ArrayList<>(combinedReqs);
609 combinedReqs.addAll(newReqs);
610 return new ArrayList<>(combinedReqs);
613 private Map<String, Object> combineEntries(Map<String, Object> newMap, Map<String, Object> existingMap) {
614 if (MapUtils.isEmpty(newMap)) {
615 newMap = new HashMap<>();
617 Map<String, Object> combinedEntries = new HashMap<>(newMap);
618 if (MapUtils.isEmpty(existingMap)) {
619 return combinedEntries;
621 combinedEntries.putAll(existingMap);
622 return combinedEntries;
625 protected Service createServiceFromYaml(Service service, String topologyTemplateYaml, String yamlName, Map<String, NodeTypeInfo> nodeTypesInfo,
627 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
628 boolean shouldLock, boolean inTransaction, String nodeName, final String userId)
629 throws BusinessLogicException {
630 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
631 Service createdService;
632 CreateServiceFromYamlParameter csfyp = new CreateServiceFromYamlParameter();
634 ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic
635 .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, service);
636 log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", service.getName());
637 csfyp.setYamlName(yamlName);
638 csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
639 csfyp.setCreatedArtifacts(createdArtifacts);
640 csfyp.setTopologyTemplateYaml(topologyTemplateYaml);
641 csfyp.setNodeTypesInfo(nodeTypesInfo);
642 csfyp.setCsarInfo(csarInfo);
643 csfyp.setNodeName(nodeName);
644 createdService = createServiceAndRIsFromYaml(service, false, nodeTypesArtifactsToCreate, shouldLock, inTransaction, csfyp, userId);
645 log.debug("#createResourceFromYaml - The resource {} has been created ", service.getName());
646 } catch (ComponentException | BusinessLogicException e) {
647 log.debug("Create Service from yaml failed", e);
649 } catch (StorageException e) {
650 log.debug("create Service From Yaml failed,get StorageException:{}", e);
653 return createdService;
656 protected Service createServiceAndRIsFromYaml(Service service, boolean isNormative,
657 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
658 boolean shouldLock, boolean inTransaction, CreateServiceFromYamlParameter csfyp,
660 throws BusinessLogicException {
661 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
662 String yamlName = csfyp.getYamlName();
663 ParsedToscaYamlInfo parsedToscaYamlInfo = csfyp.getParsedToscaYamlInfo();
664 List<ArtifactDefinition> createdArtifacts = csfyp.getCreatedArtifacts();
665 String topologyTemplateYaml = csfyp.getTopologyTemplateYaml();
666 Map<String, NodeTypeInfo> nodeTypesInfo = csfyp.getNodeTypesInfo();
667 CsarInfo csarInfo = csfyp.getCsarInfo();
668 String nodeName = csfyp.getNodeName();
670 Either<Boolean, ResponseFormat> lockResult = serviceBusinessLogic.lockComponentByName(service.getSystemName(), service, CREATE_RESOURCE);
671 if (lockResult.isRight()) {
672 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
673 throw new ComponentException(lockResult.right().value());
675 log.debug("name is locked {} status = {}", service.getSystemName(), lockResult);
677 boolean rollback = false;
679 log.trace("************* Adding properties to service from interface yaml {}", yamlName);
680 Map<String, PropertyDefinition> properties = parsedToscaYamlInfo.getProperties();
681 if (properties != null && !properties.isEmpty()) {
682 final List<PropertyDefinition> propertiesList = new ArrayList<>();
683 properties.forEach((propertyName, propertyDefinition) -> {
684 propertyDefinition.setName(propertyName);
685 propertiesList.add(propertyDefinition);
687 service.setProperties(propertiesList);
689 log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
690 service = serviceImportParseLogic.createServiceTransaction(service, csarInfo.getModifier(), isNormative);
691 log.trace("************* Going to add inputs from yaml {}", yamlName);
692 Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
693 service = serviceImportParseLogic.createInputsOnService(service, inputs);
694 log.trace("************* Finished to add inputs from yaml {}", yamlName);
695 ListDataDefinition<SubstitutionFilterPropertyDataDefinition> substitutionFilterProperties = parsedToscaYamlInfo.getSubstitutionFilterProperties();
696 service = serviceImportParseLogic.createSubstitutionFilterOnService(service, substitutionFilterProperties);
697 log.trace("************* Added Substitution filter from interface yaml {}", yamlName);
698 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances();
699 log.trace("************* Going to create nodes, RI's and Relations from yaml {}", yamlName);
700 service = createRIAndRelationsFromYaml(yamlName, service, uploadComponentInstanceInfoMap, topologyTemplateYaml,
701 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName);
702 log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName);
703 log.trace("************* Going to add outputs from yaml {}", yamlName);
704 Map<String, OutputDefinition> outputs = parsedToscaYamlInfo.getOutputs();
705 service = serviceImportParseLogic.createOutputsOnService(service, outputs, userId);
706 log.trace("************* Finished to add outputs from yaml {}", yamlName);
708 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes
709 = groupBusinessLogic.validateUpdateVfGroupNames(parsedToscaYamlInfo.getGroups(), service.getSystemName());
710 if (validateUpdateVfGroupNamesRes.isRight()) {
711 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
712 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
714 Map<String, GroupDefinition> groups;
715 log.trace("************* Going to add groups from yaml {}", yamlName);
716 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
717 groups = validateUpdateVfGroupNamesRes.left().value();
719 groups = parsedToscaYamlInfo.getGroups();
721 Either<Service, ResponseFormat> createGroupsOnResource = createGroupsOnResource(service, groups);
722 if (createGroupsOnResource.isRight()) {
723 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
724 throw new ComponentException(createGroupsOnResource.right().value());
726 service = createGroupsOnResource.left().value();
728 Either<Service, ResponseFormat> createPoliciesOnResource = createPoliciesOnResource(service, parsedToscaYamlInfo.getPolicies());
729 if (createPoliciesOnResource.isRight()) {
730 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
731 throw new ComponentException(createPoliciesOnResource.right().value());
733 service = createPoliciesOnResource.left().value();
734 log.trace("************* Going to add artifacts from yaml {}", yamlName);
735 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
736 Either<Service, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
737 createdArtifacts, yamlName, csarInfo, service, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
738 if (createArtifactsEither.isRight()) {
739 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
740 throw new ComponentException(createArtifactsEither.right().value());
742 service = serviceImportParseLogic.getServiceWithGroups(createArtifactsEither.left().value().getUniqueId());
743 service = updateInputs(service, userId, parsedToscaYamlInfo.getSubstitutionMappingProperties());
745 ASDCKpiApi.countCreatedResourcesKPI();
747 } catch (ComponentException | StorageException | BusinessLogicException e) {
749 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
752 if (!inTransaction) {
754 janusGraphDao.rollback();
756 janusGraphDao.commit();
760 graphLockOperation.unlockComponentByName(service.getSystemName(), service.getUniqueId(), NodeTypeEnum.Service);
765 private Service updateInputs(final Service component, final String userId, final Map<String, List<String>> substitutionMappingProperties) {
766 final List<InputDefinition> inputs = component.getInputs();
767 if (CollectionUtils.isNotEmpty(inputs)) {
768 final List<ComponentInstance> componentInstances = component.getComponentInstances();
769 final String componentUniqueId = component.getUniqueId();
770 for (final InputDefinition input : inputs) {
771 if (isInputFromComponentInstanceProperty(input.getName(), componentInstances)) {
772 associateInputToComponentInstanceProperty(userId, input, componentInstances, componentUniqueId);
774 associateInputToServiceProperty(userId, input, component, substitutionMappingProperties);
778 Either<List<InputDefinition>, StorageOperationStatus> either = toscaOperationFacade.updateInputsToComponent(inputs, componentUniqueId);
779 if (either.isRight()) {
780 throw new ComponentException(ActionStatus.GENERAL_ERROR);
787 private boolean isInputFromComponentInstanceProperty(final String inputName, final List<ComponentInstance> componentInstances) {
789 AtomicBoolean isInputFromCIProp = new AtomicBoolean(false);
790 if (CollectionUtils.isNotEmpty(componentInstances)) {
791 outer: for (ComponentInstance instance : componentInstances) {
792 for (PropertyDefinition instanceProperty : instance.getProperties()) {
793 if (CollectionUtils.isNotEmpty(instanceProperty.getGetInputValues())) {
794 for (GetInputValueDataDefinition getInputValueDataDefinition : instanceProperty.getGetInputValues()) {
795 if (inputName.equals(getInputValueDataDefinition.getInputName())) {
796 isInputFromCIProp.set(true);
804 return isInputFromCIProp.get();
807 private void associateInputToComponentInstanceProperty(final String userId, final InputDefinition input,
808 final List<ComponentInstance> componentInstances,
809 String componentUniqueId) {
811 String componentInstanceId = null;
812 ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
814 outer: for (ComponentInstance instance : componentInstances) {
815 for (PropertyDefinition instanceProperty : instance.getProperties()) {
816 if (CollectionUtils.isNotEmpty(instanceProperty.getGetInputValues())) {
817 for (GetInputValueDataDefinition getInputValueDataDefinition : instanceProperty.getGetInputValues()) {
818 if (input.getName().equals(getInputValueDataDefinition.getInputName())) {
819 componentInstanceId = instance.getUniqueId();
820 componentInstanceProperty = new ComponentInstanceProperty(instanceProperty);
828 //unmapping instance property declared inputs from substitution mapping
829 input.setMappedToComponentProperty(false);
832 updateInput(input, componentInstanceProperty, userId, componentInstanceId);
834 final Either<Map<String, List<ComponentInstanceProperty>>, StorageOperationStatus> either =
835 toscaOperationFacade.updateComponentInstancePropsToComponent(Collections.singletonMap(componentInstanceId,
836 Collections.singletonList(componentInstanceProperty)), componentUniqueId);
837 if (either.isRight()) {
838 throw new ComponentException(ActionStatus.GENERAL_ERROR);
842 private void associateInputToServiceProperty(final String userId,
843 final InputDefinition input, final Service component,
844 final Map<String, List<String>> substitutionMappingProperties) {
845 final List<PropertyDefinition> properties = component.getProperties();
846 if (CollectionUtils.isNotEmpty(properties) && MapUtils.isNotEmpty(substitutionMappingProperties)) {
847 AtomicReference<String> propertyNameFromInput = new AtomicReference<>(" ");
848 substitutionMappingProperties.entrySet().forEach(stringEntry -> {
849 if (stringEntry.getValue().get(0).equals(input.getName())) {
850 propertyNameFromInput.set(stringEntry.getKey());
854 final Optional<PropertyDefinition> propDefOptional = properties.stream().filter(prop -> prop.getName().equals(propertyNameFromInput.get()))
856 if (propDefOptional.isPresent()) {
858 final String componentUniqueId = component.getUniqueId();
859 final PropertyDefinition propertyDefinition = propDefOptional.get();
860 updateProperty(propertyDefinition, input, componentUniqueId);
861 final JSONObject jsonObject = new JSONObject();
862 jsonObject.put(ToscaGetFunctionType.GET_INPUT.getFunctionName(), input.getName());
863 propertyDefinition.setValue(jsonObject.toJSONString());
864 updateInput(input, propertyDefinition, userId, componentUniqueId);
866 final Either<PropertyDefinition, StorageOperationStatus> either
867 = toscaOperationFacade.updatePropertyOfComponent(component, propertyDefinition);
868 if (either.isRight()) {
869 throw new ComponentException(ActionStatus.GENERAL_ERROR);
875 private void updateProperty(final PropertyDefinition propertyDefinition, final InputDefinition input, final String componentUniqueId) {
876 propertyDefinition.setParentUniqueId(componentUniqueId);
877 final GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
878 getInputValueDataDefinition.setInputId(input.getUniqueId());
879 getInputValueDataDefinition.setInputName(input.getName());
880 getInputValueDataDefinition.setPropName(propertyDefinition.getName());
881 propertyDefinition.setGetInputValues(Collections.singletonList(getInputValueDataDefinition));
884 private void updateInput(final InputDefinition input, final PropertyDefinition propertyDefinition,
885 final String userId, final String componentUniqueId) {
886 input.setProperties(Collections.singletonList(new ComponentInstanceProperty(propertyDefinition)));
887 input.setInstanceUniqueId(componentUniqueId);
888 input.setOwnerId(userId);
889 input.setPropertyId(propertyDefinition.getUniqueId());
890 input.setParentPropertyType(propertyDefinition.getType());
893 protected Either<Resource, ResponseFormat> createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum operation,
894 List<ArtifactDefinition> createdArtifacts, String yamlFileName,
895 CsarInfo csarInfo, Resource preparedResource,
896 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
897 boolean inTransaction, boolean shouldLock) {
898 String nodeName = nodeTypeInfoToUpdateArtifacts.getNodeName();
899 Resource resource = preparedResource;
900 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = nodeTypeInfoToUpdateArtifacts
901 .getNodeTypesArtifactsToHandle();
902 if (preparedResource.getResourceType() == ResourceTypeEnum.VF) {
903 if (nodeName != null && nodeTypesArtifactsToHandle.get(nodeName) != null && !nodeTypesArtifactsToHandle.get(nodeName).isEmpty()) {
904 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = handleNodeTypeArtifacts(preparedResource,
905 nodeTypesArtifactsToHandle.get(nodeName), createdArtifacts, csarInfo.getModifier(), inTransaction, true);
906 if (handleNodeTypeArtifactsRes.isRight()) {
907 return Either.right(handleNodeTypeArtifactsRes.right().value());
911 Either<Resource, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedResource, csarInfo, createdArtifacts,
912 new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction);
913 log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
914 if (createdCsarArtifactsEither.isRight()) {
915 return createdCsarArtifactsEither;
917 resource = createdCsarArtifactsEither.left().value();
919 return Either.left(resource);
922 protected Either<Resource, ResponseFormat> handleVfCsarArtifacts(Resource resource, CsarInfo csarInfo, List<ArtifactDefinition> createdArtifacts,
923 ArtifactOperationInfo artifactOperation, boolean shouldLock,
924 boolean inTransaction) {
925 if (csarInfo.getCsar() != null) {
926 createOrUpdateSingleNonMetaArtifactToComstants(resource, csarInfo, artifactOperation, shouldLock, inTransaction);
927 Either<Resource, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, resource, createdArtifacts, shouldLock,
928 inTransaction, artifactOperation);
929 if (eitherCreateResult.isRight()) {
930 return Either.right(eitherCreateResult.right().value());
932 Either<Resource, StorageOperationStatus> eitherGerResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
933 if (eitherGerResource.isRight()) {
934 ResponseFormat responseFormat = componentsUtils
935 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), resource);
936 return Either.right(responseFormat);
938 resource = eitherGerResource.left().value();
939 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
940 .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
941 if (artifacsMetaCsarStatus.isLeft()) {
942 return getResourceResponseFormatEither(resource, csarInfo, createdArtifacts, artifactOperation, shouldLock, inTransaction,
943 artifacsMetaCsarStatus);
945 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(resource, csarInfo, shouldLock, inTransaction);
948 return Either.left(resource);
951 protected void createOrUpdateSingleNonMetaArtifactToComstants(Resource resource, CsarInfo csarInfo, ArtifactOperationInfo artifactOperation,
952 boolean shouldLock, boolean inTransaction) {
953 String vendorLicenseModelId = null;
954 String vfLicenseModelId = null;
955 if (artifactOperation.getArtifactOperationEnum() == ArtifactOperationEnum.UPDATE) {
956 Map<String, ArtifactDefinition> deploymentArtifactsMap = resource.getDeploymentArtifacts();
957 if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
958 for (Map.Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
959 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
960 vendorLicenseModelId = artifactEntry.getValue().getUniqueId();
962 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
963 vfLicenseModelId = artifactEntry.getValue().getUniqueId();
968 createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL,
969 Constants.VENDOR_LICENSE_MODEL, ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
970 Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME, Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId,
971 artifactOperation, null, true, shouldLock, inTransaction);
972 createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
973 ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL, Constants.VF_LICENSE_DISPLAY_NAME,
974 Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId, artifactOperation, null, true, shouldLock, inTransaction);
977 private Either<Resource, ResponseFormat> getResourceResponseFormatEither(Resource resource, CsarInfo csarInfo,
978 List<ArtifactDefinition> createdArtifacts,
979 ArtifactOperationInfo artifactOperation, boolean shouldLock,
980 boolean inTransaction,
981 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus) {
983 String artifactsFileName = artifacsMetaCsarStatus.left().value().getKey();
984 String artifactsContents = artifacsMetaCsarStatus.left().value().getValue();
985 Either<Resource, ResponseFormat> createArtifactsFromCsar;
986 if (ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
987 createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic
988 .createResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts);
990 Either<Component, ResponseFormat> result = csarArtifactsAndGroupsBusinessLogic
991 .updateResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
993 if ((result.left().value() instanceof Resource) && result.isLeft()) {
994 Resource service1 = (Resource) result.left().value();
995 createArtifactsFromCsar = Either.left(service1);
997 createArtifactsFromCsar = Either.right(result.right().value());
1000 if (createArtifactsFromCsar.isRight()) {
1001 log.debug("Couldn't create artifacts from artifacts.meta");
1002 return Either.right(createArtifactsFromCsar.right().value());
1004 return Either.left(createArtifactsFromCsar.left().value());
1005 } catch (Exception e) {
1006 log.debug("Exception occured in getResourceResponseFormatEither, message:{}", e.getMessage(), e);
1007 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1011 private <T extends Component> Either<T, ResponseFormat> createOrUpdateNonMetaArtifactsComp(CsarInfo csarInfo, T component,
1012 List<ArtifactDefinition> createdArtifacts,
1013 boolean shouldLock, boolean inTransaction,
1014 ArtifactOperationInfo artifactOperation) {
1015 Either<T, ResponseFormat> resStatus = null;
1016 Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
1018 Either<List<CsarUtils.NonMetaArtifactInfo>, String> artifactPathAndNameList = getValidArtifactNames(csarInfo, collectedWarningMessages);
1019 if (artifactPathAndNameList.isRight()) {
1020 return Either.right(
1021 getComponentsUtils().getResponseFormatByArtifactId(ActionStatus.ARTIFACT_NAME_INVALID, artifactPathAndNameList.right().value()));
1023 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = null;
1024 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
1025 vfCsarArtifactsToHandle = new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
1026 vfCsarArtifactsToHandle.put(artifactOperation.getArtifactOperationEnum(), artifactPathAndNameList.left().value());
1028 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandleRes = findVfCsarArtifactsToHandle(
1029 component, artifactPathAndNameList.left().value(), csarInfo.getModifier());
1030 if (findVfCsarArtifactsToHandleRes.isRight()) {
1031 resStatus = Either.right(findVfCsarArtifactsToHandleRes.right().value());
1033 if (resStatus == null) {
1034 vfCsarArtifactsToHandle = findVfCsarArtifactsToHandleRes.left().value();
1037 if (resStatus == null && vfCsarArtifactsToHandle != null) {
1038 resStatus = processCsarArtifacts(csarInfo, component, createdArtifacts, shouldLock, inTransaction, resStatus,
1039 vfCsarArtifactsToHandle);
1041 if (resStatus == null) {
1042 resStatus = Either.left(component);
1044 } catch (Exception e) {
1045 resStatus = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1046 log.debug("Exception occured in createNonMetaArtifacts, message:{}", e.getMessage(), e);
1048 CsarUtils.handleWarningMessages(collectedWarningMessages);
1053 protected Either<Resource, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Resource resource,
1054 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
1055 boolean inTransaction, ArtifactOperationInfo artifactOperation) {
1056 return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation);
1059 protected <T extends Component> Either<T, ResponseFormat> processCsarArtifacts(CsarInfo csarInfo, Component comp,
1060 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
1061 boolean inTransaction, Either<T, ResponseFormat> resStatus,
1062 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle) {
1063 for (Map.Entry<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> currArtifactOperationPair : vfCsarArtifactsToHandle
1065 Optional<ResponseFormat> optionalCreateInDBError = currArtifactOperationPair.getValue().stream().map(
1066 e -> createOrUpdateSingleNonMetaArtifact(comp, csarInfo, e.getPath(), e.getArtifactName(), e.getArtifactType(),
1067 e.getArtifactGroupType(), e.getArtifactLabel(), e.getDisplayName(), CsarUtils.ARTIFACT_CREATED_FROM_CSAR, e.getArtifactUniqueId(),
1068 new ArtifactOperationInfo(false, false, currArtifactOperationPair.getKey()), createdArtifacts, e.isFromCsar(), shouldLock,
1069 inTransaction)).filter(Either::isRight).map(e -> e.right().value()).findAny();
1070 if (optionalCreateInDBError.isPresent()) {
1071 resStatus = Either.right(optionalCreateInDBError.get());
1078 protected Either<Boolean, ResponseFormat> createOrUpdateSingleNonMetaArtifact(Component component, CsarInfo csarInfo, String artifactPath,
1079 String artifactFileName, String artifactType,
1080 ArtifactGroupTypeEnum artifactGroupType, String artifactLabel,
1081 String artifactDisplayName, String artifactDescription,
1082 String artifactId, ArtifactOperationInfo operation,
1083 List<ArtifactDefinition> createdArtifacts, boolean isFromCsar,
1084 boolean shouldLock, boolean inTransaction) {
1085 byte[] artifactFileBytes = null;
1086 if (csarInfo.getCsar().containsKey(artifactPath)) {
1087 artifactFileBytes = csarInfo.getCsar().get(artifactPath);
1089 Either<Boolean, ResponseFormat> result = Either.left(true);
1090 if (operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE
1091 || operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE) {
1092 if (serviceImportParseLogic.isArtifactDeletionRequired(artifactId, artifactFileBytes, isFromCsar)) {
1093 Either<ArtifactDefinition, ResponseFormat> handleDelete = artifactsBusinessLogic
1094 .handleDelete(component.getUniqueId(), artifactId, csarInfo.getModifier(), component, shouldLock, inTransaction);
1095 if (handleDelete.isRight()) {
1096 result = Either.right(handleDelete.right().value());
1100 if (org.apache.commons.lang.StringUtils.isEmpty(artifactId) && artifactFileBytes != null) {
1101 operation = new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
1104 if (artifactFileBytes != null) {
1105 Map<String, Object> vendorLicenseModelJson = ArtifactUtils
1106 .buildJsonForUpdateArtifact(artifactId, artifactFileName, artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
1107 artifactDescription, artifactFileBytes, null, isFromCsar);
1108 Either<Either<ArtifactDefinition, Operation>, ResponseFormat> eitherNonMetaArtifacts = csarArtifactsAndGroupsBusinessLogic
1109 .createOrUpdateCsarArtifactFromJson(component, csarInfo.getModifier(), vendorLicenseModelJson, operation);
1110 serviceImportParseLogic.addNonMetaCreatedArtifactsToSupportRollback(operation, createdArtifacts, eitherNonMetaArtifacts);
1111 if (eitherNonMetaArtifacts.isRight()) {
1112 BeEcompErrorManager.getInstance().logInternalFlowError("UploadLicenseArtifact",
1113 "Failed to upload license artifact: " + artifactFileName + "With csar uuid: " + csarInfo.getCsarUUID(),
1114 BeEcompErrorManager.ErrorSeverity.WARNING);
1115 return Either.right(eitherNonMetaArtifacts.right().value());
1121 private Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifacts(Resource nodeTypeResource,
1122 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
1123 List<ArtifactDefinition> createdArtifacts, User user,
1124 boolean inTransaction, boolean ignoreLifecycleState) {
1125 List<ArtifactDefinition> handleNodeTypeArtifactsRequestRes;
1126 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = null;
1127 Either<Resource, ResponseFormat> changeStateResponse;
1129 changeStateResponse = checkoutResource(nodeTypeResource, user, inTransaction);
1130 if (changeStateResponse.isRight()) {
1131 return Either.right(changeStateResponse.right().value());
1133 nodeTypeResource = changeStateResponse.left().value();
1134 List<ArtifactDefinition> handledNodeTypeArtifacts = new ArrayList<>();
1135 log.debug("************* Going to handle artifacts of node type resource {}. ", nodeTypeResource.getName());
1136 for (Map.Entry<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> curOperationEntry : nodeTypeArtifactsToHandle
1138 ArtifactsBusinessLogic.ArtifactOperationEnum curOperation = curOperationEntry.getKey();
1139 List<ArtifactDefinition> curArtifactsToHandle = curOperationEntry.getValue();
1140 if (curArtifactsToHandle != null && !curArtifactsToHandle.isEmpty()) {
1141 log.debug("************* Going to {} artifact to vfc {}", curOperation.name(), nodeTypeResource.getName());
1142 handleNodeTypeArtifactsRequestRes = artifactsBusinessLogic
1143 .handleArtifactsRequestForInnerVfcComponent(curArtifactsToHandle, nodeTypeResource, user, createdArtifacts,
1144 new ArtifactOperationInfo(false, ignoreLifecycleState, curOperation), false, inTransaction);
1145 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(curOperation)) {
1146 createdArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
1148 handledNodeTypeArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
1151 handleNodeTypeArtifactsRes = Either.left(handledNodeTypeArtifacts);
1152 } catch (Exception e) {
1153 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1154 handleNodeTypeArtifactsRes = Either.right(responseFormat);
1155 log.debug("Exception occured when handleVfcArtifacts, error is:{}", e.getMessage(), e);
1157 return handleNodeTypeArtifactsRes;
1160 private Either<Resource, ResponseFormat> checkoutResource(Resource resource, User user, boolean inTransaction) {
1161 Either<Resource, ResponseFormat> checkoutResourceRes;
1163 if (!resource.getComponentMetadataDefinition().getMetadataDataDefinition().getState()
1164 .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
1165 Either<? extends Component, ResponseFormat> checkoutRes = lifecycleBusinessLogic
1166 .changeComponentState(resource.getComponentType(), resource.getUniqueId(), user, LifeCycleTransitionEnum.CHECKOUT,
1167 new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
1168 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR), inTransaction, true);
1169 if (checkoutRes.isRight()) {
1170 checkoutResourceRes = Either.right(checkoutRes.right().value());
1172 checkoutResourceRes = Either.left((Resource) checkoutRes.left().value());
1175 checkoutResourceRes = Either.left(resource);
1177 } catch (Exception e) {
1178 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1179 checkoutResourceRes = Either.right(responseFormat);
1180 log.debug("Exception occured when checkoutResource {} , error is:{}", resource.getName(), e.getMessage(), e);
1182 return checkoutResourceRes;
1185 protected Either<Service, ResponseFormat> createOrUpdateArtifacts(ArtifactOperationEnum operation, List<ArtifactDefinition> createdArtifacts,
1186 String yamlFileName, CsarInfo csarInfo, Service preparedService,
1187 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
1188 boolean inTransaction, boolean shouldLock) {
1189 Either<Service, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedService, csarInfo, createdArtifacts,
1190 new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction);
1191 log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
1192 if (createdCsarArtifactsEither.isRight()) {
1193 return createdCsarArtifactsEither;
1195 return Either.left(createdCsarArtifactsEither.left().value());
1198 protected Either<Service, ResponseFormat> handleVfCsarArtifacts(Service service, CsarInfo csarInfo, List<ArtifactDefinition> createdArtifacts,
1199 ArtifactOperationInfo artifactOperation, boolean shouldLock,
1200 boolean inTransaction) {
1201 if (csarInfo.getCsar() != null) {
1202 String vendorLicenseModelId = null;
1203 String vfLicenseModelId = null;
1204 if (artifactOperation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE) {
1205 Map<String, ArtifactDefinition> deploymentArtifactsMap = service.getDeploymentArtifacts();
1206 if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
1207 for (Map.Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
1208 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
1209 vendorLicenseModelId = artifactEntry.getValue().getUniqueId();
1211 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
1212 vfLicenseModelId = artifactEntry.getValue().getUniqueId();
1217 createOrUpdateSingleNonMetaArtifact(service, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL,
1218 Constants.VENDOR_LICENSE_MODEL, ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
1219 Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME, Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId,
1220 artifactOperation, null, true, shouldLock, inTransaction);
1221 createOrUpdateSingleNonMetaArtifact(service, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
1222 ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL,
1223 Constants.VF_LICENSE_DISPLAY_NAME, Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId, artifactOperation, null, true, shouldLock,
1225 Either<Service, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, service, createdArtifacts, shouldLock,
1226 inTransaction, artifactOperation);
1227 if (eitherCreateResult.isRight()) {
1228 return Either.right(eitherCreateResult.right().value());
1230 Either<Service, StorageOperationStatus> eitherGerResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
1231 if (eitherGerResource.isRight()) {
1232 ResponseFormat responseFormat = componentsUtils
1233 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), service,
1234 ComponentTypeEnum.SERVICE);
1235 return Either.right(responseFormat);
1237 service = eitherGerResource.left().value();
1238 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
1239 .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
1240 if (artifacsMetaCsarStatus.isLeft()) {
1241 String artifactsFileName = artifacsMetaCsarStatus.left().value().getKey();
1242 String artifactsContents = artifacsMetaCsarStatus.left().value().getValue();
1243 Either<Service, ResponseFormat> createArtifactsFromCsar;
1244 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
1245 createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic
1246 .createResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts);
1248 Either<Component, ResponseFormat> result = csarArtifactsAndGroupsBusinessLogic
1249 .updateResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
1251 if ((result.left().value() instanceof Service) && result.isLeft()) {
1252 Service service1 = (Service) result.left().value();
1253 createArtifactsFromCsar = Either.left(service1);
1255 createArtifactsFromCsar = Either.right(result.right().value());
1258 if (createArtifactsFromCsar.isRight()) {
1259 log.debug("Couldn't create artifacts from artifacts.meta");
1260 return Either.right(createArtifactsFromCsar.right().value());
1262 return Either.left(createArtifactsFromCsar.left().value());
1264 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(service, csarInfo, shouldLock, inTransaction);
1267 return Either.left(service);
1270 protected Either<Service, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Service resource,
1271 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
1272 boolean inTransaction, ArtifactOperationInfo artifactOperation) {
1273 return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation);
1276 protected Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandle(
1277 Component component, List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList, User user) {
1278 List<ArtifactDefinition> existingArtifacts = new ArrayList<>();
1279 if (component.getDeploymentArtifacts() != null && !component.getDeploymentArtifacts().isEmpty()) {
1280 existingArtifacts.addAll(component.getDeploymentArtifacts().values());
1282 if (component.getArtifacts() != null && !component.getArtifacts().isEmpty()) {
1283 existingArtifacts.addAll(component.getArtifacts().values());
1285 existingArtifacts = existingArtifacts.stream().filter(this::isNonMetaArtifact).collect(toList());
1286 List<String> artifactsToIgnore = new ArrayList<>();
1287 if (component.getGroups() != null) {
1288 component.getGroups().forEach(g -> {
1289 if (g.getArtifacts() != null && !g.getArtifacts().isEmpty()) {
1290 artifactsToIgnore.addAll(g.getArtifacts());
1294 existingArtifacts = existingArtifacts.stream().filter(a -> !artifactsToIgnore.contains(a.getUniqueId())).collect(toList());
1295 return organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifacts, component, user);
1298 private boolean isNonMetaArtifact(ArtifactDefinition artifact) {
1299 boolean result = true;
1300 if (artifact.getMandatory() || artifact.getArtifactName() == null || !isValidArtifactType(artifact)) {
1306 private boolean isValidArtifactType(ArtifactDefinition artifact) {
1307 final String artifactType = artifact.getArtifactType();
1308 return artifactType != null
1309 && !ArtifactTypeEnum.VENDOR_LICENSE.getType().equals(ArtifactTypeEnum.findType(artifactType))
1310 && !ArtifactTypeEnum.VF_LICENSE.getType().equals(ArtifactTypeEnum.findType(artifactType));
1313 protected Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> organizeVfCsarArtifactsByArtifactOperation(
1314 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList, List<ArtifactDefinition> existingArtifactsToHandle, Component component,
1316 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> nodeTypeArtifactsToHandle = new EnumMap<>(
1317 ArtifactsBusinessLogic.ArtifactOperationEnum.class);
1318 Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
1319 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> nodeTypeArtifactsToHandleRes = Either
1320 .left(nodeTypeArtifactsToHandle);
1322 List<CsarUtils.NonMetaArtifactInfo> artifactsToUpload = new ArrayList<>(artifactPathAndNameList);
1323 List<CsarUtils.NonMetaArtifactInfo> artifactsToUpdate = new ArrayList<>();
1324 List<CsarUtils.NonMetaArtifactInfo> artifactsToDelete = new ArrayList<>();
1325 for (CsarUtils.NonMetaArtifactInfo currNewArtifact : artifactPathAndNameList) {
1326 ArtifactDefinition foundArtifact;
1327 if (!existingArtifactsToHandle.isEmpty()) {
1328 foundArtifact = existingArtifactsToHandle.stream().filter(a -> a.getArtifactName().equals(currNewArtifact.getArtifactName()))
1329 .findFirst().orElse(null);
1330 if (foundArtifact != null) {
1331 if (ArtifactTypeEnum.findType(foundArtifact.getArtifactType()).equals(currNewArtifact.getArtifactType())) {
1332 if (!foundArtifact.getArtifactChecksum().equals(currNewArtifact.getArtifactChecksum())) {
1333 currNewArtifact.setArtifactUniqueId(foundArtifact.getUniqueId());
1334 artifactsToUpdate.add(currNewArtifact);
1336 existingArtifactsToHandle.remove(foundArtifact);
1337 artifactsToUpload.remove(currNewArtifact);
1339 log.debug("Can't upload two artifact with the same name {}.", currNewArtifact.getArtifactName());
1340 ResponseFormat responseFormat = ResponseFormatManager.getInstance()
1341 .getResponseFormat(ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, currNewArtifact.getArtifactName(),
1342 currNewArtifact.getArtifactType(), foundArtifact.getArtifactType());
1343 AuditingActionEnum auditingAction = artifactsBusinessLogic.detectAuditingType(
1344 new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE),
1345 foundArtifact.getArtifactChecksum());
1346 artifactsBusinessLogic.handleAuditing(auditingAction, component, component.getUniqueId(), user, null, null,
1347 foundArtifact.getUniqueId(), responseFormat, component.getComponentType(), null);
1348 responseWrapper.setInnerElement(responseFormat);
1354 if (responseWrapper.isEmpty()) {
1355 for (ArtifactDefinition currArtifact : existingArtifactsToHandle) {
1356 if (currArtifact.getIsFromCsar()) {
1357 artifactsToDelete.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
1358 ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null,
1359 currArtifact.getUniqueId(), currArtifact.getIsFromCsar()));
1361 artifactsToUpdate.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
1362 ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null,
1363 currArtifact.getUniqueId(), currArtifact.getIsFromCsar()));
1367 if (responseWrapper.isEmpty()) {
1368 if (!artifactsToUpload.isEmpty()) {
1369 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, artifactsToUpload);
1371 if (!artifactsToUpdate.isEmpty()) {
1372 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE, artifactsToUpdate);
1374 if (!artifactsToDelete.isEmpty()) {
1375 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE, artifactsToDelete);
1378 if (!responseWrapper.isEmpty()) {
1379 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
1381 } catch (Exception e) {
1382 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1383 responseWrapper.setInnerElement(responseFormat);
1384 log.debug("Exception occured when findNodeTypeArtifactsToHandle, error is:{}", e.getMessage(), e);
1385 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
1387 return nodeTypeArtifactsToHandleRes;
1390 protected Either<List<CsarUtils.NonMetaArtifactInfo>, String> getValidArtifactNames(CsarInfo csarInfo,
1391 Map<String, Set<List<String>>> collectedWarningMessages) {
1392 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = csarInfo.getCsar().entrySet().stream()
1393 .filter(e -> Pattern.compile(VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN).matcher(e.getKey()).matches())
1394 .map(e -> CsarUtils.validateNonMetaArtifact(e.getKey(), e.getValue(), collectedWarningMessages)).filter(Either::isLeft)
1395 .map(e -> e.left().value()).collect(toList());
1396 Pattern englishNumbersAndUnderScoresOnly = Pattern.compile(CsarUtils.VALID_ENGLISH_ARTIFACT_NAME);
1397 for (CsarUtils.NonMetaArtifactInfo nonMetaArtifactInfo : artifactPathAndNameList) {
1398 if (!englishNumbersAndUnderScoresOnly.matcher(nonMetaArtifactInfo.getDisplayName()).matches()) {
1399 return Either.right(nonMetaArtifactInfo.getArtifactName());
1402 return Either.left(artifactPathAndNameList);
1405 protected Either<Service, ResponseFormat> createGroupsOnResource(Service service, Map<String, GroupDefinition> groups) {
1406 if (groups != null && !groups.isEmpty()) {
1407 List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, service);
1408 serviceImportParseLogic.handleGroupsProperties(service, groups);
1409 serviceImportParseLogic.fillGroupsFinalFields(groupsAsList);
1410 Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic.createGroups(service, groupsAsList, true);
1411 if (createGroups.isRight()) {
1412 return Either.right(createGroups.right().value());
1415 return Either.left(service);
1417 return getServiceResponseFormatEither(service);
1420 private Either<Service, ResponseFormat> createPoliciesOnResource(final Service service,
1421 final Map<String, PolicyDefinition> policies) {
1422 if (MapUtils.isEmpty(policies)) {
1423 return Either.left(service);
1425 Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = service.getComponentInstancesAttributes();
1426 final Map<String, List<AttributeDefinition>> instanceAttributeMap = new HashMap<>();
1427 if (MapUtils.isNotEmpty(componentInstancesAttributes)) {
1428 instanceAttributeMap.putAll(componentInstancesAttributes
1429 .entrySet().stream()
1430 .collect(toMap(Entry::getKey, entry -> entry.getValue().stream().map(AttributeDefinition.class::cast).collect(toList()))));
1432 policies.values().stream()
1433 .map(PolicyDataDefinition::getProperties)
1434 .flatMap(Collection::stream)
1435 .filter(PropertyDataDefinition::isToscaFunction)
1436 .forEach(policyDefinition -> toscaFunctionService
1437 .updateFunctionWithDataFromSelfComponent(policyDefinition.getToscaFunction(), service, service.getComponentInstancesProperties(),
1438 instanceAttributeMap)
1440 policyBusinessLogic.createPolicies(service, policies);
1441 return getServiceResponseFormatEither(service);
1444 private Either<Service, ResponseFormat> getServiceResponseFormatEither(Service service) {
1445 Either<Service, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
1446 if (updatedResource.isRight()) {
1447 ResponseFormat responseFormat = componentsUtils
1448 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), service,
1449 ComponentTypeEnum.SERVICE);
1450 return Either.right(responseFormat);
1452 return Either.left(updatedResource.left().value());
1455 protected List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups, Service component) {
1456 List<GroupDefinition> result = new ArrayList<>();
1457 List<ComponentInstance> componentInstances = component.getComponentInstances();
1458 if (groups != null) {
1459 for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
1460 String groupName = entry.getKey();
1461 GroupDefinition groupDefinition = entry.getValue();
1462 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
1463 updatedGroupDefinition.setMembers(null);
1464 Map<String, String> members = groupDefinition.getMembers();
1465 if (members != null) {
1466 serviceImportParseLogic.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
1468 result.add(updatedGroupDefinition);
1474 protected Resource createRIAndRelationsFromYaml(String yamlName, Resource resource,
1475 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap,
1476 String topologyTemplateYaml, List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1477 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1478 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
1481 log.debug("************* Going to create all nodes {}", yamlName);
1482 handleNodeTypes(yamlName, resource, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
1483 csarInfo, nodeName);
1484 log.debug("************* Going to create all resource instances {}", yamlName);
1485 resource = createResourceInstances(yamlName, resource, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes());
1486 log.debug("************* Finished to create all resource instances {}", yamlName);
1487 resource = createResourceInstancesRelations(csarInfo.getModifier(), yamlName, resource, uploadComponentInstanceInfoMap);
1488 log.debug("************* Going to create positions {}", yamlName);
1489 compositionBusinessLogic.setPositionsForComponentInstances(resource, csarInfo.getModifier().getUserId());
1490 log.debug("************* Finished to set positions {}", yamlName);
1492 } catch (Exception e) {
1493 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1497 protected Resource createResourceInstancesRelations(User user, String yamlName, Resource resource,
1498 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1499 log.debug("#createResourceInstancesRelations - Going to create relations ");
1500 List<ComponentInstance> componentInstancesList = resource.getComponentInstances();
1501 if (((MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)) &&
1502 resource.getResourceType() != ResourceTypeEnum.PNF)) { // PNF can have no resource instances
1503 log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
1504 resource.getUniqueId(), yamlName);
1505 BeEcompErrorManager.getInstance()
1506 .logInternalDataError("createResourceInstancesRelations", "No instances found in a resource or nn yaml template. ",
1507 BeEcompErrorManager.ErrorSeverity.ERROR);
1508 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName));
1510 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1511 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1512 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1513 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1514 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1515 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1516 Map<String, Resource> originCompMap = new HashMap<>();
1517 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1518 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1519 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1520 Map<String, Map<String, InterfaceDefinition>> instInterfaces = new HashMap<>();
1521 log.debug("enter ServiceImportBusinessLogic createResourceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. ");
1522 final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache;
1523 if (applicationDataTypeCache != null) {
1524 Resource finalResource = resource;
1525 uploadResInstancesMap.values().forEach(
1526 i -> processComponentInstance(yamlName, finalResource, componentInstancesList,
1527 componentsUtils.getAllDataTypes(applicationDataTypeCache, finalResource.getModel()), instProperties, instCapabilities,
1528 instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs, instNodeFilter,
1529 instInterfaces, i));
1531 serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, resource, instProperties);
1532 serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, resource, instInputs);
1533 serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts);
1534 serviceImportParseLogic.associateArtifactsToInstances(yamlName, resource, instArtifacts);
1535 serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements);
1536 serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes);
1537 resource = serviceImportParseLogic.getResourceAfterCreateRelations(resource);
1538 serviceImportParseLogic.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList, relations);
1539 serviceImportParseLogic.associateResourceInstances(yamlName, resource, relations);
1540 handleSubstitutionMappings(resource, uploadResInstancesMap);
1541 log.debug("************* in create relations, getResource start");
1542 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
1543 log.debug("************* in create relations, getResource end");
1544 if (eitherGetResource.isRight()) {
1545 throw new ComponentException(
1546 componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource));
1548 return eitherGetResource.left().value();
1551 protected void processProperty(Resource resource, Map<String, DataTypeDefinition> allDataTypes,
1552 Map<String, InputDefinition> currPropertiesMap, List<ComponentInstanceInput> instPropList,
1553 List<UploadPropInfo> propertyList) {
1554 UploadPropInfo propertyInfo = propertyList.get(0);
1555 String propName = propertyInfo.getName();
1556 if (!currPropertiesMap.containsKey(propName)) {
1557 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName));
1559 processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, resource.getInputs());
1562 private void processProperty(Map<String, DataTypeDefinition> allDataTypes, Map<String, InputDefinition> currPropertiesMap,
1563 List<ComponentInstanceInput> instPropList, UploadPropInfo propertyInfo, String propName,
1564 List<InputDefinition> inputs2) {
1565 InputDefinition curPropertyDef = currPropertiesMap.get(propName);
1566 ComponentInstanceInput property = null;
1567 String value = null;
1568 List<GetInputValueDataDefinition> getInputs = null;
1569 boolean isValidate = true;
1570 if (propertyInfo.getValue() != null) {
1571 getInputs = propertyInfo.getGet_input();
1572 isValidate = getInputs == null || getInputs.isEmpty();
1574 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
1576 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
1579 property = new ComponentInstanceInput(curPropertyDef, value, null);
1580 String validPropertyVAlue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
1581 property.setValue(validPropertyVAlue);
1582 if (isNotEmpty(getInputs)) {
1583 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1584 for (GetInputValueDataDefinition getInput : getInputs) {
1585 List<InputDefinition> inputs = inputs2;
1586 if (CollectionUtils.isEmpty(inputs)) {
1587 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1589 Optional<InputDefinition> optional = inputs.stream().filter(p -> p.getName().equals(getInput.getInputName())).findAny();
1590 if (!optional.isPresent()) {
1591 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1593 InputDefinition input = optional.get();
1594 getInput.setInputId(input.getUniqueId());
1595 getInputValues.add(getInput);
1596 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
1597 processGetInput(getInputValues, inputs, getInputIndex);
1599 property.setGetInputValues(getInputValues);
1601 instPropList.add(property);
1602 currPropertiesMap.remove(property.getName());
1605 protected void handleSubstitutionMappings(Resource resource, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1606 if (resource.getResourceType() == ResourceTypeEnum.VF) {
1607 Either<Resource, StorageOperationStatus> getResourceRes = toscaOperationFacade.getToscaFullElement(resource.getUniqueId());
1608 if (getResourceRes.isRight()) {
1609 ResponseFormat responseFormat = componentsUtils
1610 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource);
1611 throw new ComponentException(responseFormat);
1613 getResourceRes = updateCalculatedCapReqWithSubstitutionMappings(getResourceRes.left().value(), uploadResInstancesMap);
1614 if (getResourceRes.isRight()) {
1615 ResponseFormat responseFormat = componentsUtils
1616 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource);
1617 throw new ComponentException(responseFormat);
1622 protected Resource createResourceInstances(String yamlName, Resource resource, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1623 Map<String, Resource> nodeNamespaceMap) {
1624 Either<Resource, ResponseFormat> eitherResource = null;
1625 log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
1626 if (MapUtils.isEmpty(uploadResInstancesMap) && resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
1627 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
1628 throw new ComponentException(responseFormat);
1630 Map<String, Resource> existingNodeTypeMap = new HashMap<>();
1631 if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
1632 nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v));
1634 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1635 uploadResInstancesMap.values()
1636 .forEach(i -> createAndAddResourceInstance(i, yamlName, resource, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap));
1637 if (MapUtils.isNotEmpty(resourcesInstancesMap)) {
1639 toscaOperationFacade.associateComponentInstancesToComponent(resource, resourcesInstancesMap, false, false);
1640 } catch (StorageException exp) {
1641 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
1642 log.debug("Failed to add component instances to container component {}", resource.getName());
1643 ResponseFormat responseFormat = componentsUtils
1644 .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
1645 eitherResource = Either.right(responseFormat);
1646 throw new ByResponseFormatComponentException(eitherResource.right().value());
1650 log.debug("*************Going to get resource {}", resource.getUniqueId());
1651 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade
1652 .getToscaElement(resource.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter());
1653 log.debug("*************finished to get resource {}", resource.getUniqueId());
1654 if (eitherGetResource.isRight()) {
1655 ResponseFormat responseFormat = componentsUtils
1656 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource);
1657 throw new ComponentException(responseFormat);
1659 if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances()) &&
1660 resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
1661 log.debug("Error when create resource instance from csar. ComponentInstances list empty");
1662 BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty");
1663 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
1665 return eitherGetResource.left().value();
1668 protected void handleNodeTypes(String yamlName, Resource resource, String topologyTemplateYaml, boolean needLock,
1669 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1670 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1673 for (Map.Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
1674 if (nodeTypeEntry.getValue().isNested()) {
1675 handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1676 nodeTypeEntry.getKey());
1677 log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
1680 Map<String, Object> mappedToscaTemplate = null;
1681 if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo
1682 .containsKey(nodeName)) {
1683 mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
1685 if (MapUtils.isEmpty(mappedToscaTemplate)) {
1686 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
1688 createResourcesFromYamlNodeTypesList(yamlName, resource, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle,
1689 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
1690 } catch (ComponentException e) {
1691 ResponseFormat responseFormat =
1692 e.getResponseFormat() != null ? e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
1693 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
1695 } catch (StorageException e) {
1696 ResponseFormat responseFormat = componentsUtils
1697 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
1698 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
1700 } catch (Exception e) {
1701 log.debug("Exception occured when handleNodeTypes, error is:{}", e.getMessage(), e);
1702 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1706 protected Resource handleNestedVfc(Service service,
1707 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1708 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1711 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
1712 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
1713 createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
1715 log.debug("************* Finished to create node types from yaml {}", yamlName);
1716 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1717 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1718 return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
1720 return new Resource();
1721 } catch (Exception e) {
1722 log.debug("Exception occured when handleNestedVFc, error is:{}", e.getMessage(), e);
1723 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1727 protected Resource handleNestedVfc(Resource resource,
1728 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1729 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1731 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
1732 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
1733 log.debug("************* Going to create node types from yaml {}", yamlName);
1734 createResourcesFromYamlNodeTypesList(yamlName, resource, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
1736 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1737 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1738 resource = handleComplexVfc(resource, nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
1743 protected Resource handleComplexVfc(Resource resource,
1744 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1745 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1746 String nodeName, String yamlName) {
1747 Resource oldComplexVfc = null;
1748 Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(resource, csarInfo, nodeName, nodesInfo);
1749 Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
1750 .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
1751 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
1752 oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
1753 serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), nodeName).getRight());
1755 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
1756 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1757 } else if (oldComplexVfcRes.isLeft()) {
1758 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
1759 Either<Boolean, ResponseFormat> eitherValidation = serviceImportParseLogic
1760 .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc,
1761 ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
1762 if (eitherValidation.isLeft()) {
1763 oldComplexVfc = oldComplexVfcRes.left().value();
1766 newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc,
1768 csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
1769 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
1770 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR);
1771 log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
1772 final Resource result = serviceImportParseLogic
1773 .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true);
1774 csarInfo.getCreatedNodes().put(nodeName, result);
1775 csarInfo.removeNodeFromQueue();
1779 private Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Resource resource, Map<String, Object> mappedToscaTemplate,
1781 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1782 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1783 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
1784 Either<String, ImportUtils.ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
1785 TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
1786 if (toscaVersion.isRight()) {
1787 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
1789 Map<String, Object> mapToConvert = new HashMap<>();
1790 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value());
1791 Map<String, Object> nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate);
1792 createNodeTypes(yamlName, resource, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert,
1794 return csarInfo.getCreatedNodes();
1797 protected void createNodeTypes(String yamlName, Resource resource, boolean needLock,
1798 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1799 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1800 Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
1801 Iterator<Map.Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet().iterator();
1802 Resource vfcCreated = null;
1803 while (nodesNameValueIter.hasNext()) {
1804 Map.Entry<String, Object> nodeType = nodesNameValueIter.next();
1805 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle =
1806 nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeType.getKey());
1807 if (nodeTypesInfo.containsKey(nodeType.getKey())) {
1808 log.trace("************* Going to handle nested vfc {}", nodeType.getKey());
1809 vfcCreated = handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1811 log.trace("************* Finished to handle nested vfc {}", nodeType.getKey());
1812 } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames()
1813 .containsKey(nodeType.getKey())) {
1814 log.trace("************* Going to create node {}", nodeType.getKey());
1815 ImmutablePair<Resource, ActionStatus> resourceCreated = createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(),
1816 mapToConvert, resource, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true);
1817 log.debug("************* Finished to create node {}", nodeType.getKey());
1818 vfcCreated = resourceCreated.getLeft();
1819 csarInfo.getCreatedNodesToscaResourceNames().put(nodeType.getKey(), vfcCreated.getToscaResourceName());
1821 if (vfcCreated != null) {
1822 csarInfo.getCreatedNodes().put(nodeType.getKey(), vfcCreated);
1824 mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());
1828 protected ImmutablePair<Resource, ActionStatus> createNodeTypeResourceFromYaml(String yamlName, Map.Entry<String, Object> nodeNameValue,
1829 User user, Map<String, Object> mapToConvert, Resource resourceVf,
1831 Map<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
1832 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1833 boolean forceCertificationAllowed, CsarInfo csarInfo,
1835 final var validatedUser = serviceBusinessLogic.validateUser(user, "CheckIn Resource", resourceVf, AuditingActionEnum.CHECKIN_RESOURCE,
1837 UploadResourceInfo resourceMetaData = serviceImportParseLogic.fillResourceMetadata(yamlName, resourceVf, nodeNameValue.getKey(),
1839 String singleVfcYaml = serviceImportParseLogic.buildNodeTypeYaml(nodeNameValue, mapToConvert, resourceMetaData.getResourceType(), csarInfo);
1840 return serviceImportParseLogic.createResourceFromNodeType(singleVfcYaml, resourceMetaData, validatedUser, true, needLock,
1841 nodeTypeArtifactsToHandle,
1842 nodeTypesNewCreatedArtifacts, forceCertificationAllowed, csarInfo, nodeNameValue.getKey(), isNested);
1845 protected Service createRIAndRelationsFromYaml(String yamlName, Service service,
1846 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap,
1847 String topologyTemplateYaml, List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1848 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1849 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
1851 log.debug("************* Going to create all nodes {}", yamlName);
1852 handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts,
1853 nodeTypesInfo, csarInfo, nodeName);
1854 List<PropertyDefinition> serviceProperties = null != service ? service.getProperties() : Collections.emptyList();
1855 if (MapUtils.isNotEmpty(uploadComponentInstanceInfoMap)) {
1856 log.debug("************* Going to create all resource instances {}", yamlName);
1857 service = createServiceInstances(yamlName, service, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes());
1858 log.debug("************* Going to create all relations {}", yamlName);
1859 service = createServiceInstancesRelations(csarInfo.getModifier(), yamlName, service, uploadComponentInstanceInfoMap, serviceProperties);
1860 log.debug("************* Going to create positions {}", yamlName);
1861 compositionBusinessLogic.setPositionsForComponentInstances(service, csarInfo.getModifier().getUserId());
1862 log.debug("************* Finished to set positions {}", yamlName);
1867 protected Service createServiceInstancesRelations(User user, String yamlName, Service service,
1868 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1869 List<PropertyDefinition> serviceProperties) {
1870 log.debug("#createResourceInstancesRelations - Going to create relations ");
1871 List<ComponentInstance> componentInstancesList = service.getComponentInstances();
1872 if (MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)) { // PNF can have no resource instances
1873 log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
1874 service.getUniqueId(), yamlName);
1875 BeEcompErrorManager.getInstance()
1876 .logInternalDataError("createResourceInstancesRelations", "No instances found in a component or nn yaml template. ",
1877 BeEcompErrorManager.ErrorSeverity.ERROR);
1878 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName));
1880 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1881 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1882 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1883 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1884 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1885 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1886 Map<String, Resource> originCompMap = new HashMap<>();
1887 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1888 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1889 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1890 Map<String, Map<String, InterfaceDefinition>> instInterfaces = new HashMap<>();
1891 log.debug("enter ServiceImportBusinessLogic createServiceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. ");
1892 final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache;
1893 if (applicationDataTypeCache != null) {
1894 final Map<String, DataTypeDefinition> allDataTypesMap =
1895 componentsUtils.getAllDataTypes(applicationDataTypeCache, service.getModel());
1896 final Service service1 = service;
1897 service1.setProperties(serviceProperties);
1898 uploadResInstancesMap.values().forEach(
1899 i -> processComponentInstance(yamlName, service1, componentInstancesList,
1900 allDataTypesMap, instProperties,
1901 instCapabilities, instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs,
1902 instNodeFilter, instInterfaces, i)
1905 updatePropertyToscaFunctionData(service, instProperties, instAttributes);
1906 serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, service, instProperties);
1907 serviceImportParseLogic.associateComponentInstanceInterfacesToComponent(
1912 serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, service, instInputs);
1913 serviceImportParseLogic.associateCINodeFilterToComponent(yamlName, service, instNodeFilter);
1914 serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, service, instDeploymentArtifacts);
1915 serviceImportParseLogic.associateArtifactsToInstances(yamlName, service, instArtifacts);
1916 serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, service, instCapabilities, instRequirements);
1917 log.debug("enter createServiceInstancesRelations test,instRequirements:{},instCapabilities:{}", instRequirements, instCapabilities);
1918 serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, service, instAttributes);
1919 ToscaElement serviceTemplate = ModelConverter.convertToToscaElement(service);
1920 Map<String, ListCapabilityDataDefinition> capabilities = serviceTemplate.getCapabilities();
1921 Map<String, ListRequirementDataDefinition> requirements = serviceTemplate.getRequirements();
1922 serviceImportParseLogic.associateCapabilitiesToService(yamlName, service, capabilities);
1923 serviceImportParseLogic.associateRequirementsToService(yamlName, service, requirements);
1924 service = getResourceAfterCreateRelations(service);
1925 addRelationsToRI(yamlName, service, uploadResInstancesMap, componentInstancesList, relations);
1926 serviceImportParseLogic.associateResourceInstances(yamlName, service, relations);
1927 log.debug("************* in create relations, getResource start");
1928 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
1929 log.debug("************* in create relations, getResource end");
1930 if (eitherGetResource.isRight()) {
1931 throw new ComponentException(componentsUtils
1932 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service,
1933 service.getComponentType()));
1935 return eitherGetResource.left().value();
1938 private void updatePropertyToscaFunctionData(final Component service,
1939 final Map<String, List<ComponentInstanceProperty>> instancePropertyMap,
1940 final Map<String, List<AttributeDefinition>> instanceAttributeMap) {
1941 final Component updatedService =
1942 toscaOperationFacade.getToscaElement(service.getUniqueId()).left()
1943 .on(storageOperationStatus -> {
1944 final ActionStatus status = componentsUtils.convertFromStorageResponse(storageOperationStatus);
1945 final ResponseFormat responseFormat =
1946 componentsUtils.getResponseFormatByComponent(status, service, service.getComponentType());
1947 throw new ComponentException(responseFormat);
1950 instancePropertyMap.values().forEach(instancePropertyList ->
1951 instancePropertyList.stream()
1952 .filter(PropertyDataDefinition::isToscaFunction)
1953 .forEach(instanceProperty -> {
1954 toscaFunctionService.updateFunctionWithDataFromSelfComponent(instanceProperty.getToscaFunction(),
1955 updatedService, instancePropertyMap, instanceAttributeMap);
1956 instanceProperty.setValue(instanceProperty.getToscaFunction().getValue());
1961 protected void processComponentInstance(String yamlName, Component component, List<ComponentInstance> componentInstancesList,
1962 Map<String, DataTypeDefinition> allDataTypes,
1963 Map<String, List<ComponentInstanceProperty>> instProperties,
1964 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
1965 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements,
1966 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts,
1967 Map<String, Map<String, ArtifactDefinition>> instArtifacts,
1968 Map<String, List<AttributeDefinition>> instAttributes, Map<String, Resource> originCompMap,
1969 Map<String, List<ComponentInstanceInput>> instInputs,
1970 Map<String, UploadNodeFilterInfo> instNodeFilter,
1971 Map<String, Map<String, InterfaceDefinition>> instInterfaces,
1972 UploadComponentInstanceInfo uploadComponentInstanceInfo) {
1973 log.debug("enter ServiceImportBusinessLogic processComponentInstance");
1974 Optional<ComponentInstance> currentCompInstanceOpt = componentInstancesList.stream()
1975 .filter(i -> i.getName().equals(uploadComponentInstanceInfo.getName())).findFirst();
1976 if (currentCompInstanceOpt.isEmpty()) {
1977 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), component.getUniqueId());
1978 BeEcompErrorManager.getInstance()
1979 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, component.getUniqueId(),
1980 BeEcompErrorManager.ErrorSeverity.ERROR);
1981 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1982 throw new ComponentException(responseFormat);
1984 ComponentInstance currentCompInstance = currentCompInstanceOpt.get();
1985 String resourceInstanceId = currentCompInstance.getUniqueId();
1986 Resource originResource = getOriginResource(yamlName, originCompMap, currentCompInstance);
1987 if (MapUtils.isNotEmpty(originResource.getRequirements())) {
1988 instRequirements.put(currentCompInstance, originResource.getRequirements());
1990 if (MapUtils.isNotEmpty(originResource.getCapabilities())) {
1991 processComponentInstanceCapabilities(allDataTypes, instCapabilties, uploadComponentInstanceInfo, currentCompInstance, originResource);
1993 if (originResource.getDeploymentArtifacts() != null && !originResource.getDeploymentArtifacts().isEmpty()) {
1994 instDeploymentArtifacts.put(resourceInstanceId, originResource.getDeploymentArtifacts());
1996 if (originResource.getArtifacts() != null && !originResource.getArtifacts().isEmpty()) {
1997 instArtifacts.put(resourceInstanceId, originResource.getArtifacts());
1999 if (originResource.getAttributes() != null && !originResource.getAttributes().isEmpty()) {
2000 instAttributes.put(resourceInstanceId, originResource.getAttributes());
2001 addAttributeValueToResourceInstance(instAttributes, uploadComponentInstanceInfo.getAttributes());
2003 if (uploadComponentInstanceInfo.getUploadNodeFilterInfo() != null) {
2004 instNodeFilter.put(resourceInstanceId, uploadComponentInstanceInfo.getUploadNodeFilterInfo());
2006 if (MapUtils.isNotEmpty(uploadComponentInstanceInfo.getInterfaces())) {
2008 ResponseFormat addInterfacesToRiRes = addInterfaceValuesToRi(
2009 uploadComponentInstanceInfo,
2012 currentCompInstance,
2015 if (addInterfacesToRiRes.getStatus() != 200) {
2016 throw new ComponentException(addInterfacesToRiRes);
2019 if (originResource.getResourceType() != ResourceTypeEnum.VF) {
2020 ResponseFormat addPropertiesValueToRiRes = addPropertyValuesToRi(uploadComponentInstanceInfo, component, originResource,
2021 currentCompInstance, instProperties, allDataTypes);
2022 if (addPropertiesValueToRiRes.getStatus() != 200) {
2023 throw new ComponentException(addPropertiesValueToRiRes);
2026 addInputsValuesToRi(uploadComponentInstanceInfo, component, originResource, currentCompInstance, instInputs, allDataTypes);
2030 protected void addInputsValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component, Resource originResource,
2031 ComponentInstance currentCompInstance, Map<String, List<ComponentInstanceInput>> instInputs,
2032 Map<String, DataTypeDefinition> allDataTypes) {
2033 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
2035 if (MapUtils.isNotEmpty(propMap)) {
2036 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
2037 List<ComponentInstanceInput> instPropList = new ArrayList<>();
2038 if (CollectionUtils.isEmpty(originResource.getInputs())) {
2039 log.debug("failed to find properties ");
2040 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND));
2042 originResource.getInputs().forEach(p -> serviceImportParseLogic.addInput(currPropertiesMap, p));
2043 for (List<UploadPropInfo> propertyList : propMap.values()) {
2044 processProperty(component, allDataTypes, currPropertiesMap, instPropList, propertyList);
2046 currPropertiesMap.values().forEach(p -> instPropList.add(new ComponentInstanceInput(p)));
2047 instInputs.put(currentCompInstance.getUniqueId(), instPropList);
2049 } catch (Exception e) {
2050 log.debug("failed to add Inputs Values To Ri");
2051 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2055 protected void processProperty(Component component, Map<String, DataTypeDefinition> allDataTypes,
2056 Map<String, InputDefinition> currPropertiesMap, List<ComponentInstanceInput> instPropList,
2057 List<UploadPropInfo> propertyList) {
2058 UploadPropInfo propertyInfo = propertyList.get(0);
2059 String propName = propertyInfo.getName();
2060 if (!currPropertiesMap.containsKey(propName)) {
2061 log.debug("failed to find property {} ", propName);
2062 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName));
2064 processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, component.getInputs());
2067 protected void processGetInput(List<GetInputValueDataDefinition> getInputValues, List<InputDefinition> inputs,
2068 GetInputValueDataDefinition getInputIndex) {
2069 Optional<InputDefinition> optional;
2070 if (getInputIndex != null) {
2071 optional = inputs.stream().filter(p -> p.getName().equals(getInputIndex.getInputName())).findAny();
2072 if (!optional.isPresent()) {
2073 log.debug("Failed to find input {} ", getInputIndex.getInputName());
2074 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
2076 InputDefinition inputIndex = optional.get();
2077 getInputIndex.setInputId(inputIndex.getUniqueId());
2078 getInputValues.add(getInputIndex);
2082 private void addAttributeValueToResourceInstance(Map<String, List<AttributeDefinition>> instAttributes,
2083 Map<String, UploadAttributeInfo> attributeMap) {
2084 if (attributeMap == null) {
2087 attributeMap.forEach((attributeName, attributeValue) -> instAttributes.values()
2088 .forEach(value -> value.stream().filter(attr -> attr.getName().equals(attributeName)).forEach(attr -> {
2089 if (attributeValue.getValue() instanceof Collection<?> || attributeValue.getValue() instanceof Map<?, ?>) {
2090 Gson gson = new Gson();
2091 String json = gson.toJson(attributeValue.getValue());
2092 attr.setValue(json);
2094 attr.setValue(String.valueOf(attributeValue.getValue()));
2099 protected ResponseFormat addPropertyValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component,
2100 Resource originResource, ComponentInstance currentCompInstance,
2101 Map<String, List<ComponentInstanceProperty>> instProperties,
2102 Map<String, DataTypeDefinition> allDataTypes) {
2103 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
2104 Map<String, PropertyDefinition> currPropertiesMap = new HashMap<>();
2105 List<PropertyDefinition> originalPropertyList = originResource.getProperties();
2106 if (MapUtils.isNotEmpty(propMap) && CollectionUtils.isEmpty(originalPropertyList)) {
2107 log.debug("failed to find properties ");
2108 return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND);
2110 if (CollectionUtils.isEmpty(originalPropertyList)) {
2111 return componentsUtils.getResponseFormat(ActionStatus.OK);
2113 originalPropertyList.stream()
2114 .filter(property -> !currPropertiesMap.containsKey(property.getName()))
2115 .forEach(property -> currPropertiesMap.put(property.getName(), property));
2116 List<ComponentInstanceProperty> instPropList = new ArrayList<>();
2117 if (MapUtils.isNotEmpty(propMap)) {
2118 for (final List<UploadPropInfo> propertyList : propMap.values()) {
2119 UploadPropInfo propertyInfo = propertyList.get(0);
2120 String propName = propertyInfo.getName();
2121 if (!currPropertiesMap.containsKey(propName)) {
2122 log.debug("failed to find property {} ", propName);
2123 return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName);
2125 PropertyDefinition curPropertyDef = currPropertiesMap.get(propName);
2126 String value = null;
2127 final List<GetInputValueDataDefinition> getInputs = new ArrayList<>();
2128 boolean isValidate = true;
2129 if (propertyInfo.getValue() != null) {
2130 getInputs.addAll(propertyInfo.getGet_input());
2131 isValidate = getInputs.isEmpty();
2133 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
2135 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
2138 final var property = new ComponentInstanceProperty(curPropertyDef, value, null);
2139 String validatedPropValue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, true, allDataTypes);
2141 addSubPropertyYamlToscaFunctions(validatedPropValue, value, property.getType(), propertyInfo, allDataTypes);
2143 if (CollectionUtils.isNotEmpty(propertyInfo.getSubPropertyToscaFunctions())) {
2144 validatedPropValue = value;
2147 property.setValue(validatedPropValue);
2149 if (tryHandlingAsYamlToscaFunction(validatedPropValue, value, propertyInfo)) {
2151 final Object yamlValue = new Yaml().loadAs(value, Object.class);
2152 CustomYamlFunction toscaFunction = new CustomYamlFunction();
2153 toscaFunction.setYamlValue(yamlValue);
2154 property.setToscaFunction(toscaFunction);
2155 } catch (Exception exception) {
2156 log.info("Cannot create YAML value for {}", propName);
2159 property.setToscaFunction(propertyInfo.getToscaFunction());
2161 property.setSubPropertyToscaFunctions(propertyInfo.getSubPropertyToscaFunctions());
2162 if (!getInputs.isEmpty() && CollectionUtils.isEmpty(property.getSubPropertyToscaFunctions())) {
2163 final List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
2164 for (final GetInputValueDataDefinition getInput : getInputs) {
2165 final List<InputDefinition> inputs = component.getInputs();
2166 if (inputs == null || inputs.isEmpty()) {
2167 log.debug("Failed to add property {} to instance. Inputs list is empty ", property);
2168 serviceBusinessLogic.rollbackWithException(ActionStatus.INPUTS_NOT_FOUND,
2169 property.getGetInputValues().stream().map(GetInputValueDataDefinition::getInputName).collect(toList()).toString());
2171 InputDefinition input = serviceImportParseLogic.findInputByName(inputs, getInput);
2172 getInput.setInputId(input.getUniqueId());
2173 getInputValues.add(getInput);
2174 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
2175 if (getInputIndex != null) {
2176 input = serviceImportParseLogic.findInputByName(inputs, getInputIndex);
2177 getInputIndex.setInputId(input.getUniqueId());
2178 getInputValues.add(getInputIndex);
2181 property.setGetInputValues(getInputValues);
2183 instPropList.add(property);
2184 currPropertiesMap.remove(property.getName());
2187 if (!currPropertiesMap.isEmpty()) {
2188 for (PropertyDefinition value : currPropertiesMap.values()) {
2189 instPropList.add(new ComponentInstanceProperty(value));
2192 instProperties.put(currentCompInstance.getUniqueId(), instPropList);
2193 return componentsUtils.getResponseFormat(ActionStatus.OK);
2196 private boolean tryHandlingAsYamlToscaFunction(String validatedPropValue, String value, UploadPropInfo propertyInfo) {
2197 return StringUtils.isEmpty(validatedPropValue) && StringUtils.isNotEmpty(value) && propertyInfo.getToscaFunction() == null
2198 && CollectionUtils.isEmpty(propertyInfo.getSubPropertyToscaFunctions());
2201 private void addSubPropertyYamlToscaFunctions(final String validatedPropValue, final String value, final String propertyType,
2202 final UploadPropInfo propertyInfo, final Map<String, DataTypeDefinition> allDataTypes) {
2203 if (StringUtils.isNotEmpty(validatedPropValue) || StringUtils.isEmpty(value) || ToscaPropertyType.isValidType(propertyType) != null) {
2207 final JsonObject jsonObject = JsonParser.parseString(value).getAsJsonObject();
2209 final DataTypeDefinition dataTypeDefinition = allDataTypes.get(propertyType);
2210 final List<String> propertyNames =
2211 dataTypeDefinition.getProperties().stream().map(PropertyDataDefinition::getName).collect(Collectors.toList());
2213 boolean hasSubPropertyValues = jsonObject.entrySet().stream().allMatch(entry -> propertyNames.contains(entry.getKey()));
2215 if (hasSubPropertyValues) {
2216 for (final PropertyDefinition prop : dataTypeDefinition.getProperties()) {
2217 if (propertyInfo.getSubPropertyToscaFunctions().stream()
2218 .anyMatch(subPropertyToscaFunction -> subPropertyToscaFunction.getSubPropertyPath().get(0).equals(prop.getName()))) {
2221 Optional<SubPropertyToscaFunction> subPropertyToscaFunction = createSubPropertyYamlToscaFunction(jsonObject, prop, allDataTypes);
2222 if (subPropertyToscaFunction.isPresent()) {
2223 propertyInfo.getSubPropertyToscaFunctions().add(subPropertyToscaFunction.get());
2227 } catch (Exception exception) {
2228 log.info("Cannot create YAML value for {}", value);
2232 private Optional<SubPropertyToscaFunction> createSubPropertyYamlToscaFunction(final JsonObject jsonObject, final PropertyDefinition prop,
2233 final Map<String, DataTypeDefinition> allDataTypes) {
2234 JsonElement propJsonElement = jsonObject.get(prop.getName());
2235 if (propJsonElement != null) {
2236 final String subPropValue = propJsonElement.toString();
2237 final ComponentInstanceProperty subProperty = new ComponentInstanceProperty(prop, subPropValue, null);
2238 final String validateSubPropValue =
2239 serviceBusinessLogic.validatePropValueBeforeCreate(subProperty, subPropValue, true, allDataTypes);
2241 if (StringUtils.isEmpty(validateSubPropValue) && StringUtils.isNotEmpty(subPropValue)) {
2243 Object yamlValue = new Yaml().loadAs(subPropValue, Object.class);
2244 SubPropertyToscaFunction subPropertyToscaFunction = new SubPropertyToscaFunction();
2245 CustomYamlFunction toscaFunction = new CustomYamlFunction();
2246 toscaFunction.setYamlValue(yamlValue);
2247 subPropertyToscaFunction.setToscaFunction(toscaFunction);
2248 subPropertyToscaFunction.setSubPropertyPath(Collections.singletonList(prop.getName()));
2249 return Optional.of(subPropertyToscaFunction);
2250 } catch (Exception exception) {
2251 log.info("Cannot create YAML value for {}", subPropValue);
2255 return Optional.empty();
2258 protected ResponseFormat addInterfaceValuesToRi(
2259 UploadComponentInstanceInfo uploadComponentInstanceInfo,
2260 Component component,
2261 Resource originResource, ComponentInstance currentCompInstance,
2262 Map<String, Map<String, InterfaceDefinition>> instInterfaces
2264 Map<String, UploadInterfaceInfo> instanceInterfacesMap = uploadComponentInstanceInfo.getInterfaces();
2265 Map<String, InterfaceDefinition> currInterfacesMap = new HashMap<>();
2266 Map<String, InterfaceDefinition> interfacesFromNodeType = originResource.getInterfaces();
2267 if ((MapUtils.isNotEmpty(instanceInterfacesMap)) && (MapUtils.isEmpty(interfacesFromNodeType))) {
2268 log.debug("failed to find interfaces ");
2269 return componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT);
2271 if (interfacesFromNodeType == null || interfacesFromNodeType.isEmpty()) {
2272 return componentsUtils.getResponseFormat(ActionStatus.OK);
2274 for (Map.Entry<String, InterfaceDefinition> entryInstances : interfacesFromNodeType.entrySet()) {
2275 String interfaceName = entryInstances.getKey().substring(entryInstances.getKey().lastIndexOf(".") + 1);
2276 if (!currInterfacesMap.containsKey(interfaceName)) {
2277 currInterfacesMap.put(interfaceName, entryInstances.getValue());
2281 Map<String, InterfaceDefinition> instInterfacesMap = new HashMap<>();
2282 if (MapUtils.isNotEmpty(instanceInterfacesMap)) {
2283 for (UploadInterfaceInfo uploadInterfaceInfo : instanceInterfacesMap.values()) {
2284 String interfaceName = uploadInterfaceInfo.getName();
2285 if (!currInterfacesMap.containsKey(interfaceName)) {
2286 log.debug("failed to find interface {} ", interfaceName);
2287 return componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT, interfaceName);
2289 InterfaceDefinition currentInterfaceDef = currInterfacesMap.get(interfaceName);
2290 Map<String, OperationDataDefinition> operationsToAdd = new HashMap<>();
2292 Map<String, OperationDataDefinition> operations = uploadInterfaceInfo.getOperations();
2293 for (Map.Entry<String, OperationDataDefinition> operation : operations.entrySet()) {
2294 OperationDataDefinition templateOperation = currentInterfaceDef.getOperationsMap().get(operation.getKey());
2295 OperationDataDefinition instanceOperation = operation.getValue();
2297 ListDataDefinition<OperationInputDefinition> instanceInputs = instanceOperation.getInputs();
2298 mergeOperationInputDefinitions(templateOperation.getInputs(), instanceInputs);
2299 if (null != instanceInputs) {
2300 component.getProperties()
2301 .forEach(property -> instanceInputs.getListToscaDataDefinition().stream()
2302 .filter(instanceInput ->
2303 instanceInput.getToscaFunction() instanceof ToscaGetFunctionDataDefinition &&
2304 property.getName().equals(instanceInput.getToscaFunction() != null ?
2305 ((ToscaGetFunctionDataDefinition) instanceInput.getToscaFunction()).getPropertyName() :
2307 .forEach(oldInput -> oldInput.setType(property.getType()))
2310 templateOperation.setInputs(instanceInputs);
2312 templateOperation.setImplementation(instanceOperation.getImplementation());
2314 templateOperation.setDescription(instanceOperation.getDescription());
2315 operationsToAdd.put(operation.getKey(), templateOperation);
2317 InterfaceDefinition interfaceDef = new InterfaceDefinition();
2318 interfaceDef.setModel(component.getModel());
2319 interfaceDef.setType(currentInterfaceDef.getType());
2320 interfaceDef.setUniqueId(currentInterfaceDef.getType());
2321 interfaceDef.setDescription(uploadInterfaceInfo.getDescription());
2322 interfaceDef.setOperations(operationsToAdd);
2323 instInterfacesMap.put(currentInterfaceDef.getType(), interfaceDef);
2324 currInterfacesMap.remove(interfaceName);
2327 if (!currInterfacesMap.isEmpty()) {
2328 for (InterfaceDefinition value : currInterfacesMap.values()) {
2329 instInterfacesMap.put(value.getUniqueId(), value);
2332 instInterfaces.put(currentCompInstance.getUniqueId(), instInterfacesMap);
2333 return componentsUtils.getResponseFormat(ActionStatus.OK);
2336 private void mergeOperationInputDefinitions(ListDataDefinition<OperationInputDefinition> inputsFromNodeType,
2337 ListDataDefinition<OperationInputDefinition> instanceInputs) {
2338 if (inputsFromNodeType == null || CollectionUtils.isEmpty(inputsFromNodeType.getListToscaDataDefinition()) || instanceInputs == null
2339 || CollectionUtils.isEmpty(instanceInputs.getListToscaDataDefinition())) {
2342 instanceInputs.getListToscaDataDefinition().forEach(
2343 instanceInput -> inputsFromNodeType.getListToscaDataDefinition().stream().filter(
2344 templateInput -> templateInput.getName().equals(instanceInput.getName())
2346 newInstanceInput -> {
2347 instanceInput.setSourceProperty(newInstanceInput.getSourceProperty());
2348 instanceInput.setSource(newInstanceInput.getSource());
2349 instanceInput.setType(newInstanceInput.getType());
2353 instanceInputs.getListToscaDataDefinition().stream()
2354 .filter(instanceInput -> inputsFromNodeType.getListToscaDataDefinition().stream().noneMatch(
2355 inputFromNodeType -> inputFromNodeType.getName().equals(instanceInput.getName())
2357 .forEach(oldInput -> oldInput.setType("string"));
2360 protected void processComponentInstanceCapabilities(Map<String, DataTypeDefinition> allDataTypes,
2361 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
2362 UploadComponentInstanceInfo uploadComponentInstanceInfo,
2363 ComponentInstance currentCompInstance, Resource originResource) {
2364 log.debug("enter processComponentInstanceCapabilities");
2365 Map<String, List<CapabilityDefinition>> originCapabilities;
2366 if (MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities())) {
2367 originCapabilities = new HashMap<>();
2368 Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
2369 originResource.getCapabilities().forEach((k, v) -> serviceImportParseLogic.addCapabilities(originCapabilities, k, v));
2370 uploadComponentInstanceInfo.getCapabilities().values()
2371 .forEach(l -> serviceImportParseLogic.addCapabilitiesProperties(newPropertiesMap, l));
2372 updateCapabilityPropertiesValues(allDataTypes, originCapabilities, newPropertiesMap);
2374 originCapabilities = originResource.getCapabilities();
2376 instCapabilties.put(currentCompInstance, originCapabilities);
2379 protected void updateCapabilityPropertiesValues(Map<String, DataTypeDefinition> allDataTypes,
2380 Map<String, List<CapabilityDefinition>> originCapabilities,
2381 Map<String, Map<String, UploadPropInfo>> newPropertiesMap) {
2382 originCapabilities.values().stream().flatMap(Collection::stream).filter(c -> newPropertiesMap.containsKey(c.getName()))
2383 .forEach(c -> updatePropertyValues(c.getProperties(), newPropertiesMap.get(c.getName()), allDataTypes));
2386 protected void updatePropertyValues(List<ComponentInstanceProperty> properties, Map<String, UploadPropInfo> newProperties,
2387 Map<String, DataTypeDefinition> allDataTypes) {
2388 properties.forEach(p -> updatePropertyValue(p, newProperties.get(p.getName()), allDataTypes));
2391 protected String updatePropertyValue(ComponentInstanceProperty property, UploadPropInfo propertyInfo,
2392 Map<String, DataTypeDefinition> allDataTypes) {
2393 String value = null;
2394 List<GetInputValueDataDefinition> getInputs = null;
2395 boolean isValidate = true;
2396 if (null != propertyInfo && propertyInfo.getValue() != null) {
2397 getInputs = propertyInfo.getGet_input();
2398 isValidate = getInputs == null || getInputs.isEmpty();
2400 value = getPropertyJsonStringValue(propertyInfo.getValue(), property.getType());
2402 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
2405 property.setValue(value);
2406 return serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
2409 protected Resource getOriginResource(String yamlName, Map<String, Resource> originCompMap, ComponentInstance currentCompInstance) {
2410 Resource originResource;
2411 log.debug("after enter ServiceImportBusinessLogic processComponentInstance, enter getOriginResource");
2412 if (!originCompMap.containsKey(currentCompInstance.getComponentUid())) {
2413 Either<Resource, StorageOperationStatus> getOriginResourceRes = toscaOperationFacade
2414 .getToscaFullElement(currentCompInstance.getComponentUid());
2415 if (getOriginResourceRes.isRight()) {
2416 ResponseFormat responseFormat = componentsUtils
2417 .getResponseFormat(componentsUtils.convertFromStorageResponse(getOriginResourceRes.right().value()), yamlName);
2418 throw new ComponentException(responseFormat);
2420 originResource = getOriginResourceRes.left().value();
2421 originCompMap.put(originResource.getUniqueId(), originResource);
2423 originResource = originCompMap.get(currentCompInstance.getComponentUid());
2425 return originResource;
2428 protected Either<Resource, StorageOperationStatus> updateCalculatedCapReqWithSubstitutionMappings(Resource resource,
2429 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
2430 Either<Resource, StorageOperationStatus> updateRes = null;
2431 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities = new HashMap<>();
2432 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements = new HashMap<>();
2433 StorageOperationStatus status = toscaOperationFacade.deleteAllCalculatedCapabilitiesRequirements(resource.getUniqueId());
2434 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
2435 log.debug("Failed to delete all calculated capabilities and requirements of resource {} upon update. Status is {}",
2436 resource.getUniqueId(), status);
2437 updateRes = Either.right(status);
2439 if (updateRes == null) {
2440 fillUpdatedInstCapabilitiesRequirements(resource.getComponentInstances(), uploadResInstancesMap, updatedInstCapabilities,
2441 updatedInstRequirements);
2442 status = toscaOperationFacade.associateOrAddCalculatedCapReq(updatedInstCapabilities, updatedInstRequirements, resource);
2443 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
2444 updateRes = Either.right(status);
2447 if (updateRes == null) {
2448 updateRes = Either.left(resource);
2453 protected void fillUpdatedInstCapabilitiesRequirements(List<ComponentInstance> componentInstances,
2454 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
2455 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities,
2456 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements) {
2457 componentInstances.stream().forEach(i -> {
2458 fillUpdatedInstCapabilities(updatedInstCapabilities, i, uploadResInstancesMap.get(i.getName()).getCapabilitiesNamesToUpdate());
2459 fillUpdatedInstRequirements(updatedInstRequirements, i, uploadResInstancesMap.get(i.getName()).getRequirementsNamesToUpdate());
2463 protected void fillUpdatedInstCapabilities(Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilties,
2464 ComponentInstance instance, Map<String, String> capabilitiesNamesToUpdate) {
2465 Map<String, List<CapabilityDefinition>> updatedCapabilities = new HashMap<>();
2466 Set<String> updatedCapNames = new HashSet<>();
2467 if (MapUtils.isNotEmpty(capabilitiesNamesToUpdate)) {
2468 for (Map.Entry<String, List<CapabilityDefinition>> requirements : instance.getCapabilities().entrySet()) {
2469 updatedCapabilities.put(requirements.getKey(), requirements.getValue().stream().filter(
2470 c -> capabilitiesNamesToUpdate.containsKey(c.getName()) && !updatedCapNames.contains(capabilitiesNamesToUpdate.get(c.getName())))
2472 c.setParentName(c.getName());
2473 c.setName(capabilitiesNamesToUpdate.get(c.getName()));
2474 updatedCapNames.add(c.getName());
2476 }).collect(toList()));
2479 if (MapUtils.isNotEmpty(updatedCapabilities)) {
2480 updatedInstCapabilties.put(instance, updatedCapabilities);
2484 protected void fillUpdatedInstRequirements(Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements,
2485 ComponentInstance instance, Map<String, String> requirementsNamesToUpdate) {
2486 Map<String, List<RequirementDefinition>> updatedRequirements = new HashMap<>();
2487 Set<String> updatedReqNames = new HashSet<>();
2488 if (MapUtils.isNotEmpty(requirementsNamesToUpdate)) {
2489 for (Map.Entry<String, List<RequirementDefinition>> requirements : instance.getRequirements().entrySet()) {
2490 updatedRequirements.put(requirements.getKey(), requirements.getValue().stream().filter(
2491 r -> requirementsNamesToUpdate.containsKey(r.getName()) && !updatedReqNames.contains(requirementsNamesToUpdate.get(r.getName())))
2493 r.setParentName(r.getName());
2494 r.setName(requirementsNamesToUpdate.get(r.getName()));
2495 updatedReqNames.add(r.getName());
2497 }).collect(toList()));
2500 if (MapUtils.isNotEmpty(updatedRequirements)) {
2501 updatedInstRequirements.put(instance, updatedRequirements);
2505 protected void addRelationsToRI(String yamlName, Service service, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
2506 List<ComponentInstance> componentInstancesList, List<RequirementCapabilityRelDef> relations) {
2507 for (Map.Entry<String, UploadComponentInstanceInfo> entry : uploadResInstancesMap.entrySet()) {
2508 UploadComponentInstanceInfo uploadComponentInstanceInfo = entry.getValue();
2509 ComponentInstance currentCompInstance = null;
2510 for (ComponentInstance compInstance : componentInstancesList) {
2511 if (compInstance.getName().equals(uploadComponentInstanceInfo.getName())) {
2512 currentCompInstance = compInstance;
2516 if (currentCompInstance == null) {
2517 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), service.getUniqueId());
2518 BeEcompErrorManager.getInstance()
2519 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, service.getUniqueId(),
2520 BeEcompErrorManager.ErrorSeverity.ERROR);
2521 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2522 throw new ComponentException(responseFormat);
2524 ResponseFormat addRelationToRiRes = addRelationToRI(yamlName, service, entry.getValue(), relations);
2525 if (addRelationToRiRes.getStatus() != 200) {
2526 throw new ComponentException(addRelationToRiRes);
2531 protected ResponseFormat addRelationToRI(String yamlName, Service service, UploadComponentInstanceInfo nodesInfoValue,
2532 List<RequirementCapabilityRelDef> relations) {
2533 List<ComponentInstance> componentInstancesList = service.getComponentInstances();
2534 ComponentInstance currentCompInstance = null;
2535 for (ComponentInstance compInstance : componentInstancesList) {
2536 if (compInstance.getName().equals(nodesInfoValue.getName())) {
2537 currentCompInstance = compInstance;
2541 if (currentCompInstance == null) {
2542 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, nodesInfoValue.getName(), service.getUniqueId());
2543 BeEcompErrorManager.getInstance()
2544 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + nodesInfoValue.getName() + IN_RESOURCE, service.getUniqueId(),
2545 BeEcompErrorManager.ErrorSeverity.ERROR);
2546 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2548 String resourceInstanceId = currentCompInstance.getUniqueId();
2549 Map<String, List<UploadReqInfo>> regMap = nodesInfoValue.getRequirements();
2550 if (regMap != null) {
2551 Iterator<Map.Entry<String, List<UploadReqInfo>>> nodesRegValue = regMap.entrySet().iterator();
2552 while (nodesRegValue.hasNext()) {
2553 Map.Entry<String, List<UploadReqInfo>> nodesRegInfoEntry = nodesRegValue.next();
2554 List<UploadReqInfo> uploadRegInfoList = nodesRegInfoEntry.getValue();
2555 for (UploadReqInfo uploadRegInfo : uploadRegInfoList) {
2556 log.debug("Going to create relation {}", uploadRegInfo.getName());
2557 String regName = uploadRegInfo.getName();
2558 RequirementCapabilityRelDef regCapRelDef = new RequirementCapabilityRelDef();
2559 regCapRelDef.setFromNode(resourceInstanceId);
2560 log.debug("try to find available requirement {} ", regName);
2561 Either<RequirementDefinition, ResponseFormat> eitherReqStatus = serviceImportParseLogic
2562 .findAvailableRequirement(regName, yamlName, nodesInfoValue, currentCompInstance, uploadRegInfo.getCapabilityName());
2563 if (eitherReqStatus.isRight()) {
2564 log.debug("failed to find available requirement {} status is {}", regName, eitherReqStatus.right().value());
2565 return eitherReqStatus.right().value();
2567 RequirementDefinition validReq = eitherReqStatus.left().value();
2568 List<CapabilityRequirementRelationship> reqAndRelationshipPairList = regCapRelDef.getRelationships();
2569 if (reqAndRelationshipPairList == null) {
2570 reqAndRelationshipPairList = new ArrayList<>();
2572 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
2573 reqAndRelationshipPair.setRequirement(regName);
2574 reqAndRelationshipPair.setRequirementOwnerId(validReq.getOwnerId());
2575 reqAndRelationshipPair.setRequirementUid(validReq.getUniqueId());
2576 RelationshipImpl relationship = new RelationshipImpl();
2577 relationship.setType(validReq.getCapability());
2578 reqAndRelationshipPair.setRelationships(relationship);
2579 ComponentInstance currentCapCompInstance = null;
2580 for (ComponentInstance compInstance : componentInstancesList) {
2581 if (compInstance.getName().equals(uploadRegInfo.getNode())) {
2582 currentCapCompInstance = compInstance;
2586 if (currentCapCompInstance == null) {
2587 log.debug("The component instance with name {} not found on resource {} ", uploadRegInfo.getNode(), service.getUniqueId());
2588 BeEcompErrorManager.getInstance()
2589 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadRegInfo.getNode() + IN_RESOURCE, service.getUniqueId(),
2590 BeEcompErrorManager.ErrorSeverity.ERROR);
2591 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2593 regCapRelDef.setToNode(currentCapCompInstance.getUniqueId());
2594 log.debug("try to find aviable Capability req name is {} ", validReq.getName());
2595 CapabilityDefinition aviableCapForRel = serviceImportParseLogic
2596 .findAvailableCapabilityByTypeOrName(validReq, currentCapCompInstance, uploadRegInfo);
2597 if (aviableCapForRel == null) {
2598 BeEcompErrorManager.getInstance().logInternalDataError(
2599 "aviable capability was not found. req name is " + validReq.getName() + " component instance is " + currentCapCompInstance
2600 .getUniqueId(), service.getUniqueId(), BeEcompErrorManager.ErrorSeverity.ERROR);
2601 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2603 reqAndRelationshipPair.setCapability(aviableCapForRel.getName());
2604 reqAndRelationshipPair.setCapabilityUid(aviableCapForRel.getUniqueId());
2605 reqAndRelationshipPair.setCapabilityOwnerId(aviableCapForRel.getOwnerId());
2606 CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship();
2607 capReqRel.setRelation(reqAndRelationshipPair);
2608 if (StringUtils.isNotEmpty(uploadRegInfo.getRelationshipTemplate())) {
2609 capReqRel.setOperations(getOperations(nodesInfoValue.getOperations(), uploadRegInfo.getRelationshipTemplate()));
2611 reqAndRelationshipPairList.add(capReqRel);
2612 regCapRelDef.setRelationships(reqAndRelationshipPairList);
2613 relations.add(regCapRelDef);
2617 return componentsUtils.getResponseFormat(ActionStatus.OK, yamlName);
2620 private List<OperationUi> getOperations(final Map<String, List<OperationUi>> operations, final String relationshipTemplate) {
2621 final List<OperationUi> operationUiList = new ArrayList<>();
2622 operations.forEach((operationKey, operationValues) -> {
2623 if (operationKey.equals(relationshipTemplate)) {
2624 operationUiList.addAll(operationValues);
2627 return operationUiList;
2630 protected Service getResourceAfterCreateRelations(Service service) {
2631 ComponentParametersView parametersView = serviceImportParseLogic.getComponentFilterAfterCreateRelations();
2632 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId(), parametersView);
2633 if (eitherGetResource.isRight()) {
2634 serviceImportParseLogic.throwComponentExceptionByResource(eitherGetResource.right().value(), service);
2636 return eitherGetResource.left().value();
2639 protected Service createServiceInstances(String yamlName, Service service, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
2640 Map<String, Resource> nodeNamespaceMap) {
2641 Either<Resource, ResponseFormat> eitherResource = null;
2642 log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
2643 if (MapUtils.isEmpty(uploadResInstancesMap)) { // PNF can have no resource instances
2644 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
2645 throw new ComponentException(responseFormat);
2647 Map<String, Resource> existingNodeTypeMap = new HashMap<>();
2648 if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
2649 nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v));
2651 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
2652 uploadResInstancesMap.values()
2653 .forEach(i -> createAndAddResourceInstance(i, yamlName, service, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap));
2654 if (MapUtils.isNotEmpty(resourcesInstancesMap)) {
2656 toscaOperationFacade.associateComponentInstancesToComponent(service, resourcesInstancesMap, false, false);
2657 } catch (StorageException exp) {
2658 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
2659 log.debug("Failed to add component instances to container component {}", service.getName());
2660 ResponseFormat responseFormat = componentsUtils
2661 .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
2662 eitherResource = Either.right(responseFormat);
2663 throw new ComponentException(eitherResource.right().value());
2667 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade
2668 .getToscaElement(service.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter());
2669 log.debug("*************finished to get resource {}", service.getUniqueId());
2670 if (eitherGetResource.isRight()) {
2671 ResponseFormat responseFormat = componentsUtils
2672 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service,
2673 ComponentTypeEnum.SERVICE);
2674 throw new ComponentException(responseFormat);
2676 if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances())) { // PNF can have no resource instances
2677 log.debug("Error when create resource instance from csar. ComponentInstances list empty");
2678 BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty");
2679 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
2681 return eitherGetResource.left().value();
2684 protected void createAndAddResourceInstance(UploadComponentInstanceInfo uploadComponentInstanceInfo, String yamlName, Component component,
2685 Map<String, Resource> nodeNamespaceMap, Map<String, Resource> existingnodeTypeMap,
2686 Map<ComponentInstance, Resource> resourcesInstancesMap) {
2687 log.debug("*************Going to create resource instances {}", uploadComponentInstanceInfo.getName());
2689 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
2690 uploadComponentInstanceInfo.setType(nodeNamespaceMap.get(uploadComponentInstanceInfo.getType()).getToscaResourceName());
2692 Resource refResource =
2693 validateResourceInstanceBeforeCreate(yamlName, component.getModel(), uploadComponentInstanceInfo, existingnodeTypeMap);
2694 ComponentInstance componentInstance = new ComponentInstance();
2695 componentInstance.setComponentUid(refResource.getUniqueId());
2696 Collection<String> directives = uploadComponentInstanceInfo.getDirectives();
2697 if (directives != null && !directives.isEmpty()) {
2698 componentInstance.setDirectives(new ArrayList<>(directives));
2700 UploadNodeFilterInfo uploadNodeFilterInfo = uploadComponentInstanceInfo.getUploadNodeFilterInfo();
2701 if (uploadNodeFilterInfo != null) {
2703 .setNodeFilter(new CINodeFilterUtils().getNodeFilterDataDefinition(uploadNodeFilterInfo, componentInstance.getUniqueId()));
2705 ComponentTypeEnum containerComponentType = component.getComponentType();
2706 NodeTypeEnum containerNodeType = containerComponentType.getNodeType();
2707 if (containerNodeType.equals(NodeTypeEnum.Resource) && MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities()) && MapUtils
2708 .isNotEmpty(refResource.getCapabilities())) {
2709 serviceImportParseLogic.setCapabilityNamesTypes(refResource.getCapabilities(), uploadComponentInstanceInfo.getCapabilities());
2710 Map<String, List<CapabilityDefinition>> validComponentInstanceCapabilities = serviceImportParseLogic
2711 .getValidComponentInstanceCapabilities(refResource.getUniqueId(), refResource.getCapabilities(),
2712 uploadComponentInstanceInfo.getCapabilities());
2713 componentInstance.setCapabilities(validComponentInstanceCapabilities);
2715 if (!existingnodeTypeMap.containsKey(uploadComponentInstanceInfo.getType())) {
2716 ResponseFormat responseFormat = componentsUtils
2717 .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(),
2718 uploadComponentInstanceInfo.getType());
2719 throw new ComponentException(responseFormat);
2721 Resource origResource = existingnodeTypeMap.get(uploadComponentInstanceInfo.getType());
2722 componentInstance.setName(uploadComponentInstanceInfo.getName());
2723 componentInstance.setIcon(origResource.getIcon());
2724 componentInstance.setMinOccurrences(uploadComponentInstanceInfo.getMinOccurrences());
2725 componentInstance.setMaxOccurrences(uploadComponentInstanceInfo.getMaxOccurrences());
2726 componentInstance.setInstanceCount(uploadComponentInstanceInfo.getInstanceCount());
2727 resourcesInstancesMap.put(componentInstance, origResource);
2728 } catch (final ComponentException e) {
2730 } catch (final Exception e) {
2731 throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
2735 protected Resource validateResourceInstanceBeforeCreate(String yamlName, String model, UploadComponentInstanceInfo uploadComponentInstanceInfo,
2736 Map<String, Resource> nodeNamespaceMap) {
2737 Resource refResource;
2739 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
2740 refResource = nodeNamespaceMap.get(uploadComponentInstanceInfo.getType());
2742 final Either<Component, StorageOperationStatus> resourceEither =
2743 toscaOperationFacade.getLatestByToscaResourceName(uploadComponentInstanceInfo.getType(), model);
2744 if (resourceEither.isRight()) {
2745 ResponseFormat responseFormat = componentsUtils
2746 .getResponseFormat(componentsUtils.convertFromStorageResponse(resourceEither.right().value()));
2747 throw new ComponentException(responseFormat);
2749 refResource = (Resource) resourceEither.left().value();
2750 nodeNamespaceMap.put(refResource.getToscaResourceName(), refResource);
2752 String componentState = refResource.getComponentMetadataDefinition().getMetadataDataDefinition().getState();
2753 if (componentState.equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
2754 ResponseFormat responseFormat = componentsUtils
2755 .getResponseFormat(ActionStatus.ILLEGAL_COMPONENT_STATE, refResource.getComponentType().getValue(), refResource.getName(),
2757 throw new ComponentException(responseFormat);
2759 if (!ModelConverter.isAtomicComponent(refResource) && refResource.getResourceType() != ResourceTypeEnum.VF) {
2760 log.debug("validateResourceInstanceBeforeCreate - ref resource type is ", refResource.getResourceType());
2761 ResponseFormat responseFormat = componentsUtils
2762 .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(),
2763 uploadComponentInstanceInfo.getType());
2764 throw new ComponentException(responseFormat);
2767 } catch (final ComponentException e) {
2769 } catch (final Exception e) {
2770 throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
2774 protected void handleServiceNodeTypes(String yamlName, Service service, String topologyTemplateYaml, boolean needLock,
2775 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2776 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo,
2777 CsarInfo csarInfo, String nodeName) {
2779 for (Map.Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
2780 boolean isResourceNotExisted = validateResourceNotExisted(nodeTypeEntry.getKey());
2781 if (nodeTypeEntry.getValue().isNested() && isResourceNotExisted) {
2782 handleNestedVF(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
2783 nodeTypeEntry.getKey());
2784 log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
2787 Map<String, Object> mappedToscaTemplate = null;
2788 if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo
2789 .containsKey(nodeName)) {
2790 mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
2792 if (MapUtils.isEmpty(mappedToscaTemplate)) {
2793 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
2795 createResourcesFromYamlNodeTypesList(yamlName, service, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle,
2796 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
2797 } catch (ComponentException | StorageException e) {
2799 } catch (Exception e) {
2800 log.debug("Exception occured when handleServiceNodeTypes, error is:{}", e.getMessage(), e);
2801 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2805 protected boolean validateResourceNotExisted(String type) {
2807 Either<Resource, StorageOperationStatus> latestResource = toscaOperationFacade.getLatestResourceByToscaResourceName(type);
2808 return latestResource.isRight();
2809 } catch (Exception e) {
2810 log.debug("Exception occured when validateResourceNotExisted, error is:{}", e.getMessage(), e);
2811 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2815 protected Resource handleNestedVF(Service service,
2816 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2817 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
2820 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
2821 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
2822 createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
2824 log.debug("************* Finished to create node types from yaml {}", yamlName);
2825 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
2826 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
2827 return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
2829 return new Resource();
2830 } catch (Exception e) {
2831 log.debug("Exception occured when handleNestedVF, error is:{}", e.getMessage(), e);
2832 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2836 protected Resource handleComplexVfc(
2837 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2838 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName) {
2840 Resource oldComplexVfc = null;
2841 Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(csarInfo, nodeName, nodesInfo);
2842 Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
2843 .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
2844 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
2845 oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
2846 serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), nodeName)
2849 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
2850 log.debug("Failed to fetch previous complex VFC by tosca resource name {}. Status is {}. ", newComplexVfc.getToscaResourceName(),
2851 oldComplexVfcRes.right().value());
2852 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2853 } else if (oldComplexVfcRes.isLeft()) {
2854 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
2855 Either<Boolean, ResponseFormat> eitherValidation = serviceImportParseLogic
2856 .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc,
2857 ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
2858 if (eitherValidation.isLeft()) {
2859 oldComplexVfc = oldComplexVfcRes.left().value();
2862 newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc,
2864 csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
2865 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
2866 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR);
2867 log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
2868 final Resource result = serviceImportParseLogic
2869 .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true);
2870 csarInfo.getCreatedNodes().put(nodeName, result);
2871 csarInfo.removeNodeFromQueue();
2873 } catch (Exception e) {
2874 log.debug("Exception occured when handleComplexVfc, error is:{}", e.getMessage(), e);
2875 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2879 protected Resource handleComplexVfc(
2880 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2881 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName,
2882 Resource oldComplexVfc, Resource newComplexVfc) {
2883 Resource handleComplexVfcRes;
2885 Map<String, Object> mappedToscaTemplate = nodesInfo.get(nodeName).getMappedToscaTemplate();
2886 String yamlContent = new String(csarInfo.getCsar().get(yamlName));
2887 Map<String, NodeTypeInfo> newNodeTypesInfo = nodesInfo.entrySet().stream()
2888 .collect(toMap(Map.Entry::getKey, e -> e.getValue().getUnmarkedCopy()));
2889 CsarInfo.markNestedVfc(mappedToscaTemplate, newNodeTypesInfo);
2890 if (oldComplexVfc == null) {
2891 handleComplexVfcRes = createResourceFromYaml(newComplexVfc, yamlContent, yamlName, newNodeTypesInfo, csarInfo, nodesArtifactsToHandle,
2892 false, true, nodeName);
2894 handleComplexVfcRes = updateResourceFromYaml(oldComplexVfc, newComplexVfc, AuditingActionEnum.UPDATE_RESOURCE_METADATA,
2895 createdArtifacts, yamlContent, yamlName, csarInfo, newNodeTypesInfo, nodesArtifactsToHandle, nodeName, true);
2897 return handleComplexVfcRes;
2898 } catch (Exception e) {
2899 log.debug("Exception occured when handleComplexVfc, error is:{}", e.getMessage(), e);
2900 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2904 protected Resource updateResourceFromYaml(Resource oldRresource, Resource newRresource, AuditingActionEnum actionEnum,
2905 List<ArtifactDefinition> createdArtifacts, String yamlFileName, String yamlFileContent,
2906 CsarInfo csarInfo, Map<String, NodeTypeInfo> nodeTypesInfo,
2907 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2908 String nodeName, boolean isNested) {
2909 boolean inTransaction = true;
2910 boolean shouldLock = false;
2911 Resource preparedResource = null;
2912 ParsedToscaYamlInfo uploadComponentInstanceInfoMap = null;
2914 uploadComponentInstanceInfoMap = csarBusinessLogic
2915 .getParsedToscaYamlInfo(yamlFileContent, yamlFileName, nodeTypesInfo, csarInfo, nodeName, oldRresource);
2916 Map<String, UploadComponentInstanceInfo> instances = uploadComponentInstanceInfoMap.getInstances();
2917 if (MapUtils.isEmpty(instances) && newRresource.getResourceType() != ResourceTypeEnum.PNF) {
2918 throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlFileName);
2920 preparedResource = updateExistingResourceByImport(newRresource, oldRresource, csarInfo.getModifier(), inTransaction, shouldLock,
2922 log.trace("YAML topology file found in CSAR, file name: {}, contents: {}", yamlFileName, yamlFileContent);
2923 serviceImportParseLogic.handleResourceGenericType(preparedResource);
2924 handleNodeTypes(yamlFileName, preparedResource, yamlFileContent, shouldLock, nodeTypesArtifactsToHandle, createdArtifacts, nodeTypesInfo,
2925 csarInfo, nodeName);
2926 preparedResource = serviceImportParseLogic.createInputsOnResource(preparedResource, uploadComponentInstanceInfoMap.getInputs());
2927 preparedResource = createResourceInstances(yamlFileName, preparedResource, instances, csarInfo.getCreatedNodes());
2928 preparedResource = createResourceInstancesRelations(csarInfo.getModifier(), yamlFileName, preparedResource, instances);
2929 } catch (ComponentException e) {
2930 ResponseFormat responseFormat =
2931 e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
2932 log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat);
2934 .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum);
2936 } catch (StorageException e) {
2937 ResponseFormat responseFormat = componentsUtils
2938 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
2939 log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat);
2941 .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum);
2944 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic.validateUpdateVfGroupNames(
2945 uploadComponentInstanceInfoMap.getGroups(), preparedResource.getSystemName());
2946 if (validateUpdateVfGroupNamesRes.isRight()) {
2947 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
2949 Map<String, GroupDefinition> groups;
2950 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
2951 groups = validateUpdateVfGroupNamesRes.left().value();
2953 groups = uploadComponentInstanceInfoMap.getGroups();
2955 serviceImportParseLogic.handleGroupsProperties(preparedResource, groups);
2956 preparedResource = serviceImportParseLogic.updateGroupsOnResource(preparedResource, groups);
2957 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToHandle);
2958 Either<Resource, ResponseFormat> updateArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE,
2959 createdArtifacts, yamlFileName, csarInfo, preparedResource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
2960 if (updateArtifactsEither.isRight()) {
2961 log.debug("failed to update artifacts {}", updateArtifactsEither.right().value());
2962 throw new ComponentException(updateArtifactsEither.right().value());
2964 preparedResource = serviceImportParseLogic.getResourceWithGroups(updateArtifactsEither.left().value().getUniqueId());
2965 ActionStatus mergingPropsAndInputsStatus = resourceDataMergeBusinessLogic.mergeResourceEntities(oldRresource, preparedResource);
2966 if (mergingPropsAndInputsStatus != ActionStatus.OK) {
2967 ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(mergingPropsAndInputsStatus, preparedResource);
2968 throw new ComponentException(responseFormat);
2970 compositionBusinessLogic.setPositionsForComponentInstances(preparedResource, csarInfo.getModifier().getUserId());
2971 return preparedResource;
2974 protected Resource createResourceFromYaml(Resource resource, String topologyTemplateYaml, String yamlName,
2975 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
2976 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
2977 boolean shouldLock, boolean inTransaction, String nodeName) {
2978 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
2979 Resource createdResource;
2981 ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic
2982 .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, resource);
2983 if (MapUtils.isEmpty(parsedToscaYamlInfo.getInstances()) && resource.getResourceType() != ResourceTypeEnum.PNF) {
2984 throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2986 log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", resource.getName());
2987 createdResource = createResourceAndRIsFromYaml(yamlName, resource, parsedToscaYamlInfo, AuditingActionEnum.IMPORT_RESOURCE, false,
2988 createdArtifacts, topologyTemplateYaml, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName);
2989 log.debug("#createResourceFromYaml - The resource {} has been created ", resource.getName());
2990 } catch (ComponentException e) {
2991 ResponseFormat responseFormat =
2992 e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
2993 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
2995 } catch (StorageException e) {
2996 ResponseFormat responseFormat = componentsUtils
2997 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
2998 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
3001 return createdResource;
3004 protected Resource createResourceAndRIsFromYaml(String yamlName, Resource resource, ParsedToscaYamlInfo parsedToscaYamlInfo,
3005 AuditingActionEnum actionEnum, boolean isNormative, List<ArtifactDefinition> createdArtifacts,
3006 String topologyTemplateYaml, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
3007 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
3008 boolean shouldLock, boolean inTransaction, String nodeName) {
3009 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
3011 Either<Boolean, ResponseFormat> lockResult = serviceBusinessLogic
3012 .lockComponentByName(resource.getSystemName(), resource, CREATE_RESOURCE);
3013 if (lockResult.isRight()) {
3014 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
3015 throw new ComponentException(lockResult.right().value());
3017 log.debug("name is locked {} status = {}", resource.getSystemName(), lockResult);
3020 log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
3021 Resource genericResource = serviceBusinessLogic.fetchAndSetDerivedFromGenericType(resource);
3022 resource = createResourceTransaction(resource, csarInfo.getModifier(), isNormative);
3023 log.trace("************* Going to add inputs from yaml {}", yamlName);
3024 Map<String, Object> yamlMap = ImportUtils.loadYamlAsStrictMap(csarInfo.getMainTemplateContent());
3025 Map<String, Object> metadata = (Map<String, Object>) yamlMap.get("metadata");
3026 String type = (String) metadata.get("type");
3027 if (resource.shouldGenerateInputs() && !"Service".equalsIgnoreCase(type)) {
3028 serviceBusinessLogic.generateAndAddInputsFromGenericTypeProperties(resource, genericResource);
3030 Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
3031 resource = serviceImportParseLogic.createInputsOnResource(resource, inputs);
3032 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances();
3033 resource = createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap, topologyTemplateYaml,
3034 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName);
3035 log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName);
3036 // validate update vf module group names
3037 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic.validateUpdateVfGroupNames(
3038 parsedToscaYamlInfo.getGroups(), resource.getSystemName());
3039 if (validateUpdateVfGroupNamesRes.isRight()) {
3040 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
3041 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
3043 Map<String, GroupDefinition> groups;
3044 log.trace("************* Going to add groups from yaml {}", yamlName);
3045 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
3046 groups = validateUpdateVfGroupNamesRes.left().value();
3048 groups = parsedToscaYamlInfo.getGroups();
3050 Either<Resource, ResponseFormat> createGroupsOnResource = createGroupsOnResource(resource, groups);
3051 if (createGroupsOnResource.isRight()) {
3052 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
3053 throw new ComponentException(createGroupsOnResource.right().value());
3055 resource = createGroupsOnResource.left().value();
3056 log.trace("************* Going to add artifacts from yaml {}", yamlName);
3057 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
3058 Either<Resource, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
3059 createdArtifacts, yamlName, csarInfo, resource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
3060 if (createArtifactsEither.isRight()) {
3061 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
3062 throw new ComponentException(createArtifactsEither.right().value());
3064 resource = serviceImportParseLogic.getResourceWithGroups(createArtifactsEither.left().value().getUniqueId());
3065 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.CREATED);
3066 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, actionEnum);
3067 ASDCKpiApi.countCreatedResourcesKPI();
3069 } catch (ComponentException | StorageException e) {
3070 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
3073 if (!inTransaction) {
3074 janusGraphDao.commit();
3077 graphLockOperation.unlockComponentByName(resource.getSystemName(), resource.getUniqueId(), NodeTypeEnum.Resource);
3082 protected Either<Resource, ResponseFormat> createGroupsOnResource(Resource resource, Map<String, GroupDefinition> groups) {
3083 if (groups != null && !groups.isEmpty()) {
3084 List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, resource);
3085 serviceImportParseLogic.handleGroupsProperties(resource, groups);
3086 serviceImportParseLogic.fillGroupsFinalFields(groupsAsList);
3087 Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic.createGroups(resource, groupsAsList, true);
3088 if (createGroups.isRight()) {
3089 return Either.right(createGroups.right().value());
3092 return Either.left(resource);
3094 Either<Resource, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
3095 if (updatedResource.isRight()) {
3096 ResponseFormat responseFormat = componentsUtils
3097 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), resource);
3098 return Either.right(responseFormat);
3100 return Either.left(updatedResource.left().value());
3103 protected List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups, Resource component) {
3104 List<GroupDefinition> result = new ArrayList<>();
3105 List<ComponentInstance> componentInstances = component.getComponentInstances();
3106 if (groups != null) {
3107 for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
3108 String groupName = entry.getKey();
3109 GroupDefinition groupDefinition = entry.getValue();
3110 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
3111 updatedGroupDefinition.setMembers(null);
3112 Map<String, String> members = groupDefinition.getMembers();
3113 if (members != null) {
3114 updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
3116 result.add(updatedGroupDefinition);
3122 protected void updateGroupMembers(Map<String, GroupDefinition> groups, GroupDefinition updatedGroupDefinition, Resource component,
3123 List<ComponentInstance> componentInstances, String groupName, Map<String, String> members) {
3124 Set<String> compInstancesNames = members.keySet();
3125 if (CollectionUtils.isEmpty(componentInstances)) {
3126 String membersAstString = compInstancesNames.stream().collect(joining(","));
3127 log.debug("The members: {}, in group: {}, cannot be found in component {}. There are no component instances.", membersAstString,
3128 groupName, component.getNormalizedName());
3129 throw new ComponentException(componentsUtils
3130 .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(),
3131 serviceImportParseLogic.getComponentTypeForResponse(component)));
3133 Map<String, String> memberNames = componentInstances.stream().collect(toMap(ComponentInstance::getName, ComponentInstance::getUniqueId));
3134 memberNames.putAll(groups.keySet().stream().collect(toMap(g -> g, g -> "")));
3135 Map<String, String> relevantInstances = memberNames.entrySet().stream().filter(n -> compInstancesNames.contains(n.getKey()))
3136 .collect(toMap(Map.Entry::getKey, Map.Entry::getValue));
3137 if (relevantInstances == null || relevantInstances.size() != compInstancesNames.size()) {
3138 List<String> foundMembers = new ArrayList<>();
3139 if (relevantInstances != null) {
3140 foundMembers = relevantInstances.keySet().stream().collect(toList());
3142 compInstancesNames.removeAll(foundMembers);
3143 String membersAstString = compInstancesNames.stream().collect(joining(","));
3144 throw new ComponentException(componentsUtils
3145 .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(),
3146 serviceImportParseLogic.getComponentTypeForResponse(component)));
3148 updatedGroupDefinition.setMembers(relevantInstances);
3151 protected Resource createResourceTransaction(Resource resource, User user, boolean isNormative) {
3152 Either<Boolean, StorageOperationStatus> eitherValidation = toscaOperationFacade
3153 .validateComponentNameExists(resource.getName(), resource.getResourceType(), resource.getComponentType());
3154 if (eitherValidation.isRight()) {
3155 ResponseFormat errorResponse = componentsUtils
3156 .getResponseFormat(componentsUtils.convertFromStorageResponse(eitherValidation.right().value()));
3157 throw new ComponentException(errorResponse);
3159 if (Boolean.TRUE.equals(eitherValidation.left().value())) {
3160 log.debug("resource with name: {}, already exists", resource.getName());
3161 ResponseFormat errorResponse = componentsUtils
3162 .getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resource.getName());
3163 throw new ComponentException(errorResponse);
3165 log.debug("send resource {} to dao for create", resource.getName());
3166 serviceImportParseLogic.createArtifactsPlaceHolderData(resource, user);
3168 log.debug("enrich resource with creator, version and state");
3169 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
3170 resource.setVersion(INITIAL_VERSION);
3171 resource.setHighestVersion(true);
3172 if (resource.getResourceType() != null && resource.getResourceType() != ResourceTypeEnum.VF) {
3173 resource.setAbstract(false);
3176 return toscaOperationFacade.createToscaComponent(resource).left()
3177 .on(r -> serviceImportParseLogic.throwComponentExceptionByResource(r, resource));
3180 protected ImmutablePair<Resource, ActionStatus> updateExistingResourceByImport(Resource newResource, Resource oldResource, User user,
3181 boolean inTransaction, boolean needLock, boolean isNested) {
3182 String lockedResourceId = oldResource.getUniqueId();
3183 log.debug("found resource: name={}, id={}, version={}, state={}", oldResource.getName(), lockedResourceId, oldResource.getVersion(),
3184 oldResource.getLifecycleState());
3185 ImmutablePair<Resource, ActionStatus> resourcePair = null;
3187 serviceBusinessLogic.lockComponent(lockedResourceId, oldResource, needLock, "Update Resource by Import");
3188 oldResource = serviceImportParseLogic.prepareResourceForUpdate(oldResource, newResource, user, inTransaction, false);
3189 serviceImportParseLogic.mergeOldResourceMetadataWithNew(oldResource, newResource);
3190 serviceImportParseLogic.validateResourceFieldsBeforeUpdate(oldResource, newResource, inTransaction, isNested);
3191 serviceImportParseLogic.validateCapabilityTypesCreate(user, serviceImportParseLogic.getCapabilityTypeOperation(), newResource,
3192 AuditingActionEnum.IMPORT_RESOURCE, inTransaction);
3193 createNewResourceToOldResource(newResource, oldResource, user);
3194 Either<Resource, StorageOperationStatus> overrideResource = toscaOperationFacade.overrideComponent(newResource, oldResource);
3195 if (overrideResource.isRight()) {
3196 ResponseFormat responseFormat = new ResponseFormat();
3197 serviceBusinessLogic.throwComponentException(responseFormat);
3199 log.debug("Resource updated successfully!!!");
3200 resourcePair = new ImmutablePair<>(overrideResource.left().value(), ActionStatus.OK);
3201 return resourcePair;
3203 if (resourcePair == null) {
3204 BeEcompErrorManager.getInstance().logBeSystemError("Change LifecycleState - Certify");
3205 janusGraphDao.rollback();
3206 } else if (!inTransaction) {
3207 janusGraphDao.commit();
3210 log.debug("unlock resource {}", lockedResourceId);
3211 graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource);
3216 protected void createNewResourceToOldResource(Resource newResource, Resource oldResource, User user) {
3217 newResource.setContactId(newResource.getContactId().toLowerCase());
3218 newResource.setCreatorUserId(user.getUserId());
3219 newResource.setCreatorFullName(user.getFullName());
3220 newResource.setLastUpdaterUserId(user.getUserId());
3221 newResource.setLastUpdaterFullName(user.getFullName());
3222 newResource.setUniqueId(oldResource.getUniqueId());
3223 newResource.setVersion(oldResource.getVersion());
3224 newResource.setInvariantUUID(oldResource.getInvariantUUID());
3225 newResource.setLifecycleState(oldResource.getLifecycleState());
3226 newResource.setUUID(oldResource.getUUID());
3227 newResource.setNormalizedName(oldResource.getNormalizedName());
3228 newResource.setSystemName(oldResource.getSystemName());
3229 if (oldResource.getCsarUUID() != null) {
3230 newResource.setCsarUUID(oldResource.getCsarUUID());
3232 if (oldResource.getCsarVersionId() != null) {
3233 newResource.setCsarVersionId(oldResource.getCsarVersionId());
3235 if (oldResource.getImportedToscaChecksum() != null) {
3236 newResource.setImportedToscaChecksum(oldResource.getImportedToscaChecksum());
3238 if (newResource.getDerivedFromGenericType() == null || newResource.getDerivedFromGenericType().isEmpty()) {
3239 newResource.setDerivedFromGenericType(oldResource.getDerivedFromGenericType());
3241 if (newResource.getDerivedFromGenericVersion() == null || newResource.getDerivedFromGenericVersion().isEmpty()) {
3242 newResource.setDerivedFromGenericVersion(oldResource.getDerivedFromGenericVersion());
3244 if (newResource.getToscaArtifacts() == null || newResource.getToscaArtifacts().isEmpty()) {
3245 serviceBusinessLogic.setToscaArtifactsPlaceHolders(newResource, user);
3247 if (newResource.getInterfaces() == null || newResource.getInterfaces().isEmpty()) {
3248 newResource.setInterfaces(oldResource.getInterfaces());
3250 if (CollectionUtils.isEmpty(newResource.getProperties())) {
3251 newResource.setProperties(oldResource.getProperties());
3253 if (newResource.getModel() == null) {
3254 newResource.setModel(oldResource.getModel());
3258 protected Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Service service, Map<String, Object> mappedToscaTemplate,
3260 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
3261 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
3262 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
3264 Either<String, ImportUtils.ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
3265 TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
3266 if (toscaVersion.isRight()) {
3267 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
3269 Map<String, Object> mapToConvert = new HashMap<>();
3270 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value());
3271 Map<String, Object> nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate);
3272 createNodeTypes(yamlName, service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
3273 mapToConvert, nodeTypes);
3274 return csarInfo.getCreatedNodes();
3275 } catch (Exception e) {
3276 log.debug("Exception occured when createResourcesFromYamlNodeTypesList,error is:{}", e.getMessage(), e);
3277 throw new ComponentException(ActionStatus.GENERAL_ERROR);
3281 protected void createNodeTypes(String yamlName, Service service, boolean needLock,
3282 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
3283 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
3284 Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
3285 Iterator<Map.Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet().iterator();
3286 Resource vfcCreated = null;
3287 while (nodesNameValueIter.hasNext()) {
3288 Map.Entry<String, Object> nodeType = nodesNameValueIter.next();
3289 String nodeTypeKey = nodeType.getKey();
3290 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle =
3291 nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeTypeKey);
3292 if (nodeTypesInfo.containsKey(nodeTypeKey)) {
3293 vfcCreated = handleNestedVfc(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
3295 log.trace("************* Finished to handle nested vfc {}", nodeTypeKey);
3296 } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames()
3297 .containsKey(nodeTypeKey)) {
3298 ImmutablePair<Resource, ActionStatus> resourceCreated = serviceImportParseLogic
3299 .createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(), mapToConvert, service, needLock,
3300 nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true);
3301 log.debug("************* Finished to create node {}", nodeTypeKey);
3302 vfcCreated = resourceCreated.getLeft();
3303 csarInfo.getCreatedNodesToscaResourceNames().put(nodeTypeKey, vfcCreated.getName());
3305 if (vfcCreated != null) {
3306 csarInfo.getCreatedNodes().put(nodeTypeKey, vfcCreated);
3308 mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());