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.
17 package org.openecomp.sdc.be.components.impl;
19 import static java.util.stream.Collectors.joining;
20 import static java.util.stream.Collectors.toList;
21 import static java.util.stream.Collectors.toMap;
22 import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
23 import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaMapElement;
24 import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaStringElement;
25 import static org.openecomp.sdc.be.components.impl.ImportUtils.getPropertyJsonStringValue;
26 import static org.openecomp.sdc.be.tosca.CsarUtils.VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN;
28 import com.google.gson.Gson;
29 import com.google.gson.JsonElement;
30 import com.google.gson.JsonObject;
31 import com.google.gson.JsonParser;
32 import fj.data.Either;
33 import java.lang.reflect.Method;
34 import java.util.ArrayList;
35 import java.util.Arrays;
36 import java.util.Collection;
37 import java.util.Collections;
38 import java.util.EnumMap;
39 import java.util.HashMap;
40 import java.util.HashSet;
41 import java.util.Iterator;
42 import java.util.LinkedHashMap;
43 import java.util.List;
45 import java.util.Map.Entry;
46 import java.util.Optional;
48 import java.util.TreeSet;
49 import java.util.concurrent.atomic.AtomicReference;
50 import java.util.regex.Pattern;
51 import java.util.stream.Collectors;
54 import org.apache.commons.collections.CollectionUtils;
55 import org.apache.commons.collections.MapUtils;
56 import org.apache.commons.lang3.StringEscapeUtils;
57 import org.apache.commons.lang3.StringUtils;
58 import org.apache.commons.lang3.tuple.ImmutablePair;
59 import org.json.simple.JSONObject;
60 import org.openecomp.sdc.be.components.csar.CsarArtifactsAndGroupsBusinessLogic;
61 import org.openecomp.sdc.be.components.csar.CsarBusinessLogic;
62 import org.openecomp.sdc.be.components.csar.CsarInfo;
63 import org.openecomp.sdc.be.components.csar.ServiceCsarInfo;
64 import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum;
65 import org.openecomp.sdc.be.components.impl.artifact.ArtifactOperationInfo;
66 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
67 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
68 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
69 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
70 import org.openecomp.sdc.be.components.impl.model.ToscaTypeImportData;
71 import org.openecomp.sdc.be.components.impl.utils.CINodeFilterUtils;
72 import org.openecomp.sdc.be.components.impl.utils.CreateServiceFromYamlParameter;
73 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
74 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
75 import org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic;
76 import org.openecomp.sdc.be.config.BeEcompErrorManager;
77 import org.openecomp.sdc.be.config.ConfigurationManager;
78 import org.openecomp.sdc.be.dao.api.ActionStatus;
79 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
80 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
81 import org.openecomp.sdc.be.datamodel.utils.ArtifactUtils;
82 import org.openecomp.sdc.be.datatypes.elements.CustomYamlFunction;
83 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
84 import org.openecomp.sdc.be.datatypes.elements.ListCapabilityDataDefinition;
85 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
86 import org.openecomp.sdc.be.datatypes.elements.ListRequirementDataDefinition;
87 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
88 import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition;
89 import org.openecomp.sdc.be.datatypes.elements.PolicyDataDefinition;
90 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
91 import org.openecomp.sdc.be.datatypes.elements.SubPropertyToscaFunction;
92 import org.openecomp.sdc.be.datatypes.elements.SubstitutionFilterPropertyDataDefinition;
93 import org.openecomp.sdc.be.datatypes.elements.ToscaGetFunctionDataDefinition;
94 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
95 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
96 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
97 import org.openecomp.sdc.be.datatypes.tosca.ToscaGetFunctionType;
98 import org.openecomp.sdc.be.impl.ComponentsUtils;
99 import org.openecomp.sdc.be.info.NodeTypeInfoToUpdateArtifacts;
100 import org.openecomp.sdc.be.model.ArtifactDefinition;
101 import org.openecomp.sdc.be.model.ArtifactTypeDefinition;
102 import org.openecomp.sdc.be.model.AttributeDefinition;
103 import org.openecomp.sdc.be.model.CapabilityDefinition;
104 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
105 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
106 import org.openecomp.sdc.be.model.Component;
107 import org.openecomp.sdc.be.model.ComponentInstance;
108 import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
109 import org.openecomp.sdc.be.model.ComponentInstanceInput;
110 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
111 import org.openecomp.sdc.be.model.ComponentParametersView;
112 import org.openecomp.sdc.be.model.DataTypeDefinition;
113 import org.openecomp.sdc.be.model.DistributionStatusEnum;
114 import org.openecomp.sdc.be.model.GroupDefinition;
115 import org.openecomp.sdc.be.model.GroupTypeDefinition;
116 import org.openecomp.sdc.be.model.InputDefinition;
117 import org.openecomp.sdc.be.model.InterfaceDefinition;
118 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
119 import org.openecomp.sdc.be.model.LifecycleStateEnum;
120 import org.openecomp.sdc.be.model.NodeTypeDefinition;
121 import org.openecomp.sdc.be.model.NodeTypeInfo;
122 import org.openecomp.sdc.be.model.NodeTypeMetadata;
123 import org.openecomp.sdc.be.model.NodeTypesMetadataList;
124 import org.openecomp.sdc.be.model.Operation;
125 import org.openecomp.sdc.be.model.OutputDefinition;
126 import org.openecomp.sdc.be.model.ParsedToscaYamlInfo;
127 import org.openecomp.sdc.be.model.PolicyDefinition;
128 import org.openecomp.sdc.be.model.PropertyDefinition;
129 import org.openecomp.sdc.be.model.RelationshipImpl;
130 import org.openecomp.sdc.be.model.RelationshipInfo;
131 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
132 import org.openecomp.sdc.be.model.RequirementDefinition;
133 import org.openecomp.sdc.be.model.Resource;
134 import org.openecomp.sdc.be.model.Service;
135 import org.openecomp.sdc.be.model.UploadAttributeInfo;
136 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
137 import org.openecomp.sdc.be.model.UploadInterfaceInfo;
138 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
139 import org.openecomp.sdc.be.model.UploadPropInfo;
140 import org.openecomp.sdc.be.model.UploadReqInfo;
141 import org.openecomp.sdc.be.model.UploadResourceInfo;
142 import org.openecomp.sdc.be.model.User;
143 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
144 import org.openecomp.sdc.be.model.jsonjanusgraph.datamodel.ToscaElement;
145 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
146 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
147 import org.openecomp.sdc.be.model.normatives.ToscaTypeMetadata;
148 import org.openecomp.sdc.be.model.operations.StorageException;
149 import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
150 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
151 import org.openecomp.sdc.be.model.operations.impl.ArtifactTypeOperation;
152 import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
153 import org.openecomp.sdc.be.model.operations.impl.GroupTypeOperation;
154 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
155 import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
156 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
157 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
158 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
159 import org.openecomp.sdc.be.tosca.CsarUtils;
160 import org.openecomp.sdc.be.tosca.ToscaExportHandler;
161 import org.openecomp.sdc.be.ui.model.OperationUi;
162 import org.openecomp.sdc.be.utils.TypeUtils;
163 import org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum;
164 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
165 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
166 import org.openecomp.sdc.common.api.Constants;
167 import org.openecomp.sdc.common.datastructure.Wrapper;
168 import org.openecomp.sdc.common.kpi.api.ASDCKpiApi;
169 import org.openecomp.sdc.common.log.wrappers.Logger;
170 import org.openecomp.sdc.common.util.ValidationUtils;
171 import org.openecomp.sdc.exception.ResponseFormat;
172 import org.springframework.beans.factory.annotation.Autowired;
173 import org.yaml.snakeyaml.Yaml;
177 @org.springframework.stereotype.Component("serviceImportBusinessLogic")
178 public class ServiceImportBusinessLogic {
180 protected static final String CREATE_RESOURCE = "Create Resource";
181 private static final String INITIAL_VERSION = "0.1";
182 private static final String IN_RESOURCE = " in resource {} ";
183 private static final String COMPONENT_INSTANCE_WITH_NAME = "component instance with name ";
184 private static final String COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE = "component instance with name {} in resource {} ";
185 private static final String CERTIFICATION_ON_IMPORT = "certification on import";
186 private static final String VALIDATE_DERIVED_BEFORE_UPDATE = "validate derived before update";
187 private static final String PLACE_HOLDER_RESOURCE_TYPES = "validForResourceTypes";
188 private static final String CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES = "Create Resource - validateCapabilityTypesCreate";
189 private static final String CATEGORY_IS_EMPTY = "Resource category is empty";
190 private static final Logger log = Logger.getLogger(ServiceImportBusinessLogic.class);
192 private final ComponentsUtils componentsUtils;
193 private final ToscaOperationFacade toscaOperationFacade;
194 private final ServiceBusinessLogic serviceBusinessLogic;
195 private final CsarBusinessLogic csarBusinessLogic;
196 private final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic;
197 private final LifecycleBusinessLogic lifecycleBusinessLogic;
198 private final CompositionBusinessLogic compositionBusinessLogic;
199 private final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic;
200 private final ServiceImportParseLogic serviceImportParseLogic;
201 private final GroupBusinessLogic groupBusinessLogic;
202 private final PolicyBusinessLogic policyBusinessLogic;
203 private final ResourceImportManager resourceImportManager;
204 private final JanusGraphDao janusGraphDao;
205 private final ArtifactsBusinessLogic artifactsBusinessLogic;
206 private final ArtifactTypeImportManager artifactTypeImportManager;
207 private final IGraphLockOperation graphLockOperation;
208 private final ToscaFunctionService toscaFunctionService;
209 private final DataTypeBusinessLogic dataTypeBusinessLogic;
210 private final ArtifactTypeOperation artifactTypeOperation;
211 private final GroupTypeImportManager groupTypeImportManager;
212 private final GroupTypeOperation groupTypeOperation;
213 private final CapabilityTypeImportManager capabilityTypeImportManager;
214 private final CapabilityTypeOperation capabilityTypeOperation;
215 private ApplicationDataTypeCache applicationDataTypeCache;
216 private final InterfaceLifecycleOperation interfaceLifecycleTypeOperation;
217 private final InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager;
218 private final ModelOperation modelOperation;
220 public ServiceImportBusinessLogic(final GroupBusinessLogic groupBusinessLogic, final ArtifactsBusinessLogic artifactsBusinessLogic,
221 final ComponentsUtils componentsUtils, final ToscaOperationFacade toscaOperationFacade,
222 final ServiceBusinessLogic serviceBusinessLogic, final CsarBusinessLogic csarBusinessLogic,
223 final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic,
224 final LifecycleBusinessLogic lifecycleBusinessLogic, final CompositionBusinessLogic compositionBusinessLogic,
225 final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic,
226 final ServiceImportParseLogic serviceImportParseLogic, final PolicyBusinessLogic policyBusinessLogic,
227 final ResourceImportManager resourceImportManager, final JanusGraphDao janusGraphDao,
228 final IGraphLockOperation graphLockOperation, final ToscaFunctionService toscaFunctionService,
229 final DataTypeBusinessLogic dataTypeBusinessLogic, final ArtifactTypeOperation artifactTypeOperation,
230 final ArtifactTypeImportManager artifactTypeImportManager, final GroupTypeImportManager groupTypeImportManager,
231 final GroupTypeOperation groupTypeOperation,
232 final InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
233 final InterfaceLifecycleTypeImportManager interfaceLifecycleTypeImportManager,
234 final CapabilityTypeImportManager capabilityTypeImportManager,
235 final CapabilityTypeOperation capabilityTypeOperation,
236 final ModelOperation modelOperation) {
237 this.componentsUtils = componentsUtils;
238 this.toscaOperationFacade = toscaOperationFacade;
239 this.serviceBusinessLogic = serviceBusinessLogic;
240 this.csarBusinessLogic = csarBusinessLogic;
241 this.csarArtifactsAndGroupsBusinessLogic = csarArtifactsAndGroupsBusinessLogic;
242 this.lifecycleBusinessLogic = lifecycleBusinessLogic;
243 this.compositionBusinessLogic = compositionBusinessLogic;
244 this.resourceDataMergeBusinessLogic = resourceDataMergeBusinessLogic;
245 this.serviceImportParseLogic = serviceImportParseLogic;
246 this.groupBusinessLogic = groupBusinessLogic;
247 this.policyBusinessLogic = policyBusinessLogic;
248 this.resourceImportManager = resourceImportManager;
249 this.janusGraphDao = janusGraphDao;
250 this.artifactsBusinessLogic = artifactsBusinessLogic;
251 this.graphLockOperation = graphLockOperation;
252 this.toscaFunctionService = toscaFunctionService;
253 this.dataTypeBusinessLogic = dataTypeBusinessLogic;
254 this.artifactTypeOperation = artifactTypeOperation;
255 this.artifactTypeImportManager = artifactTypeImportManager;
256 this.groupTypeImportManager = groupTypeImportManager;
257 this.groupTypeOperation = groupTypeOperation;
258 this.interfaceLifecycleTypeOperation = interfaceLifecycleTypeOperation;
259 this.interfaceLifecycleTypeImportManager = interfaceLifecycleTypeImportManager;
260 this.capabilityTypeImportManager = capabilityTypeImportManager;
261 this.capabilityTypeOperation = capabilityTypeOperation;
262 this.modelOperation = modelOperation;
266 public void setApplicationDataTypeCache(ApplicationDataTypeCache applicationDataTypeCache) {
267 this.applicationDataTypeCache = applicationDataTypeCache;
270 public Service updateServiceFromToscaTemplate(final String serviceId, final User modifier, final String data) {
271 final Either<Service, ResponseFormat> serviceResponseFormatEither = serviceBusinessLogic.getService(serviceId, modifier);
272 if (serviceResponseFormatEither.isRight()) {
273 throw new ByActionStatusComponentException(ActionStatus.SERVICE_NOT_FOUND, serviceId);
275 final Service serviceOriginal = serviceResponseFormatEither.left().value();
276 final Map<String, String> metadata = (Map<String, String>) new Yaml().loadAs(data, Map.class).get("metadata");
277 validateServiceMetadataBeforeCreate(serviceOriginal, metadata);
279 final Service newService = cloneServiceIdentifications(serviceOriginal);
280 final Map<String, byte[]> payload = new HashMap<>();
281 payload.put("Definitions/service-" + metadata.get("name") + "-template.yml", data.getBytes());
282 updateServiceMetadata(newService, metadata);
283 return createService(newService, AuditingActionEnum.UPDATE_SERVICE_TOSCA_TEMPLATE, modifier, payload, null);
286 private Service cloneServiceIdentifications(final Service serviceOriginal) {
287 final Service newService = new Service(serviceOriginal.getComponentMetadataDefinition());
288 newService.setCategories(serviceOriginal.getCategories());
289 newService.setInvariantUUID(serviceOriginal.getInvariantUUID());
290 newService.setUniqueId(serviceOriginal.getUniqueId());
291 newService.setName(serviceOriginal.getName());
292 newService.setUUID(serviceOriginal.getUUID());
296 private void validateServiceMetadataBeforeCreate(final Service service, final Map<String, String> metadata) {
297 if (MapUtils.isEmpty(metadata)) {
298 throw new ByActionStatusComponentException(ActionStatus.MISSING_SERVICE_METADATA);
300 final String uuid = metadata.get("UUID");
301 if (!service.getUUID().equals(uuid)) {
302 throw new ByActionStatusComponentException(ActionStatus.UNCHANGEABLE_PROPERTY_ERROR, "UUID");
304 final String invariantUUID = metadata.get("invariantUUID");
305 if (!service.getInvariantUUID().equals(invariantUUID)) {
306 throw new ByActionStatusComponentException(ActionStatus.UNCHANGEABLE_PROPERTY_ERROR, "invariantUUID");
308 final String name = metadata.get("name");
309 if (!service.getName().equals(name)) {
310 throw new ByActionStatusComponentException(ActionStatus.UNCHANGEABLE_PROPERTY_ERROR, "name");
312 final String version = metadata.get("template_version");
313 if (!service.getVersion().equals(version)) {
314 throw new ByActionStatusComponentException(ActionStatus.UNCHANGEABLE_PROPERTY_ERROR, "template_version");
318 public Service createService(Service service, AuditingActionEnum auditingAction, User user, Map<String, byte[]> csarUIPayload,
319 String payloadName) {
320 log.debug("enter createService");
321 if (AuditingActionEnum.CREATE_SERVICE.equals(auditingAction)) {
322 service.setCreatorUserId(user.getUserId());
323 service.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
324 service.setVersion(INITIAL_VERSION);
325 service.setConformanceLevel(ConfigurationManager.getConfigurationManager().getConfiguration().getToscaConformanceLevel());
326 service.setDistributionStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
329 final var serviceBeforeCreate = serviceBusinessLogic.validateServiceBeforeCreate(service, user, auditingAction);
330 if (serviceBeforeCreate.isRight()) {
331 throw new ComponentException(ActionStatus.GENERAL_ERROR);
333 log.debug("enter createService,validateServiceBeforeCreate success");
334 String csarUUID = payloadName == null ? service.getCsarUUID() : payloadName;
335 if (AuditingActionEnum.CREATE_SERVICE.equals(auditingAction)) {
336 log.debug("enter createService,get csarUUID:{}", csarUUID);
337 csarBusinessLogic.validateCsarBeforeCreate(service, csarUUID);
339 log.debug("CsarUUID is {} - going to create resource from CSAR", csarUUID);
340 return createServiceFromCsar(service, user, csarUIPayload, csarUUID, auditingAction);
341 } catch (final ComponentException e) {
342 log.debug("Exception occurred when createService: {}", e.getMessage(), e);
344 } catch (final Exception e) {
345 log.debug("Exception occurred when createService: {}", e.getMessage(), e);
346 throw new ComponentException(ActionStatus.GENERAL_ERROR);
350 private void updateServiceMetadata(final Service service, final Map<String, String> metadata) {
351 metadata.entrySet().forEach(s -> {
352 final Optional<Method> find =
353 Arrays.stream(service.getClass().getMethods()).filter(method -> method.getName().equalsIgnoreCase("set" + s.getKey())).findAny();
354 if (find.isPresent()) {
356 find.get().invoke(service, s.getValue());
357 } catch (final Exception e) {
358 log.warn("Unable to set '{}' with value '{}'", s.getKey(), s.getValue());
364 protected Service createServiceFromCsar(Service service, User user, Map<String, byte[]> csarUIPayload, String csarUUID,
365 AuditingActionEnum auditingAction) {
366 log.trace("************* created successfully from YAML, resource TOSCA ");
368 final ServiceCsarInfo csarInfo;
369 if (AuditingActionEnum.UPDATE_SERVICE_TOSCA_TEMPLATE.equals(auditingAction)) {
370 csarInfo = new ServiceCsarInfo(user, csarUUID, csarUIPayload, service.getName(), service.getModel(),
371 csarUIPayload.keySet().iterator().next(), new String(csarUIPayload.values().iterator().next()), true, modelOperation);
373 csarInfo = csarBusinessLogic.getCsarInfo(service, null, user, csarUIPayload, csarUUID, auditingAction);
375 final String serviceModel = service.getModel();
376 final Map<String, Object> dataTypesToCreate = getDatatypesToCreate(serviceModel, csarInfo);
377 if (MapUtils.isNotEmpty(dataTypesToCreate)) {
378 dataTypeBusinessLogic.createDataTypeFromYaml(new Yaml().dump(dataTypesToCreate), serviceModel, true);
379 dataTypesToCreate.keySet().forEach(key ->
380 applicationDataTypeCache.reload(serviceModel, UniqueIdBuilder.buildDataTypeUid(serviceModel, key))
384 final Map<String, Object> artifactTypesToCreate = getArtifactTypesToCreate(serviceModel, csarInfo);
385 if (MapUtils.isNotEmpty(artifactTypesToCreate)) {
386 artifactTypeImportManager.createArtifactTypes(new Yaml().dump(artifactTypesToCreate), serviceModel, true);
389 final List<NodeTypeDefinition> nodeTypesToCreate = getNodeTypesToCreate(serviceModel, csarInfo);
390 if (CollectionUtils.isNotEmpty(nodeTypesToCreate)) {
391 ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic.getParsedToscaYamlInfo(csarInfo, service);
392 createNodeTypes(nodeTypesToCreate, parsedToscaYamlInfo.getInstances(), serviceModel, csarInfo.getModifier());
395 final Map<String, Object> groupTypesToCreate = getGroupTypesToCreate(serviceModel, csarInfo);
396 if (MapUtils.isNotEmpty(groupTypesToCreate)) {
397 final Map<String, ToscaTypeMetadata> toscaTypeMetadata = fillToscaTypeMetadata(groupTypesToCreate);
398 final ToscaTypeImportData toscaTypeImportData = new ToscaTypeImportData(new Yaml().dump(groupTypesToCreate), toscaTypeMetadata);
399 groupTypeImportManager.createGroupTypes(toscaTypeImportData, serviceModel, true);
402 final Map<String, Object> interfaceTypesToCreate = getInterfaceTypesToCreate(serviceModel, csarInfo);
403 if (MapUtils.isNotEmpty(interfaceTypesToCreate)) {
404 interfaceLifecycleTypeImportManager.createLifecycleTypes(new Yaml().dump(interfaceTypesToCreate), serviceModel, true);
407 final Map<String, Object> capabilityTypesToCreate = getCapabilityTypesToCreate(serviceModel, csarInfo);
408 if (MapUtils.isNotEmpty(capabilityTypesToCreate)) {
409 capabilityTypeImportManager.createCapabilityTypes(new Yaml().dump(capabilityTypesToCreate), serviceModel, true);
412 Map<String, NodeTypeInfo> nodeTypesInfo = csarInfo.extractTypesInfo();
413 Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandleRes
414 = serviceImportParseLogic.findNodeTypesArtifactsToHandle(nodeTypesInfo, csarInfo, service);
415 if (findNodeTypesArtifactsToHandleRes.isRight()) {
416 log.debug("failed to find node types for update with artifacts during import csar {}. ", csarInfo.getCsarUUID());
417 throw new ComponentException(findNodeTypesArtifactsToHandleRes.right().value());
419 return createServiceFromYaml(service, csarInfo.getMainTemplateContent(), csarInfo.getMainTemplateName(), nodeTypesInfo, csarInfo,
420 findNodeTypesArtifactsToHandleRes.left().value(), true, false, null, user.getUserId(), auditingAction);
421 } catch (final ComponentException e) {
422 log.debug("Exception occurred when createServiceFromCsar,error is:{}", e.getMessage(), e);
424 } catch (final Exception e) {
425 log.debug("Exception occurred when createServiceFromCsar,error is:{}", e.getMessage(), e);
426 throw new ComponentException(ActionStatus.GENERAL_ERROR);
430 private Map<String, ToscaTypeMetadata> fillToscaTypeMetadata(final Map<String, Object> groupTypesToCreate) {
431 final Map<String, ToscaTypeMetadata> toscaTypeMetadata = new HashMap<>();
432 groupTypesToCreate.entrySet().forEach(entry -> {
433 final ToscaTypeMetadata metadata = new ToscaTypeMetadata();
434 metadata.setIcon(getIconFromGroupType(entry.getValue()));
435 metadata.setDisplayName(extractDisplayName(entry.getKey()));
436 toscaTypeMetadata.put(entry.getKey(), metadata);
438 return toscaTypeMetadata;
441 private String extractDisplayName(final String key) {
442 final String[] split = key.split("\\.");
443 return split[split.length - 1];
446 private String getIconFromGroupType(final Object value) {
447 final Either<GroupTypeDefinition, StorageOperationStatus> groupType = groupTypeOperation.getLatestGroupTypeByType(
448 (String) ((LinkedHashMap) value).get(ToscaTagNamesEnum.DERIVED_FROM.getElementName()), null);
449 if (groupType.isLeft()) {
450 return groupType.left().value().getIcon();
455 private Map<String, Object> getGroupTypesToCreate(final String model, final CsarInfo csarInfo) {
456 final Map<String, Object> groupTypesToCreate = new HashMap<>();
457 final Map<String, Object> groupTypes = csarInfo.getGroupTypes();
458 if (MapUtils.isNotEmpty(groupTypes)) {
459 for (final Entry<String, Object> entry : groupTypes.entrySet()) {
460 final Either<GroupTypeDefinition, StorageOperationStatus> result
461 = groupTypeOperation.getGroupTypeByUid(UniqueIdBuilder.buildGroupTypeUid(model, entry.getKey(), "1.0"));
462 if (result.isRight() && result.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
463 groupTypesToCreate.put(entry.getKey(), entry.getValue());
464 log.info("Deploying new group type {} to model {} from package {}", entry.getKey(), model, csarInfo.getCsarUUID());
468 return groupTypesToCreate;
471 private Map<String, Object> getCapabilityTypesToCreate(final String model, final CsarInfo csarInfo) {
472 final Map<String, Object> capabilityTypesToCreate = new HashMap<>();
473 final Map<String, Object> capabilityTypes = csarInfo.getCapabilityTypes();
474 if (MapUtils.isNotEmpty(capabilityTypes)) {
475 for (final Entry<String, Object> entry : capabilityTypes.entrySet()) {
476 final Either<CapabilityTypeDefinition, StorageOperationStatus> result
477 = capabilityTypeOperation.getCapabilityType(UniqueIdBuilder.buildCapabilityTypeUid(model, entry.getKey()));
478 if (result.isRight() && result.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
479 capabilityTypesToCreate.put(entry.getKey(), entry.getValue());
480 log.info("Deploying new capability type {} to model {} from package {}", entry.getKey(), model, csarInfo.getCsarUUID());
484 return capabilityTypesToCreate;
487 private Map<String, Object> getDatatypesToCreate(final String model, final CsarInfo csarInfo) {
488 final Map<String, Object> dataTypesToCreate = new HashMap<>();
490 for (final Entry<String, Object> dataTypeEntry : csarInfo.getDataTypes().entrySet()) {
491 final Either<DataTypeDefinition, JanusGraphOperationStatus> result = applicationDataTypeCache.get(model,
492 UniqueIdBuilder.buildDataTypeUid(model, dataTypeEntry.getKey()));
493 if (result.isRight() && result.right().value().equals(JanusGraphOperationStatus.NOT_FOUND)) {
494 dataTypesToCreate.put(dataTypeEntry.getKey(), dataTypeEntry.getValue());
495 log.info("Deploying unknown type {} to model {} from package {}", dataTypeEntry.getKey(), model, csarInfo.getCsarUUID());
497 if (hasNewProperties(result, (Map<String, Map<String, Object>>) dataTypeEntry.getValue())) {
498 dataTypesToCreate.put(dataTypeEntry.getKey(), dataTypeEntry.getValue());
499 log.info("Deploying new version of type {} to model {} from package {}", dataTypeEntry.getKey(), model, csarInfo.getCsarUUID());
502 return dataTypesToCreate;
505 private Map<String, Object> getArtifactTypesToCreate(final String model, final CsarInfo csarInfo) {
506 final Map<String, Object> artifactTypesToCreate = new HashMap<>();
507 final Map<String, Object> artifactTypesMap = csarInfo.getArtifactTypes();
508 if (MapUtils.isNotEmpty(artifactTypesMap)) {
509 for (final Entry<String, Object> artifactTypeEntry : artifactTypesMap.entrySet()) {
510 final Either<ArtifactTypeDefinition, StorageOperationStatus> result =
511 artifactTypeOperation.getArtifactTypeByUid(UniqueIdBuilder.buildArtifactTypeUid(model, artifactTypeEntry.getKey()));
512 if (result.isRight() && StorageOperationStatus.NOT_FOUND.equals(result.right().value())) {
513 artifactTypesToCreate.put(artifactTypeEntry.getKey(), artifactTypeEntry.getValue());
514 log.info("Deploying new artifact type={}, to model={}, from package={}",
515 artifactTypeEntry.getKey(), model, csarInfo.getCsarUUID());
519 return artifactTypesToCreate;
522 private Map<String, Object> getInterfaceTypesToCreate(final String model, final CsarInfo csarInfo) {
523 final Map<String, Object> interfaceTypesToCreate = new HashMap<>();
524 Map<String, Object> interfacetypeMap = csarInfo.getInterfaceTypes();
526 interfacetypeMap.entrySet().forEach(interfacetypeDef -> {
527 Either<InterfaceDefinition, StorageOperationStatus> interfaceDefinition =
528 interfaceLifecycleTypeOperation.getInterface(UniqueIdBuilder.buildInterfaceTypeUid(model, interfacetypeDef.getKey()));
529 if (interfaceDefinition.isRight() && interfaceDefinition.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
530 interfaceTypesToCreate.put(interfacetypeDef.getKey(), interfacetypeDef.getValue());
533 return interfaceTypesToCreate;
536 private boolean hasNewProperties(final Either<DataTypeDefinition, JanusGraphOperationStatus> result,
537 final Map<String, Map<String, Object>> dataType) {
538 return result.isLeft() && dataType.containsKey("properties") && result.left().value().getProperties() != null
539 && result.left().value().getProperties().size() != dataType.get("properties").size();
542 private void createNodeTypes(List<NodeTypeDefinition> nodeTypesToCreate, Map<String, UploadComponentInstanceInfo> instancesFromCsar, String model, User user) {
543 NodeTypesMetadataList nodeTypesMetadataList = new NodeTypesMetadataList();
544 List<NodeTypeMetadata> nodeTypeMetadataList = new ArrayList<>();
545 final Map<String, Object> allTypesToCreate = new HashMap<>();
546 nodeTypesToCreate.forEach(nodeType -> {
547 allTypesToCreate.put(nodeType.getMappedNodeType().getKey(), nodeType.getMappedNodeType().getValue());
548 nodeTypeMetadataList.add(nodeType.getNodeTypeMetadata());
550 nodeTypesMetadataList.setNodeMetadataList(nodeTypeMetadataList);
551 resourceImportManager.importAllNormativeResource(allTypesToCreate, nodeTypesMetadataList, instancesFromCsar, user, model, true, false);
554 private List<NodeTypeDefinition> getNodeTypesToCreate(final String model, final ServiceCsarInfo csarInfo) {
555 List<NodeTypeDefinition> namesOfNodeTypesToCreate = new ArrayList<>();
557 for (final NodeTypeDefinition nodeTypeDefinition : csarInfo.getNodeTypesUsed()) {
558 Either<Component, StorageOperationStatus> result = toscaOperationFacade
559 .getLatestByToscaResourceName(nodeTypeDefinition.getMappedNodeType().getKey(), model);
560 if (result.isRight() && result.right().value().equals(StorageOperationStatus.NOT_FOUND)) {
561 namesOfNodeTypesToCreate.add(nodeTypeDefinition);
562 } else if (result.isLeft()) {
563 Resource latestResource = (Resource) result.left().value();
564 Entry<String, Object> existingMappedToscaTemplate = getResourceToscaTemplate(latestResource.getUniqueId(),
565 latestResource.getToscaArtifacts().get(ToscaExportHandler.ASSET_TOSCA_TEMPLATE), csarInfo.getModifier().getUserId());
566 Map<String, Object> newMappedToscaTemplate = (Map<String, Object>) nodeTypeDefinition.getMappedNodeType().getValue();
567 Map<String, Object> combinedMappedToscaTemplate =
568 getNewChangesToToscaTemplate(newMappedToscaTemplate, (Map<String, Object>) existingMappedToscaTemplate.getValue());
569 if (!combinedMappedToscaTemplate.equals(existingMappedToscaTemplate.getValue())) {
570 if (latestResource.getComponentMetadataDefinition().getMetadataDataDefinition().isNormative()) {
571 nodeTypeDefinition.getNodeTypeMetadata().setNormative(true);
573 existingMappedToscaTemplate.setValue(combinedMappedToscaTemplate);
574 nodeTypeDefinition.setMappedNodeType(existingMappedToscaTemplate);
575 namesOfNodeTypesToCreate.add(nodeTypeDefinition);
579 return namesOfNodeTypesToCreate;
582 private Entry<String, Object> getResourceToscaTemplate(String uniqueId, ArtifactDefinition assetToscaTemplate, String userId) {
583 String assetToToscaTemplate = assetToscaTemplate.getUniqueId();
584 ImmutablePair<String, byte[]> toscaTemplate = artifactsBusinessLogic.
585 handleDownloadRequestById(uniqueId, assetToToscaTemplate, userId, ComponentTypeEnum.RESOURCE, null, null);
586 Map<String, Object> mappedToscaTemplate = new Yaml().load(new String(toscaTemplate.right));
587 Either<Map<String, Object>, ImportUtils.ResultStatusEnum> eitherNodeTypes =
588 findFirstToscaMapElement(mappedToscaTemplate, TypeUtils.ToscaTagNamesEnum.NODE_TYPES);
589 if (eitherNodeTypes.isRight()) {
590 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
592 return eitherNodeTypes.left().value().entrySet().iterator().next();
595 private Map<String, Object> getNewChangesToToscaTemplate(Map<String, Object> newMappedToscaTemplate,
596 Map<String, Object> existingMappedToscaTemplate) {
597 Map<String, Object> combinedMappedToscaTemplate = new HashMap<>(existingMappedToscaTemplate);
598 combinePropertiesIntoToscaTemplate((Map<String, Object>) newMappedToscaTemplate.get("properties"),
599 (Map<String, Object>) existingMappedToscaTemplate.get("properties"), combinedMappedToscaTemplate);
600 combineAttributesIntoToscaTemplate((Map<String, Object>) newMappedToscaTemplate.get("attributes"),
601 (Map<String, Object>) existingMappedToscaTemplate.get("attributes"), combinedMappedToscaTemplate);
602 combineRequirementsIntoToscaTemplate((List<Map<String, Object>>) newMappedToscaTemplate.get("requirements"),
603 (List<Map<String, Object>>) existingMappedToscaTemplate.get("requirements"), combinedMappedToscaTemplate);
604 combineCapabilitiesIntoToscaTemplate((Map<String, Object>) newMappedToscaTemplate.get("capabilities"),
605 (Map<String, Object>) existingMappedToscaTemplate.get("capabilities"), combinedMappedToscaTemplate);
606 combineInterfacesIntoToscaTemplate((Map<String, Map<String, Object>>) newMappedToscaTemplate.get("interfaces"),
607 (Map<String, Map<String, Object>>) existingMappedToscaTemplate.get("interfaces"), combinedMappedToscaTemplate);
608 return combinedMappedToscaTemplate;
611 private void combineInterfacesIntoToscaTemplate(Map<String, Map<String, Object>> newInterfaces,
612 Map<String, Map<String, Object>> existingInterfaces,
613 Map<String, Object> combinedMappedToscaTemplate) {
614 Map<String, Map<String, Object>> combinedInterfaces = combineAdditionalInterfaces(existingInterfaces, newInterfaces);
615 if ((MapUtils.isEmpty(existingInterfaces) && MapUtils.isNotEmpty(combinedInterfaces))
616 || (MapUtils.isNotEmpty(existingInterfaces) && !existingInterfaces.equals(combinedInterfaces))) {
617 combinedMappedToscaTemplate.put("interfaces", combinedInterfaces);
621 private void combineCapabilitiesIntoToscaTemplate(Map<String, Object> newCapabilities, Map<String, Object> existingCapabilities,
622 Map<String, Object> combinedMappedToscaTemplate) {
623 Map<String, Object> combinedCapabilities = combineEntries(newCapabilities, existingCapabilities);
624 if ((MapUtils.isEmpty(existingCapabilities) && MapUtils.isNotEmpty(combinedCapabilities)) ||
625 (MapUtils.isNotEmpty(existingCapabilities) && !combinedCapabilities.equals(existingCapabilities))) {
626 combinedMappedToscaTemplate.put("capabilities", combinedCapabilities);
630 private void combineRequirementsIntoToscaTemplate(List<Map<String, Object>> newRequirements, List<Map<String, Object>> existingRequirements,
631 Map<String, Object> combinedMappedToscaTemplate) {
632 List<Map<String, Object>> combinedRequirements = combineAdditionalRequirements(newRequirements, existingRequirements);
633 if ((CollectionUtils.isEmpty(existingRequirements) && CollectionUtils.isNotEmpty(combinedRequirements))
634 || (CollectionUtils.isNotEmpty(existingRequirements) && !combinedRequirements.equals(existingRequirements))) {
635 combinedMappedToscaTemplate.put("requirements", combinedRequirements);
639 private void combineAttributesIntoToscaTemplate(Map<String, Object> newAttributes, Map<String, Object> existingAttributes,
640 Map<String, Object> combinedMappedToscaTemplate) {
641 Map<String, Object> combinedAttributes = combineEntries(newAttributes, existingAttributes);
642 if ((MapUtils.isEmpty(existingAttributes) && MapUtils.isNotEmpty(combinedAttributes)) ||
643 (MapUtils.isNotEmpty(existingAttributes) && !combinedAttributes.equals(existingAttributes))) {
644 combinedMappedToscaTemplate.put("attributes", combinedAttributes);
648 private void combinePropertiesIntoToscaTemplate(Map<String, Object> newProperties, Map<String, Object> existingProperties,
649 Map<String, Object> combinedMappedToscaTemplate) {
650 Map<String, Object> combinedProperties = combineEntries(newProperties, existingProperties);
651 if ((MapUtils.isEmpty(existingProperties) && MapUtils.isNotEmpty(combinedProperties)) ||
652 (MapUtils.isNotEmpty(existingProperties) && !combinedProperties.equals(existingProperties))) {
653 combinedMappedToscaTemplate.put("properties", combinedProperties);
657 private Map<String, Map<String, Object>> combineAdditionalInterfaces(Map<String, Map<String, Object>> existingInterfaces,
658 Map<String, Map<String, Object>> newInterfaces) {
659 if (MapUtils.isEmpty(newInterfaces)) {
660 newInterfaces = new HashMap<>();
662 Map<String, Map<String, Object>> combinedEntries = new HashMap<>(newInterfaces);
663 if (MapUtils.isEmpty(existingInterfaces)) {
664 return combinedEntries;
666 existingInterfaces.entrySet().forEach(interfaceDef -> {
667 combinedEntries.entrySet().stream().filter((interFace) -> interFace.getValue().get("type").equals((interfaceDef.getValue()).get("type")))
668 .findFirst().ifPresentOrElse((interFace) -> {
669 interFace.getValue().putAll(interfaceDef.getValue());
671 combinedEntries.put(interfaceDef.getKey(), interfaceDef.getValue());
674 return combinedEntries;
677 private List<Map<String, Object>> combineAdditionalRequirements(List<Map<String, Object>> newReqs,
678 List<Map<String, Object>> existingResourceReqs) {
679 if (CollectionUtils.isEmpty(existingResourceReqs)) {
680 existingResourceReqs = new ArrayList<>();
682 Set<Map<String, Object>> combinedReqs = new TreeSet<>((map1, map2) ->
683 map1.keySet().equals(map2.keySet()) ? 0 : map1.keySet().iterator().next().compareTo(map2.keySet().iterator().next()));
684 combinedReqs.addAll(existingResourceReqs);
685 if (CollectionUtils.isEmpty(newReqs)) {
686 return new ArrayList<>(combinedReqs);
688 combinedReqs.addAll(newReqs);
689 return new ArrayList<>(combinedReqs);
692 private Map<String, Object> combineEntries(Map<String, Object> newMap, Map<String, Object> existingMap) {
693 if (MapUtils.isEmpty(newMap)) {
694 newMap = new HashMap<>();
696 Map<String, Object> combinedEntries = new HashMap<>(newMap);
697 if (MapUtils.isEmpty(existingMap)) {
698 return combinedEntries;
700 combinedEntries.putAll(existingMap);
701 return combinedEntries;
704 protected Service createServiceFromYaml(Service service, String topologyTemplateYaml, String yamlName, Map<String, NodeTypeInfo> nodeTypesInfo,
706 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
707 boolean shouldLock, boolean inTransaction, String nodeName, final String userId,
708 AuditingActionEnum auditingAction)
709 throws BusinessLogicException {
710 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
711 Service createdService;
712 CreateServiceFromYamlParameter csfyp = new CreateServiceFromYamlParameter();
714 ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic
715 .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, service);
716 log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", service.getName());
717 csfyp.setYamlName(yamlName);
718 csfyp.setParsedToscaYamlInfo(parsedToscaYamlInfo);
719 csfyp.setCreatedArtifacts(createdArtifacts);
720 csfyp.setTopologyTemplateYaml(topologyTemplateYaml);
721 csfyp.setNodeTypesInfo(nodeTypesInfo);
722 csfyp.setCsarInfo(csarInfo);
723 csfyp.setNodeName(nodeName);
724 createdService = createServiceAndRIsFromYaml(service, false, nodeTypesArtifactsToCreate, shouldLock, inTransaction, csfyp, userId,
726 log.debug("#createResourceFromYaml - The resource {} has been created ", service.getName());
727 } catch (ComponentException | BusinessLogicException e) {
728 log.debug("Create Service from yaml failed", e);
730 } catch (StorageException e) {
731 log.debug("create Service From Yaml failed,get StorageException:{}", e);
734 return createdService;
737 protected Service createServiceAndRIsFromYaml(Service service, boolean isNormative,
738 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
739 boolean shouldLock, boolean inTransaction, CreateServiceFromYamlParameter csfyp,
740 final String userId, AuditingActionEnum auditingAction)
741 throws BusinessLogicException {
743 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
744 String yamlName = csfyp.getYamlName();
745 ParsedToscaYamlInfo parsedToscaYamlInfo = csfyp.getParsedToscaYamlInfo();
746 List<ArtifactDefinition> createdArtifacts = csfyp.getCreatedArtifacts();
747 String topologyTemplateYaml = csfyp.getTopologyTemplateYaml();
748 Map<String, NodeTypeInfo> nodeTypesInfo = csfyp.getNodeTypesInfo();
749 CsarInfo csarInfo = csfyp.getCsarInfo();
750 String nodeName = csfyp.getNodeName();
752 Either<Boolean, ResponseFormat> lockResult = serviceBusinessLogic.lockComponentByName(service.getSystemName(), service, CREATE_RESOURCE);
753 if (lockResult.isRight()) {
754 throw new ComponentException(lockResult.right().value());
756 log.debug("name is locked {} status = {}", service.getSystemName(), lockResult);
758 boolean rollback = false;
760 log.trace("************* Adding properties to service from interface yaml {}", yamlName);
761 Map<String, PropertyDefinition> properties = parsedToscaYamlInfo.getProperties();
762 if (properties != null && !properties.isEmpty()) {
763 final List<PropertyDefinition> propertiesList = new ArrayList<>();
764 properties.forEach((propertyName, propertyDefinition) -> {
765 propertyDefinition.setName(propertyName);
766 propertiesList.add(propertyDefinition);
768 service.setProperties(propertiesList);
770 log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
771 service = serviceImportParseLogic.createServiceTransaction(service, csarInfo.getModifier(), isNormative, auditingAction);
772 log.trace("************* Going to add inputs from yaml {}", yamlName);
773 Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
774 service = serviceImportParseLogic.createInputsOnService(service, inputs);
775 log.trace("************* Finished to add inputs from yaml {}", yamlName);
776 ListDataDefinition<SubstitutionFilterPropertyDataDefinition> substitutionFilterProperties =
777 parsedToscaYamlInfo.getSubstitutionFilterProperties();
778 service = serviceImportParseLogic.createSubstitutionFilterOnService(service, substitutionFilterProperties);
779 log.trace("************* Added Substitution filter from interface yaml {}", yamlName);
780 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances();
781 log.trace("************* Going to create nodes, RI's and Relations from yaml {}", yamlName);
782 service = createRIAndRelationsFromYaml(yamlName, service, uploadComponentInstanceInfoMap, topologyTemplateYaml,
783 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName);
784 log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName);
785 log.trace("************* Going to add outputs from yaml {}", yamlName);
786 Map<String, OutputDefinition> outputs = parsedToscaYamlInfo.getOutputs();
787 service = serviceImportParseLogic.createOutputsOnService(service, outputs, userId);
788 log.trace("************* Finished to add outputs from yaml {}", yamlName);
790 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes
791 = groupBusinessLogic.validateUpdateVfGroupNames(parsedToscaYamlInfo.getGroups(), service.getSystemName());
792 if (validateUpdateVfGroupNamesRes.isRight()) {
793 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
795 Map<String, GroupDefinition> groups;
796 log.trace("************* Going to add groups from yaml {}", yamlName);
797 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
798 groups = validateUpdateVfGroupNamesRes.left().value();
800 groups = parsedToscaYamlInfo.getGroups();
802 Either<Service, ResponseFormat> createGroupsOnResource = createGroupsOnResource(service, groups);
803 if (createGroupsOnResource.isRight()) {
804 throw new ComponentException(createGroupsOnResource.right().value());
806 service = createGroupsOnResource.left().value();
808 Either<Service, ResponseFormat> createPoliciesOnResource = createPoliciesOnResource(service, parsedToscaYamlInfo.getPolicies());
809 if (createPoliciesOnResource.isRight()) {
810 throw new ComponentException(createPoliciesOnResource.right().value());
812 service = createPoliciesOnResource.left().value();
813 log.trace("************* Going to add artifacts from yaml {}", yamlName);
814 Either<Service, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
815 createdArtifacts, yamlName, csarInfo, service, inTransaction, shouldLock);
816 if (createArtifactsEither.isRight()) {
817 throw new ComponentException(createArtifactsEither.right().value());
819 service = serviceImportParseLogic.getServiceWithGroups(createArtifactsEither.left().value().getUniqueId());
820 service = updateInputs(service, userId, parsedToscaYamlInfo.getSubstitutionMappingProperties());
822 ASDCKpiApi.countCreatedResourcesKPI();
824 } catch (Exception e) {
826 serviceImportParseLogic.rollback(inTransaction, service, createdArtifacts, nodeTypesNewCreatedArtifacts);
829 if (!inTransaction) {
831 janusGraphDao.rollback();
833 janusGraphDao.commit();
837 graphLockOperation.unlockComponentByName(service.getSystemName(), service.getUniqueId(), NodeTypeEnum.Service);
842 private Service updateInputs(final Service component, final String userId, final Map<String, List<String>> substitutionMappingProperties) {
843 final List<InputDefinition> inputs = component.getInputs();
844 if (CollectionUtils.isNotEmpty(inputs)) {
845 final List<ComponentInstance> componentInstances = component.getComponentInstances();
846 final String componentUniqueId = component.getUniqueId();
847 List<String> propertyMissingNames = new ArrayList<>();
848 for (final InputDefinition input : inputs) {
849 boolean isSubMapProp = false;
850 if (substitutionMappingProperties != null && !substitutionMappingProperties.isEmpty()) {
851 isSubMapProp = substitutionMappingProperties.entrySet().stream()
852 .anyMatch(stringEntry -> stringEntry.getValue().get(0).equals(input.getName()));
854 if (!isSubMapProp && isInputFromComponentInstanceProperty(input.getName(), componentInstances)) {
855 associateInputToComponentInstanceProperty(userId, input, componentInstances, componentUniqueId);
857 String propertyName = associateInputToServiceProperty(userId, input, component, substitutionMappingProperties);
858 if (StringUtils.isNotBlank(propertyName)) {
859 propertyMissingNames.add(propertyName);
863 if (CollectionUtils.isNotEmpty(propertyMissingNames)) {
864 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.MISSING_PROPERTIES_ERROR, propertyMissingNames.toString()));
866 Either<List<InputDefinition>, StorageOperationStatus> either = toscaOperationFacade.updateInputsToComponent(inputs, componentUniqueId);
867 if (either.isRight()) {
868 throw new ComponentException(ActionStatus.GENERAL_ERROR);
875 private boolean isInputFromComponentInstanceProperty(final String inputName, final List<ComponentInstance> componentInstances) {
877 if (CollectionUtils.isNotEmpty(componentInstances)) {
878 for (ComponentInstance instance : componentInstances) {
879 for (PropertyDefinition instanceProperty : instance.getProperties()) {
880 if (CollectionUtils.isNotEmpty(instanceProperty.getGetInputValues())) {
881 for (GetInputValueDataDefinition getInputValueDataDefinition : instanceProperty.getGetInputValues()) {
882 if (inputName.equals(getInputValueDataDefinition.getInputName())) {
893 private void associateInputToComponentInstanceProperty(final String userId, final InputDefinition input,
894 final List<ComponentInstance> componentInstances,
895 String componentUniqueId) {
897 String componentInstanceId = null;
898 ComponentInstanceProperty componentInstanceProperty = new ComponentInstanceProperty();
901 for (ComponentInstance instance : componentInstances) {
902 for (PropertyDefinition instanceProperty : instance.getProperties()) {
903 if (CollectionUtils.isNotEmpty(instanceProperty.getGetInputValues())) {
904 for (GetInputValueDataDefinition getInputValueDataDefinition : instanceProperty.getGetInputValues()) {
905 if (input.getName().equals(getInputValueDataDefinition.getInputName())) {
906 componentInstanceId = instance.getUniqueId();
907 componentInstanceProperty = new ComponentInstanceProperty(instanceProperty);
915 //unmapping instance property declared inputs from substitution mapping
916 input.setMappedToComponentProperty(false);
919 updateInput(input, componentInstanceProperty, userId, componentInstanceId);
921 final Either<Map<String, List<ComponentInstanceProperty>>, StorageOperationStatus> either =
922 toscaOperationFacade.updateComponentInstancePropsToComponent(Collections.singletonMap(componentInstanceId,
923 Collections.singletonList(componentInstanceProperty)), componentUniqueId);
924 if (either.isRight()) {
925 throw new ComponentException(ActionStatus.GENERAL_ERROR);
929 private String associateInputToServiceProperty(final String userId,
930 final InputDefinition input, final Service component,
931 final Map<String, List<String>> substitutionMappingProperties) {
932 final List<PropertyDefinition> properties = component.getProperties();
933 if (CollectionUtils.isNotEmpty(properties) && MapUtils.isNotEmpty(substitutionMappingProperties)) {
934 AtomicReference<String> propertyNameFromInput = new AtomicReference<>(" ");
935 substitutionMappingProperties.entrySet().forEach(stringEntry -> {
936 if (stringEntry.getValue().get(0).equals(input.getName())) {
937 propertyNameFromInput.set(stringEntry.getKey());
941 final Optional<PropertyDefinition> propDefOptional =
942 properties.stream().filter(prop -> prop.getName().equals(propertyNameFromInput.get()))
944 if (propDefOptional.isPresent()) {
946 final String componentUniqueId = component.getUniqueId();
947 final PropertyDefinition propertyDefinition = propDefOptional.get();
948 updateProperty(propertyDefinition, input, componentUniqueId);
949 final JSONObject jsonObject = new JSONObject();
950 jsonObject.put(ToscaGetFunctionType.GET_INPUT.getFunctionName(), input.getName());
951 propertyDefinition.setValue(jsonObject.toJSONString());
952 updateInput(input, propertyDefinition, userId, componentUniqueId);
954 final Either<PropertyDefinition, StorageOperationStatus> either
955 = toscaOperationFacade.updatePropertyOfComponent(component, propertyDefinition);
956 if (either.isRight()) {
957 throw new ComponentException(ActionStatus.GENERAL_ERROR);
960 input.setMappedToComponentProperty(false);
961 return propertyNameFromInput.get();
967 private void updateProperty(final PropertyDefinition propertyDefinition, final InputDefinition input, final String componentUniqueId) {
968 propertyDefinition.setParentUniqueId(componentUniqueId);
969 final GetInputValueDataDefinition getInputValueDataDefinition = new GetInputValueDataDefinition();
970 getInputValueDataDefinition.setInputId(input.getUniqueId());
971 getInputValueDataDefinition.setInputName(input.getName());
972 getInputValueDataDefinition.setPropName(propertyDefinition.getName());
973 propertyDefinition.setGetInputValues(Collections.singletonList(getInputValueDataDefinition));
976 private void updateInput(final InputDefinition input, final PropertyDefinition propertyDefinition,
977 final String userId, final String componentUniqueId) {
978 input.setProperties(Collections.singletonList(new ComponentInstanceProperty(propertyDefinition)));
979 input.setInstanceUniqueId(componentUniqueId);
980 input.setOwnerId(userId);
981 input.setPropertyId(propertyDefinition.getUniqueId());
982 input.setParentPropertyType(propertyDefinition.getType());
985 protected Either<Resource, ResponseFormat> createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum operation,
986 List<ArtifactDefinition> createdArtifacts, String yamlFileName,
987 CsarInfo csarInfo, Resource preparedResource,
988 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
989 boolean inTransaction, boolean shouldLock) {
990 String nodeName = nodeTypeInfoToUpdateArtifacts.getNodeName();
991 Resource resource = preparedResource;
992 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle =
993 nodeTypeInfoToUpdateArtifacts
994 .getNodeTypesArtifactsToHandle();
995 if (preparedResource.getResourceType() == ResourceTypeEnum.VF) {
996 if (nodeName != null && nodeTypesArtifactsToHandle.get(nodeName) != null && !nodeTypesArtifactsToHandle.get(nodeName).isEmpty()) {
997 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = handleNodeTypeArtifacts(preparedResource,
998 nodeTypesArtifactsToHandle.get(nodeName), createdArtifacts, csarInfo.getModifier(), inTransaction, true);
999 if (handleNodeTypeArtifactsRes.isRight()) {
1000 return Either.right(handleNodeTypeArtifactsRes.right().value());
1004 Either<Resource, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedResource, csarInfo, createdArtifacts,
1005 new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction);
1006 log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
1007 if (createdCsarArtifactsEither.isRight()) {
1008 return createdCsarArtifactsEither;
1010 resource = createdCsarArtifactsEither.left().value();
1012 return Either.left(resource);
1015 protected Either<Resource, ResponseFormat> handleVfCsarArtifacts(Resource resource, CsarInfo csarInfo, List<ArtifactDefinition> createdArtifacts,
1016 ArtifactOperationInfo artifactOperation, boolean shouldLock,
1017 boolean inTransaction) {
1018 if (csarInfo.getCsar() != null) {
1019 createOrUpdateSingleNonMetaArtifactToComstants(resource, csarInfo, artifactOperation, shouldLock, inTransaction);
1020 Either<Resource, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, resource, createdArtifacts, shouldLock,
1021 inTransaction, artifactOperation);
1022 if (eitherCreateResult.isRight()) {
1023 return Either.right(eitherCreateResult.right().value());
1025 Either<Resource, StorageOperationStatus> eitherGerResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
1026 if (eitherGerResource.isRight()) {
1027 ResponseFormat responseFormat = componentsUtils
1028 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), resource);
1029 return Either.right(responseFormat);
1031 resource = eitherGerResource.left().value();
1032 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
1033 .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
1034 if (artifacsMetaCsarStatus.isLeft()) {
1035 return getResourceResponseFormatEither(resource, csarInfo, createdArtifacts, artifactOperation, shouldLock, inTransaction,
1036 artifacsMetaCsarStatus);
1038 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(resource, csarInfo, shouldLock, inTransaction);
1041 return Either.left(resource);
1044 protected void createOrUpdateSingleNonMetaArtifactToComstants(Resource resource, CsarInfo csarInfo, ArtifactOperationInfo artifactOperation,
1045 boolean shouldLock, boolean inTransaction) {
1046 String vendorLicenseModelId = null;
1047 String vfLicenseModelId = null;
1048 if (artifactOperation.getArtifactOperationEnum() == ArtifactOperationEnum.UPDATE) {
1049 Map<String, ArtifactDefinition> deploymentArtifactsMap = resource.getDeploymentArtifacts();
1050 if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
1051 for (Map.Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
1052 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
1053 vendorLicenseModelId = artifactEntry.getValue().getUniqueId();
1055 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
1056 vfLicenseModelId = artifactEntry.getValue().getUniqueId();
1061 createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL,
1062 Constants.VENDOR_LICENSE_MODEL, ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
1063 Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME, Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId,
1064 artifactOperation, null, true, shouldLock, inTransaction);
1065 createOrUpdateSingleNonMetaArtifact(resource, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
1066 ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL, Constants.VF_LICENSE_DISPLAY_NAME,
1067 Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId, artifactOperation, null, true, shouldLock, inTransaction);
1070 private Either<Resource, ResponseFormat> getResourceResponseFormatEither(Resource resource, CsarInfo csarInfo,
1071 List<ArtifactDefinition> createdArtifacts,
1072 ArtifactOperationInfo artifactOperation, boolean shouldLock,
1073 boolean inTransaction,
1074 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus) {
1076 String artifactsFileName = artifacsMetaCsarStatus.left().value().getKey();
1077 String artifactsContents = artifacsMetaCsarStatus.left().value().getValue();
1078 Either<Resource, ResponseFormat> createArtifactsFromCsar;
1079 if (ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
1080 createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic
1081 .createResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts);
1083 Either<Component, ResponseFormat> result = csarArtifactsAndGroupsBusinessLogic
1084 .updateResourceArtifactsFromCsar(csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
1086 if ((result.left().value() instanceof Resource) && result.isLeft()) {
1087 Resource service1 = (Resource) result.left().value();
1088 createArtifactsFromCsar = Either.left(service1);
1090 createArtifactsFromCsar = Either.right(result.right().value());
1093 if (createArtifactsFromCsar.isRight()) {
1094 log.debug("Couldn't create artifacts from artifacts.meta");
1095 return Either.right(createArtifactsFromCsar.right().value());
1097 return Either.left(createArtifactsFromCsar.left().value());
1098 } catch (Exception e) {
1099 log.debug("Exception occured in getResourceResponseFormatEither, message:{}", e.getMessage(), e);
1100 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1104 private <T extends Component> Either<T, ResponseFormat> createOrUpdateNonMetaArtifactsComp(CsarInfo csarInfo, T component,
1105 List<ArtifactDefinition> createdArtifacts,
1106 boolean shouldLock, boolean inTransaction,
1107 ArtifactOperationInfo artifactOperation) {
1108 Either<T, ResponseFormat> resStatus = null;
1109 Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
1111 Either<List<CsarUtils.NonMetaArtifactInfo>, String> artifactPathAndNameList = getValidArtifactNames(csarInfo, collectedWarningMessages);
1112 if (artifactPathAndNameList.isRight()) {
1113 return Either.right(
1114 getComponentsUtils().getResponseFormatByArtifactId(ActionStatus.ARTIFACT_NAME_INVALID, artifactPathAndNameList.right().value()));
1116 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle = null;
1117 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
1118 vfCsarArtifactsToHandle = new EnumMap<>(ArtifactsBusinessLogic.ArtifactOperationEnum.class);
1119 vfCsarArtifactsToHandle.put(artifactOperation.getArtifactOperationEnum(), artifactPathAndNameList.left().value());
1121 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat>
1122 findVfCsarArtifactsToHandleRes = findVfCsarArtifactsToHandle(
1123 component, artifactPathAndNameList.left().value(), csarInfo.getModifier());
1124 if (findVfCsarArtifactsToHandleRes.isRight()) {
1125 resStatus = Either.right(findVfCsarArtifactsToHandleRes.right().value());
1127 if (resStatus == null) {
1128 vfCsarArtifactsToHandle = findVfCsarArtifactsToHandleRes.left().value();
1131 if (resStatus == null && vfCsarArtifactsToHandle != null) {
1132 resStatus = processCsarArtifacts(csarInfo, component, createdArtifacts, shouldLock, inTransaction, resStatus,
1133 vfCsarArtifactsToHandle);
1135 if (resStatus == null) {
1136 resStatus = Either.left(component);
1138 } catch (Exception e) {
1139 resStatus = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
1140 log.debug("Exception occured in createNonMetaArtifacts, message:{}", e.getMessage(), e);
1142 CsarUtils.handleWarningMessages(collectedWarningMessages);
1147 protected Either<Resource, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Resource resource,
1148 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
1149 boolean inTransaction, ArtifactOperationInfo artifactOperation) {
1150 return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation);
1153 protected <T extends Component> Either<T, ResponseFormat> processCsarArtifacts(CsarInfo csarInfo, Component comp,
1154 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
1155 boolean inTransaction, Either<T, ResponseFormat> resStatus,
1156 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> vfCsarArtifactsToHandle) {
1157 for (Map.Entry<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> currArtifactOperationPair : vfCsarArtifactsToHandle
1159 Optional<ResponseFormat> optionalCreateInDBError = currArtifactOperationPair.getValue().stream().map(
1160 e -> createOrUpdateSingleNonMetaArtifact(comp, csarInfo, e.getPath(), e.getArtifactName(), e.getArtifactType(),
1161 e.getArtifactGroupType(), e.getArtifactLabel(), e.getDisplayName(), CsarUtils.ARTIFACT_CREATED_FROM_CSAR, e.getArtifactUniqueId(),
1162 new ArtifactOperationInfo(false, false, currArtifactOperationPair.getKey()), createdArtifacts, e.isFromCsar(), shouldLock,
1163 inTransaction)).filter(Either::isRight).map(e -> e.right().value()).findAny();
1164 if (optionalCreateInDBError.isPresent()) {
1165 resStatus = Either.right(optionalCreateInDBError.get());
1172 protected Either<Boolean, ResponseFormat> createOrUpdateSingleNonMetaArtifact(Component component, CsarInfo csarInfo, String artifactPath,
1173 String artifactFileName, String artifactType,
1174 ArtifactGroupTypeEnum artifactGroupType, String artifactLabel,
1175 String artifactDisplayName, String artifactDescription,
1176 String artifactId, ArtifactOperationInfo operation,
1177 List<ArtifactDefinition> createdArtifacts, boolean isFromCsar,
1178 boolean shouldLock, boolean inTransaction) {
1179 byte[] artifactFileBytes = null;
1180 if (csarInfo.getCsar().containsKey(artifactPath)) {
1181 artifactFileBytes = csarInfo.getCsar().get(artifactPath);
1183 Either<Boolean, ResponseFormat> result = Either.left(true);
1184 if (operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE
1185 || operation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE) {
1186 if (serviceImportParseLogic.isArtifactDeletionRequired(artifactId, artifactFileBytes, isFromCsar)) {
1187 Either<ArtifactDefinition, ResponseFormat> handleDelete = artifactsBusinessLogic
1188 .handleDelete(component.getUniqueId(), artifactId, csarInfo.getModifier(), component, shouldLock, inTransaction);
1189 if (handleDelete.isRight()) {
1190 result = Either.right(handleDelete.right().value());
1194 if (org.apache.commons.lang.StringUtils.isEmpty(artifactId) && artifactFileBytes != null) {
1195 operation = new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE);
1198 if (artifactFileBytes != null) {
1199 Map<String, Object> vendorLicenseModelJson = ArtifactUtils
1200 .buildJsonForUpdateArtifact(artifactId, artifactFileName, artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
1201 artifactDescription, artifactFileBytes, null, isFromCsar);
1202 Either<Either<ArtifactDefinition, Operation>, ResponseFormat> eitherNonMetaArtifacts = csarArtifactsAndGroupsBusinessLogic
1203 .createOrUpdateCsarArtifactFromJson(component, csarInfo.getModifier(), vendorLicenseModelJson, operation);
1204 serviceImportParseLogic.addNonMetaCreatedArtifactsToSupportRollback(operation, createdArtifacts, eitherNonMetaArtifacts);
1205 if (eitherNonMetaArtifacts.isRight()) {
1206 BeEcompErrorManager.getInstance().logInternalFlowError("UploadLicenseArtifact",
1207 "Failed to upload license artifact: " + artifactFileName + "With csar uuid: " + csarInfo.getCsarUUID(),
1208 BeEcompErrorManager.ErrorSeverity.WARNING);
1209 return Either.right(eitherNonMetaArtifacts.right().value());
1215 private Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifacts(Resource nodeTypeResource,
1216 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
1217 List<ArtifactDefinition> createdArtifacts, User user,
1218 boolean inTransaction, boolean ignoreLifecycleState) {
1219 List<ArtifactDefinition> handleNodeTypeArtifactsRequestRes;
1220 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = null;
1221 Either<Resource, ResponseFormat> changeStateResponse;
1223 changeStateResponse = checkoutResource(nodeTypeResource, user, inTransaction);
1224 if (changeStateResponse.isRight()) {
1225 return Either.right(changeStateResponse.right().value());
1227 nodeTypeResource = changeStateResponse.left().value();
1228 List<ArtifactDefinition> handledNodeTypeArtifacts = new ArrayList<>();
1229 log.debug("************* Going to handle artifacts of node type resource {}. ", nodeTypeResource.getName());
1230 for (Map.Entry<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> curOperationEntry : nodeTypeArtifactsToHandle
1232 ArtifactsBusinessLogic.ArtifactOperationEnum curOperation = curOperationEntry.getKey();
1233 List<ArtifactDefinition> curArtifactsToHandle = curOperationEntry.getValue();
1234 if (curArtifactsToHandle != null && !curArtifactsToHandle.isEmpty()) {
1235 log.debug("************* Going to {} artifact to vfc {}", curOperation.name(), nodeTypeResource.getName());
1236 handleNodeTypeArtifactsRequestRes = artifactsBusinessLogic
1237 .handleArtifactsRequestForInnerVfcComponent(curArtifactsToHandle, nodeTypeResource, user, createdArtifacts,
1238 new ArtifactOperationInfo(false, ignoreLifecycleState, curOperation), false, inTransaction);
1239 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(curOperation)) {
1240 createdArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
1242 handledNodeTypeArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
1245 handleNodeTypeArtifactsRes = Either.left(handledNodeTypeArtifacts);
1246 } catch (Exception e) {
1247 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1248 handleNodeTypeArtifactsRes = Either.right(responseFormat);
1249 log.debug("Exception occured when handleVfcArtifacts, error is:{}", e.getMessage(), e);
1251 return handleNodeTypeArtifactsRes;
1254 private Either<Resource, ResponseFormat> checkoutResource(Resource resource, User user, boolean inTransaction) {
1255 Either<Resource, ResponseFormat> checkoutResourceRes;
1257 if (!resource.getComponentMetadataDefinition().getMetadataDataDefinition().getState()
1258 .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
1259 Either<? extends Component, ResponseFormat> checkoutRes = lifecycleBusinessLogic
1260 .changeComponentState(resource.getComponentType(), resource.getUniqueId(), user, LifeCycleTransitionEnum.CHECKOUT,
1261 new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
1262 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR), inTransaction, true);
1263 if (checkoutRes.isRight()) {
1264 checkoutResourceRes = Either.right(checkoutRes.right().value());
1266 checkoutResourceRes = Either.left((Resource) checkoutRes.left().value());
1269 checkoutResourceRes = Either.left(resource);
1271 } catch (Exception e) {
1272 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1273 checkoutResourceRes = Either.right(responseFormat);
1274 log.debug("Exception occured when checkoutResource {} , error is:{}", resource.getName(), e.getMessage(), e);
1276 return checkoutResourceRes;
1279 protected Either<Service, ResponseFormat> createOrUpdateArtifacts(ArtifactOperationEnum operation, List<ArtifactDefinition> createdArtifacts,
1280 String yamlFileName, CsarInfo csarInfo, Service preparedService,
1281 boolean inTransaction, boolean shouldLock) {
1282 Either<Service, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedService, csarInfo, createdArtifacts,
1283 new ArtifactOperationInfo(false, false, operation), shouldLock, inTransaction);
1284 log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
1285 if (createdCsarArtifactsEither.isRight()) {
1286 return createdCsarArtifactsEither;
1288 return Either.left(createdCsarArtifactsEither.left().value());
1291 protected Either<Service, ResponseFormat> handleVfCsarArtifacts(Service service, CsarInfo csarInfo, List<ArtifactDefinition> createdArtifacts,
1292 ArtifactOperationInfo artifactOperation, boolean shouldLock,
1293 boolean inTransaction) {
1294 if (csarInfo.getCsar() != null) {
1295 String vendorLicenseModelId = null;
1296 String vfLicenseModelId = null;
1297 if (artifactOperation.getArtifactOperationEnum() == ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE) {
1298 Map<String, ArtifactDefinition> deploymentArtifactsMap = service.getDeploymentArtifacts();
1299 if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
1300 for (Map.Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
1301 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
1302 vendorLicenseModelId = artifactEntry.getValue().getUniqueId();
1304 if (artifactEntry.getValue().getArtifactName().equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
1305 vfLicenseModelId = artifactEntry.getValue().getUniqueId();
1310 createOrUpdateSingleNonMetaArtifact(service, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL,
1311 Constants.VENDOR_LICENSE_MODEL, ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
1312 Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME, Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId,
1313 artifactOperation, null, true, shouldLock, inTransaction);
1314 createOrUpdateSingleNonMetaArtifact(service, csarInfo, CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
1315 ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL,
1316 Constants.VF_LICENSE_DISPLAY_NAME, Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId, artifactOperation, null, true, shouldLock,
1318 Either<Service, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, service, createdArtifacts, shouldLock,
1319 inTransaction, artifactOperation);
1320 if (eitherCreateResult.isRight()) {
1321 return Either.right(eitherCreateResult.right().value());
1323 Either<Service, StorageOperationStatus> eitherGerResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
1324 if (eitherGerResource.isRight()) {
1325 ResponseFormat responseFormat = componentsUtils
1326 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGerResource.right().value()), service,
1327 ComponentTypeEnum.SERVICE);
1328 return Either.right(responseFormat);
1330 service = eitherGerResource.left().value();
1331 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
1332 .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
1333 if (artifacsMetaCsarStatus.isLeft()) {
1334 String artifactsFileName = artifacsMetaCsarStatus.left().value().getKey();
1335 String artifactsContents = artifacsMetaCsarStatus.left().value().getValue();
1336 Either<Service, ResponseFormat> createArtifactsFromCsar;
1337 if (ArtifactsBusinessLogic.ArtifactOperationEnum.isCreateOrLink(artifactOperation.getArtifactOperationEnum())) {
1338 createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic
1339 .createResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts);
1341 Either<Component, ResponseFormat> result = csarArtifactsAndGroupsBusinessLogic
1342 .updateResourceArtifactsFromCsar(csarInfo, service, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
1344 if ((result.left().value() instanceof Service) && result.isLeft()) {
1345 Service service1 = (Service) result.left().value();
1346 createArtifactsFromCsar = Either.left(service1);
1348 createArtifactsFromCsar = Either.right(result.right().value());
1351 if (createArtifactsFromCsar.isRight()) {
1352 log.debug("Couldn't create artifacts from artifacts.meta");
1353 return Either.right(createArtifactsFromCsar.right().value());
1355 return Either.left(createArtifactsFromCsar.left().value());
1357 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(service, csarInfo, shouldLock, inTransaction);
1360 return Either.left(service);
1363 protected Either<Service, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Service resource,
1364 List<ArtifactDefinition> createdArtifacts, boolean shouldLock,
1365 boolean inTransaction, ArtifactOperationInfo artifactOperation) {
1366 return createOrUpdateNonMetaArtifactsComp(csarInfo, resource, createdArtifacts, shouldLock, inTransaction, artifactOperation);
1369 protected Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandle(
1370 Component component, List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList, User user) {
1371 List<ArtifactDefinition> existingArtifacts = new ArrayList<>();
1372 if (component.getDeploymentArtifacts() != null && !component.getDeploymentArtifacts().isEmpty()) {
1373 existingArtifacts.addAll(component.getDeploymentArtifacts().values());
1375 if (component.getArtifacts() != null && !component.getArtifacts().isEmpty()) {
1376 existingArtifacts.addAll(component.getArtifacts().values());
1378 existingArtifacts = existingArtifacts.stream().filter(this::isNonMetaArtifact).collect(toList());
1379 List<String> artifactsToIgnore = new ArrayList<>();
1380 if (component.getGroups() != null) {
1381 component.getGroups().forEach(g -> {
1382 if (g.getArtifacts() != null && !g.getArtifacts().isEmpty()) {
1383 artifactsToIgnore.addAll(g.getArtifacts());
1387 existingArtifacts = existingArtifacts.stream().filter(a -> !artifactsToIgnore.contains(a.getUniqueId())).collect(toList());
1388 return organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifacts, component, user);
1391 private boolean isNonMetaArtifact(ArtifactDefinition artifact) {
1392 boolean result = true;
1393 if (artifact.getMandatory() || artifact.getArtifactName() == null || !isValidArtifactType(artifact)) {
1399 private boolean isValidArtifactType(ArtifactDefinition artifact) {
1400 final String artifactType = artifact.getArtifactType();
1401 return artifactType != null
1402 && !ArtifactTypeEnum.VENDOR_LICENSE.getType().equals(ArtifactTypeEnum.findType(artifactType))
1403 && !ArtifactTypeEnum.VF_LICENSE.getType().equals(ArtifactTypeEnum.findType(artifactType));
1406 protected Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat> organizeVfCsarArtifactsByArtifactOperation(
1407 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList, List<ArtifactDefinition> existingArtifactsToHandle, Component component,
1409 EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>> nodeTypeArtifactsToHandle = new EnumMap<>(
1410 ArtifactsBusinessLogic.ArtifactOperationEnum.class);
1411 Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
1412 Either<EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<CsarUtils.NonMetaArtifactInfo>>, ResponseFormat>
1413 nodeTypeArtifactsToHandleRes = Either
1414 .left(nodeTypeArtifactsToHandle);
1416 List<CsarUtils.NonMetaArtifactInfo> artifactsToUpload = new ArrayList<>(artifactPathAndNameList);
1417 List<CsarUtils.NonMetaArtifactInfo> artifactsToUpdate = new ArrayList<>();
1418 List<CsarUtils.NonMetaArtifactInfo> artifactsToDelete = new ArrayList<>();
1419 for (CsarUtils.NonMetaArtifactInfo currNewArtifact : artifactPathAndNameList) {
1420 ArtifactDefinition foundArtifact;
1421 if (!existingArtifactsToHandle.isEmpty()) {
1422 foundArtifact = existingArtifactsToHandle.stream().filter(a -> a.getArtifactName().equals(currNewArtifact.getArtifactName()))
1423 .findFirst().orElse(null);
1424 if (foundArtifact != null) {
1425 if (ArtifactTypeEnum.findType(foundArtifact.getArtifactType()).equals(currNewArtifact.getArtifactType())) {
1426 if (!foundArtifact.getArtifactChecksum().equals(currNewArtifact.getArtifactChecksum())) {
1427 currNewArtifact.setArtifactUniqueId(foundArtifact.getUniqueId());
1428 artifactsToUpdate.add(currNewArtifact);
1430 existingArtifactsToHandle.remove(foundArtifact);
1431 artifactsToUpload.remove(currNewArtifact);
1433 log.debug("Can't upload two artifact with the same name {}.", currNewArtifact.getArtifactName());
1434 ResponseFormat responseFormat = ResponseFormatManager.getInstance()
1435 .getResponseFormat(ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR, currNewArtifact.getArtifactName(),
1436 currNewArtifact.getArtifactType(), foundArtifact.getArtifactType());
1437 AuditingActionEnum auditingAction = artifactsBusinessLogic.detectAuditingType(
1438 new ArtifactOperationInfo(false, false, ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE),
1439 foundArtifact.getArtifactChecksum());
1440 artifactsBusinessLogic.handleAuditing(auditingAction, component, component.getUniqueId(), user, null, null,
1441 foundArtifact.getUniqueId(), responseFormat, component.getComponentType(), null);
1442 responseWrapper.setInnerElement(responseFormat);
1448 if (responseWrapper.isEmpty()) {
1449 for (ArtifactDefinition currArtifact : existingArtifactsToHandle) {
1450 if (currArtifact.getIsFromCsar()) {
1451 artifactsToDelete.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
1452 ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null,
1453 currArtifact.getUniqueId(), currArtifact.getIsFromCsar()));
1455 artifactsToUpdate.add(new CsarUtils.NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
1456 ArtifactTypeEnum.findType(currArtifact.getArtifactType()), currArtifact.getArtifactGroupType(), null,
1457 currArtifact.getUniqueId(), currArtifact.getIsFromCsar()));
1461 if (responseWrapper.isEmpty()) {
1462 if (!artifactsToUpload.isEmpty()) {
1463 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE, artifactsToUpload);
1465 if (!artifactsToUpdate.isEmpty()) {
1466 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE, artifactsToUpdate);
1468 if (!artifactsToDelete.isEmpty()) {
1469 nodeTypeArtifactsToHandle.put(ArtifactsBusinessLogic.ArtifactOperationEnum.DELETE, artifactsToDelete);
1472 if (!responseWrapper.isEmpty()) {
1473 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
1475 } catch (Exception e) {
1476 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1477 responseWrapper.setInnerElement(responseFormat);
1478 log.debug("Exception occured when findNodeTypeArtifactsToHandle, error is:{}", e.getMessage(), e);
1479 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
1481 return nodeTypeArtifactsToHandleRes;
1484 protected Either<List<CsarUtils.NonMetaArtifactInfo>, String> getValidArtifactNames(CsarInfo csarInfo,
1485 Map<String, Set<List<String>>> collectedWarningMessages) {
1486 List<CsarUtils.NonMetaArtifactInfo> artifactPathAndNameList = csarInfo.getCsar().entrySet().stream()
1487 .filter(e -> Pattern.compile(VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN).matcher(e.getKey()).matches())
1488 .map(e -> CsarUtils.validateNonMetaArtifact(e.getKey(), e.getValue(), collectedWarningMessages)).filter(Either::isLeft)
1489 .map(e -> e.left().value()).collect(toList());
1490 Pattern englishNumbersAndUnderScoresOnly = Pattern.compile(CsarUtils.VALID_ENGLISH_ARTIFACT_NAME);
1491 for (CsarUtils.NonMetaArtifactInfo nonMetaArtifactInfo : artifactPathAndNameList) {
1492 if (!englishNumbersAndUnderScoresOnly.matcher(nonMetaArtifactInfo.getDisplayName()).matches()) {
1493 return Either.right(nonMetaArtifactInfo.getArtifactName());
1496 return Either.left(artifactPathAndNameList);
1499 protected Either<Service, ResponseFormat> createGroupsOnResource(Service service, Map<String, GroupDefinition> groups) {
1500 if (groups != null && !groups.isEmpty()) {
1501 List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, service);
1502 serviceImportParseLogic.handleGroupsProperties(service, groups);
1503 serviceImportParseLogic.fillGroupsFinalFields(groupsAsList);
1504 Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic.createGroups(service, groupsAsList, true);
1505 if (createGroups.isRight()) {
1506 return Either.right(createGroups.right().value());
1509 return Either.left(service);
1511 return getServiceResponseFormatEither(service);
1514 private Either<Service, ResponseFormat> createPoliciesOnResource(final Service service,
1515 final Map<String, PolicyDefinition> policies) {
1516 if (MapUtils.isEmpty(policies)) {
1517 return Either.left(service);
1519 Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = service.getComponentInstancesAttributes();
1520 final Map<String, List<AttributeDefinition>> instanceAttributeMap = new HashMap<>();
1521 if (MapUtils.isNotEmpty(componentInstancesAttributes)) {
1522 instanceAttributeMap.putAll(componentInstancesAttributes
1523 .entrySet().stream()
1524 .collect(toMap(Entry::getKey, entry -> entry.getValue().stream().map(AttributeDefinition.class::cast).collect(toList()))));
1526 policies.values().stream()
1527 .map(PolicyDataDefinition::getProperties)
1528 .flatMap(Collection::stream)
1529 .filter(PropertyDataDefinition::isToscaFunction)
1530 .forEach(policyDefinition -> toscaFunctionService
1531 .updateFunctionWithDataFromSelfComponent(policyDefinition.getToscaFunction(), service, service.getComponentInstancesProperties(),
1532 instanceAttributeMap)
1534 policyBusinessLogic.createPolicies(service, policies);
1535 return getServiceResponseFormatEither(service);
1538 private Either<Service, ResponseFormat> getServiceResponseFormatEither(Service service) {
1539 Either<Service, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
1540 if (updatedResource.isRight()) {
1541 ResponseFormat responseFormat = componentsUtils
1542 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), service,
1543 ComponentTypeEnum.SERVICE);
1544 return Either.right(responseFormat);
1546 return Either.left(updatedResource.left().value());
1549 protected List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups, Service component) {
1550 List<GroupDefinition> result = new ArrayList<>();
1551 List<ComponentInstance> componentInstances = component.getComponentInstances();
1552 if (groups != null) {
1553 for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
1554 String groupName = entry.getKey();
1555 GroupDefinition groupDefinition = entry.getValue();
1556 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
1557 updatedGroupDefinition.setMembers(null);
1558 Map<String, String> members = groupDefinition.getMembers();
1559 if (members != null) {
1560 serviceImportParseLogic.updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
1562 result.add(updatedGroupDefinition);
1568 protected Resource createRIAndRelationsFromYaml(String yamlName, Resource resource,
1569 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap,
1570 String topologyTemplateYaml, List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1571 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1572 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
1575 log.debug("************* Going to create all nodes {}", yamlName);
1576 handleNodeTypes(yamlName, resource, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
1577 csarInfo, nodeName);
1578 log.debug("************* Going to create all resource instances {}", yamlName);
1579 resource = createResourceInstances(yamlName, resource, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes());
1580 log.debug("************* Finished to create all resource instances {}", yamlName);
1581 resource = createResourceInstancesRelations(csarInfo.getModifier(), yamlName, resource, uploadComponentInstanceInfoMap);
1582 log.debug("************* Going to create positions {}", yamlName);
1583 compositionBusinessLogic.setPositionsForComponentInstances(resource, csarInfo.getModifier().getUserId());
1584 log.debug("************* Finished to set positions {}", yamlName);
1586 } catch (Exception e) {
1587 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1591 protected Resource createResourceInstancesRelations(User user, String yamlName, Resource resource,
1592 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1593 log.debug("#createResourceInstancesRelations - Going to create relations ");
1594 List<ComponentInstance> componentInstancesList = resource.getComponentInstances();
1595 if (((MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)) &&
1596 resource.getResourceType() != ResourceTypeEnum.PNF)) { // PNF can have no resource instances
1597 log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
1598 resource.getUniqueId(), yamlName);
1599 BeEcompErrorManager.getInstance()
1600 .logInternalDataError("createResourceInstancesRelations", "No instances found in a resource or nn yaml template. ",
1601 BeEcompErrorManager.ErrorSeverity.ERROR);
1602 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName));
1604 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1605 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1606 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1607 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1608 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1609 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1610 Map<String, Resource> originCompMap = new HashMap<>();
1611 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1612 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1613 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1614 Map<String, Map<String, InterfaceDefinition>> instInterfaces = new HashMap<>();
1615 log.debug("enter ServiceImportBusinessLogic createResourceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. ");
1616 final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache;
1617 if (applicationDataTypeCache != null) {
1618 Resource finalResource = resource;
1619 uploadResInstancesMap.values().forEach(
1620 i -> processComponentInstance(yamlName, finalResource, componentInstancesList,
1621 componentsUtils.getAllDataTypes(applicationDataTypeCache, finalResource.getModel()), instProperties, instCapabilities,
1622 instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs, instNodeFilter,
1623 instInterfaces, i));
1625 serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, resource, instProperties);
1626 serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, resource, instInputs);
1627 serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts);
1628 serviceImportParseLogic.associateArtifactsToInstances(yamlName, resource, instArtifacts);
1629 serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements);
1630 serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes);
1631 resource = serviceImportParseLogic.getResourceAfterCreateRelations(resource);
1632 serviceImportParseLogic.addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList, relations);
1633 serviceImportParseLogic.associateResourceInstances(yamlName, resource, relations);
1634 handleSubstitutionMappings(resource, uploadResInstancesMap);
1635 log.debug("************* in create relations, getResource start");
1636 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
1637 log.debug("************* in create relations, getResource end");
1638 if (eitherGetResource.isRight()) {
1639 throw new ComponentException(
1640 componentsUtils.getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource));
1642 return eitherGetResource.left().value();
1645 protected void processProperty(Resource resource, Map<String, DataTypeDefinition> allDataTypes,
1646 Map<String, InputDefinition> currPropertiesMap, List<ComponentInstanceInput> instPropList,
1647 List<UploadPropInfo> propertyList) {
1648 UploadPropInfo propertyInfo = propertyList.get(0);
1649 String propName = propertyInfo.getName();
1650 if (!currPropertiesMap.containsKey(propName)) {
1651 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName));
1653 processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, resource.getInputs());
1656 private void processProperty(Map<String, DataTypeDefinition> allDataTypes, Map<String, InputDefinition> currPropertiesMap,
1657 List<ComponentInstanceInput> instPropList, UploadPropInfo propertyInfo, String propName,
1658 List<InputDefinition> inputs2) {
1659 InputDefinition curPropertyDef = currPropertiesMap.get(propName);
1660 ComponentInstanceInput property = null;
1661 String value = null;
1662 List<GetInputValueDataDefinition> getInputs = null;
1663 boolean isValidate = true;
1664 if (propertyInfo.getValue() != null) {
1665 getInputs = propertyInfo.getGet_input();
1666 isValidate = getInputs == null || getInputs.isEmpty();
1668 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
1670 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
1673 property = new ComponentInstanceInput(curPropertyDef, value, null);
1674 String validPropertyVAlue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
1675 property.setValue(validPropertyVAlue);
1676 if (isNotEmpty(getInputs)) {
1677 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
1678 for (GetInputValueDataDefinition getInput : getInputs) {
1679 List<InputDefinition> inputs = inputs2;
1680 if (CollectionUtils.isEmpty(inputs)) {
1681 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1683 Optional<InputDefinition> optional = inputs.stream().filter(p -> p.getName().equals(getInput.getInputName())).findAny();
1684 if (!optional.isPresent()) {
1685 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
1687 InputDefinition input = optional.get();
1688 getInput.setInputId(input.getUniqueId());
1689 getInputValues.add(getInput);
1690 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
1691 processGetInput(getInputValues, inputs, getInputIndex);
1693 property.setGetInputValues(getInputValues);
1695 instPropList.add(property);
1696 currPropertiesMap.remove(property.getName());
1699 protected void handleSubstitutionMappings(Resource resource, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
1700 if (resource.getResourceType() == ResourceTypeEnum.VF) {
1701 Either<Resource, StorageOperationStatus> getResourceRes = toscaOperationFacade.getToscaFullElement(resource.getUniqueId());
1702 if (getResourceRes.isRight()) {
1703 ResponseFormat responseFormat = componentsUtils
1704 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource);
1705 throw new ComponentException(responseFormat);
1707 getResourceRes = updateCalculatedCapReqWithSubstitutionMappings(getResourceRes.left().value(), uploadResInstancesMap);
1708 if (getResourceRes.isRight()) {
1709 ResponseFormat responseFormat = componentsUtils
1710 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right().value()), resource);
1711 throw new ComponentException(responseFormat);
1716 protected Resource createResourceInstances(String yamlName, Resource resource, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1717 Map<String, Resource> nodeNamespaceMap) {
1718 Either<Resource, ResponseFormat> eitherResource = null;
1719 log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
1720 if (MapUtils.isEmpty(uploadResInstancesMap) && resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
1721 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
1722 throw new ComponentException(responseFormat);
1724 Map<String, Resource> existingNodeTypeMap = new HashMap<>();
1725 if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
1726 nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v));
1728 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
1729 uploadResInstancesMap.values()
1730 .forEach(i -> createAndAddResourceInstance(i, yamlName, resource, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap));
1731 if (MapUtils.isNotEmpty(resourcesInstancesMap)) {
1733 toscaOperationFacade.associateComponentInstancesToComponent(resource, resourcesInstancesMap, false, false);
1734 } catch (StorageException exp) {
1735 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
1736 log.debug("Failed to add component instances to container component {}", resource.getName());
1737 ResponseFormat responseFormat = componentsUtils
1738 .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
1739 eitherResource = Either.right(responseFormat);
1740 throw new ByResponseFormatComponentException(eitherResource.right().value());
1744 log.debug("*************Going to get resource {}", resource.getUniqueId());
1745 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade
1746 .getToscaElement(resource.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter());
1747 log.debug("*************finished to get resource {}", resource.getUniqueId());
1748 if (eitherGetResource.isRight()) {
1749 ResponseFormat responseFormat = componentsUtils
1750 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), resource);
1751 throw new ComponentException(responseFormat);
1753 if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances()) &&
1754 resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
1755 log.debug("Error when create resource instance from csar. ComponentInstances list empty");
1756 BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty");
1757 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
1759 return eitherGetResource.left().value();
1762 protected void handleNodeTypes(String yamlName, Resource resource, String topologyTemplateYaml, boolean needLock,
1763 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1764 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1767 for (Map.Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
1768 if (nodeTypeEntry.getValue().isNested()) {
1769 handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1770 nodeTypeEntry.getKey());
1771 log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
1774 Map<String, Object> mappedToscaTemplate = null;
1775 if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo
1776 .containsKey(nodeName)) {
1777 mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
1779 if (MapUtils.isEmpty(mappedToscaTemplate)) {
1780 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
1782 createResourcesFromYamlNodeTypesList(yamlName, resource, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle,
1783 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
1784 } catch (ComponentException e) {
1785 ResponseFormat responseFormat =
1786 e.getResponseFormat() != null ? e.getResponseFormat() : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
1787 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
1789 } catch (StorageException e) {
1790 ResponseFormat responseFormat = componentsUtils
1791 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
1792 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
1794 } catch (Exception e) {
1795 log.debug("Exception occured when handleNodeTypes, error is:{}", e.getMessage(), e);
1796 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1800 protected Resource handleNestedVfc(Service service,
1801 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1802 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1805 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
1806 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
1807 createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
1809 log.debug("************* Finished to create node types from yaml {}", yamlName);
1810 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1811 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1812 return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
1814 return new Resource();
1815 } catch (Exception e) {
1816 log.debug("Exception occured when handleNestedVFc, error is:{}", e.getMessage(), e);
1817 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1821 protected Resource handleNestedVfc(Resource resource,
1822 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1823 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1825 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
1826 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
1827 log.debug("************* Going to create node types from yaml {}", yamlName);
1828 createResourcesFromYamlNodeTypesList(yamlName, resource, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
1830 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1831 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1832 resource = handleComplexVfc(resource, nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
1837 protected Resource handleComplexVfc(Resource resource,
1838 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1839 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1840 String nodeName, String yamlName) {
1841 Resource oldComplexVfc = null;
1842 Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(resource, csarInfo, nodeName, nodesInfo);
1843 Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
1844 .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
1845 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
1846 oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
1847 serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), nodeName).getRight());
1849 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
1850 throw new ComponentException(ActionStatus.GENERAL_ERROR);
1851 } else if (oldComplexVfcRes.isLeft()) {
1852 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
1853 Either<Boolean, ResponseFormat> eitherValidation = serviceImportParseLogic
1854 .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc,
1855 ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
1856 if (eitherValidation.isLeft()) {
1857 oldComplexVfc = oldComplexVfcRes.left().value();
1860 newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc,
1862 csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
1863 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
1864 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR);
1865 log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
1866 final Resource result = serviceImportParseLogic
1867 .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true);
1868 csarInfo.getCreatedNodes().put(nodeName, result);
1869 csarInfo.removeNodeFromQueue();
1873 private Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Resource resource, Map<String, Object> mappedToscaTemplate,
1875 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1876 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1877 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
1878 Either<String, ImportUtils.ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
1879 TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
1880 if (toscaVersion.isRight()) {
1881 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
1883 Map<String, Object> mapToConvert = new HashMap<>();
1884 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value());
1885 Map<String, Object> nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate);
1886 createNodeTypes(yamlName, resource, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, mapToConvert,
1888 return csarInfo.getCreatedNodes();
1891 protected void createNodeTypes(String yamlName, Resource resource, boolean needLock,
1892 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1893 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1894 Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
1895 Iterator<Map.Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet().iterator();
1896 Resource vfcCreated = null;
1897 while (nodesNameValueIter.hasNext()) {
1898 Map.Entry<String, Object> nodeType = nodesNameValueIter.next();
1899 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle =
1900 nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeType.getKey());
1901 if (nodeTypesInfo.containsKey(nodeType.getKey())) {
1902 log.trace("************* Going to handle nested vfc {}", nodeType.getKey());
1903 vfcCreated = handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
1905 log.trace("************* Finished to handle nested vfc {}", nodeType.getKey());
1906 } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames()
1907 .containsKey(nodeType.getKey())) {
1908 log.trace("************* Going to create node {}", nodeType.getKey());
1909 ImmutablePair<Resource, ActionStatus> resourceCreated = createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(),
1910 mapToConvert, resource, needLock, nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true);
1911 log.debug("************* Finished to create node {}", nodeType.getKey());
1912 vfcCreated = resourceCreated.getLeft();
1913 csarInfo.getCreatedNodesToscaResourceNames().put(nodeType.getKey(), vfcCreated.getToscaResourceName());
1915 if (vfcCreated != null) {
1916 csarInfo.getCreatedNodes().put(nodeType.getKey(), vfcCreated);
1918 mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());
1922 protected ImmutablePair<Resource, ActionStatus> createNodeTypeResourceFromYaml(String yamlName, Map.Entry<String, Object> nodeNameValue,
1923 User user, Map<String, Object> mapToConvert, Resource resourceVf,
1925 Map<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
1926 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1927 boolean forceCertificationAllowed, CsarInfo csarInfo,
1929 final var validatedUser = serviceBusinessLogic.validateUser(user, "CheckIn Resource", resourceVf, AuditingActionEnum.CHECKIN_RESOURCE,
1931 UploadResourceInfo resourceMetaData = serviceImportParseLogic.fillResourceMetadata(yamlName, resourceVf, nodeNameValue.getKey(),
1933 String singleVfcYaml = serviceImportParseLogic.buildNodeTypeYaml(nodeNameValue, mapToConvert, resourceMetaData.getResourceType(), csarInfo);
1934 return serviceImportParseLogic.createResourceFromNodeType(singleVfcYaml, resourceMetaData, validatedUser, true, needLock,
1935 nodeTypeArtifactsToHandle,
1936 nodeTypesNewCreatedArtifacts, forceCertificationAllowed, csarInfo, nodeNameValue.getKey(), isNested);
1939 protected Service createRIAndRelationsFromYaml(String yamlName, Service service,
1940 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap,
1941 String topologyTemplateYaml, List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1942 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1943 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
1945 log.debug("************* Going to create all nodes {}", yamlName);
1946 handleServiceNodeTypes(yamlName, service, topologyTemplateYaml, false, nodeTypesArtifactsToCreate, nodeTypesNewCreatedArtifacts,
1947 nodeTypesInfo, csarInfo, nodeName);
1948 List<PropertyDefinition> serviceProperties = null != service ? service.getProperties() : Collections.emptyList();
1949 if (MapUtils.isNotEmpty(uploadComponentInstanceInfoMap)) {
1950 log.debug("************* Going to create all resource instances {}", yamlName);
1951 service = createServiceInstances(yamlName, service, uploadComponentInstanceInfoMap, csarInfo.getCreatedNodes());
1952 log.debug("************* Going to create all relations {}", yamlName);
1953 service = createServiceInstancesRelations(csarInfo.getModifier(), yamlName, service, uploadComponentInstanceInfoMap, serviceProperties);
1954 log.debug("************* Going to create positions {}", yamlName);
1955 compositionBusinessLogic.setPositionsForComponentInstances(service, csarInfo.getModifier().getUserId());
1956 log.debug("************* Finished to set positions {}", yamlName);
1961 protected Service createServiceInstancesRelations(User user, String yamlName, Service service,
1962 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
1963 List<PropertyDefinition> serviceProperties) {
1964 log.debug("#createResourceInstancesRelations - Going to create relations ");
1965 List<ComponentInstance> componentInstancesList = service.getComponentInstances();
1966 if (MapUtils.isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList)) { // PNF can have no resource instances
1967 log.debug("#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
1968 service.getUniqueId(), yamlName);
1969 BeEcompErrorManager.getInstance()
1970 .logInternalDataError("createResourceInstancesRelations", "No instances found in a component or nn yaml template. ",
1971 BeEcompErrorManager.ErrorSeverity.ERROR);
1972 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName));
1974 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
1975 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
1976 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
1977 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
1978 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
1979 Map<String, List<AttributeDefinition>> instAttributes = new HashMap<>();
1980 Map<String, Resource> originCompMap = new HashMap<>();
1981 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1982 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
1983 Map<String, UploadNodeFilterInfo> instNodeFilter = new HashMap<>();
1984 Map<String, Map<String, InterfaceDefinition>> instInterfaces = new HashMap<>();
1985 log.debug("enter ServiceImportBusinessLogic createServiceInstancesRelations#createResourceInstancesRelations - Before get all datatypes. ");
1986 final ApplicationDataTypeCache applicationDataTypeCache = serviceBusinessLogic.applicationDataTypeCache;
1987 if (applicationDataTypeCache != null) {
1988 final Map<String, DataTypeDefinition> allDataTypesMap =
1989 componentsUtils.getAllDataTypes(applicationDataTypeCache, service.getModel());
1990 final Service service1 = service;
1991 service1.setProperties(serviceProperties);
1992 uploadResInstancesMap.values().forEach(
1993 i -> processComponentInstance(yamlName, service1, componentInstancesList,
1994 allDataTypesMap, instProperties,
1995 instCapabilities, instRequirements, instDeploymentArtifacts, instArtifacts, instAttributes, originCompMap, instInputs,
1996 instNodeFilter, instInterfaces, i)
1999 updatePropertyToscaFunctionData(service, instProperties, instAttributes);
2000 serviceImportParseLogic.associateComponentInstancePropertiesToComponent(yamlName, service, instProperties);
2001 serviceImportParseLogic.associateComponentInstanceInterfacesToComponent(
2006 serviceImportParseLogic.associateComponentInstanceInputsToComponent(yamlName, service, instInputs);
2007 serviceImportParseLogic.associateCINodeFilterToComponent(yamlName, service, instNodeFilter);
2008 serviceImportParseLogic.associateDeploymentArtifactsToInstances(user, yamlName, service, instDeploymentArtifacts);
2009 serviceImportParseLogic.associateArtifactsToInstances(yamlName, service, instArtifacts);
2010 serviceImportParseLogic.associateOrAddCalculatedCapReq(yamlName, service, instCapabilities, instRequirements);
2011 log.debug("enter createServiceInstancesRelations test,instRequirements:{},instCapabilities:{}", instRequirements, instCapabilities);
2012 serviceImportParseLogic.associateInstAttributeToComponentToInstances(yamlName, service, instAttributes);
2013 ToscaElement serviceTemplate = ModelConverter.convertToToscaElement(service);
2014 Map<String, ListCapabilityDataDefinition> capabilities = serviceTemplate.getCapabilities();
2015 Map<String, ListRequirementDataDefinition> requirements = serviceTemplate.getRequirements();
2016 serviceImportParseLogic.associateCapabilitiesToService(yamlName, service, capabilities);
2017 serviceImportParseLogic.associateRequirementsToService(yamlName, service, requirements);
2018 service = getResourceAfterCreateRelations(service);
2019 addRelationsToRI(yamlName, service, uploadResInstancesMap, componentInstancesList, relations);
2020 serviceImportParseLogic.associateResourceInstances(yamlName, service, relations);
2021 log.debug("************* in create relations, getResource start");
2022 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId());
2023 log.debug("************* in create relations, getResource end");
2024 if (eitherGetResource.isRight()) {
2025 throw new ComponentException(componentsUtils
2026 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service,
2027 service.getComponentType()));
2029 return eitherGetResource.left().value();
2032 private void updatePropertyToscaFunctionData(final Component service,
2033 final Map<String, List<ComponentInstanceProperty>> instancePropertyMap,
2034 final Map<String, List<AttributeDefinition>> instanceAttributeMap) {
2035 final Component updatedService =
2036 toscaOperationFacade.getToscaElement(service.getUniqueId()).left()
2037 .on(storageOperationStatus -> {
2038 final ActionStatus status = componentsUtils.convertFromStorageResponse(storageOperationStatus);
2039 final ResponseFormat responseFormat =
2040 componentsUtils.getResponseFormatByComponent(status, service, service.getComponentType());
2041 throw new ComponentException(responseFormat);
2044 instancePropertyMap.values().forEach(instancePropertyList ->
2045 instancePropertyList.stream()
2046 .filter(PropertyDataDefinition::isToscaFunction)
2047 .forEach(instanceProperty -> {
2048 toscaFunctionService.updateFunctionWithDataFromSelfComponent(instanceProperty.getToscaFunction(),
2049 updatedService, instancePropertyMap, instanceAttributeMap);
2050 instanceProperty.setValue(StringEscapeUtils.unescapeJava(instanceProperty.getToscaFunction().getValue()));
2055 protected void processComponentInstance(String yamlName, Component component, List<ComponentInstance> componentInstancesList,
2056 Map<String, DataTypeDefinition> allDataTypes,
2057 Map<String, List<ComponentInstanceProperty>> instProperties,
2058 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
2059 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements,
2060 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts,
2061 Map<String, Map<String, ArtifactDefinition>> instArtifacts,
2062 Map<String, List<AttributeDefinition>> instAttributes, Map<String, Resource> originCompMap,
2063 Map<String, List<ComponentInstanceInput>> instInputs,
2064 Map<String, UploadNodeFilterInfo> instNodeFilter,
2065 Map<String, Map<String, InterfaceDefinition>> instInterfaces,
2066 UploadComponentInstanceInfo uploadComponentInstanceInfo) {
2067 log.debug("enter ServiceImportBusinessLogic processComponentInstance");
2068 Optional<ComponentInstance> currentCompInstanceOpt = componentInstancesList.stream()
2069 .filter(i -> i.getName().equals(uploadComponentInstanceInfo.getName())).findFirst();
2070 if (currentCompInstanceOpt.isEmpty()) {
2071 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), component.getUniqueId());
2072 BeEcompErrorManager.getInstance()
2073 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, component.getUniqueId(),
2074 BeEcompErrorManager.ErrorSeverity.ERROR);
2075 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2076 throw new ComponentException(responseFormat);
2078 ComponentInstance currentCompInstance = currentCompInstanceOpt.get();
2079 String resourceInstanceId = currentCompInstance.getUniqueId();
2080 Resource originResource = getOriginResource(yamlName, originCompMap, currentCompInstance);
2081 if (MapUtils.isNotEmpty(originResource.getRequirements())) {
2082 instRequirements.put(currentCompInstance, originResource.getRequirements());
2084 if (MapUtils.isNotEmpty(originResource.getCapabilities())) {
2085 processComponentInstanceCapabilities(allDataTypes, instCapabilties, uploadComponentInstanceInfo, currentCompInstance, originResource);
2087 if (originResource.getDeploymentArtifacts() != null && !originResource.getDeploymentArtifacts().isEmpty()) {
2088 instDeploymentArtifacts.put(resourceInstanceId, originResource.getDeploymentArtifacts());
2090 if (originResource.getArtifacts() != null && !originResource.getArtifacts().isEmpty()) {
2091 instArtifacts.put(resourceInstanceId, originResource.getArtifacts());
2093 if (originResource.getAttributes() != null && !originResource.getAttributes().isEmpty()) {
2094 instAttributes.put(resourceInstanceId, originResource.getAttributes());
2095 addAttributeValueToResourceInstance(instAttributes, uploadComponentInstanceInfo.getAttributes());
2097 if (uploadComponentInstanceInfo.getUploadNodeFilterInfo() == null) {
2098 instNodeFilter.put(resourceInstanceId, new UploadNodeFilterInfo());
2100 instNodeFilter.put(resourceInstanceId, uploadComponentInstanceInfo.getUploadNodeFilterInfo());
2102 if (MapUtils.isNotEmpty(uploadComponentInstanceInfo.getInterfaces())) {
2104 ResponseFormat addInterfacesToRiRes = addInterfaceValuesToRi(
2105 uploadComponentInstanceInfo,
2108 currentCompInstance,
2111 if (addInterfacesToRiRes.getStatus() != 200) {
2112 throw new ComponentException(addInterfacesToRiRes);
2115 if (originResource.getResourceType() != ResourceTypeEnum.VF) {
2116 ResponseFormat addPropertiesValueToRiRes = addPropertyValuesToRi(uploadComponentInstanceInfo, component, originResource,
2117 currentCompInstance, instProperties, allDataTypes);
2118 if (addPropertiesValueToRiRes.getStatus() != 200) {
2119 throw new ComponentException(addPropertiesValueToRiRes);
2122 addInputsValuesToRi(uploadComponentInstanceInfo, component, originResource, currentCompInstance, instInputs, allDataTypes);
2126 protected void addInputsValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component, Resource originResource,
2127 ComponentInstance currentCompInstance, Map<String, List<ComponentInstanceInput>> instInputs,
2128 Map<String, DataTypeDefinition> allDataTypes) {
2129 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
2131 if (MapUtils.isNotEmpty(propMap)) {
2132 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
2133 List<ComponentInstanceInput> instPropList = new ArrayList<>();
2134 if (CollectionUtils.isEmpty(originResource.getInputs())) {
2135 log.debug("failed to find properties ");
2136 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND));
2138 originResource.getInputs().forEach(p -> serviceImportParseLogic.addInput(currPropertiesMap, p));
2139 for (List<UploadPropInfo> propertyList : propMap.values()) {
2140 processProperty(component, allDataTypes, currPropertiesMap, instPropList, propertyList);
2142 currPropertiesMap.values().forEach(p -> instPropList.add(new ComponentInstanceInput(p)));
2143 instInputs.put(currentCompInstance.getUniqueId(), instPropList);
2145 } catch (Exception e) {
2146 log.debug("failed to add Inputs Values To Ri");
2147 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2151 protected void processProperty(Component component, Map<String, DataTypeDefinition> allDataTypes,
2152 Map<String, InputDefinition> currPropertiesMap, List<ComponentInstanceInput> instPropList,
2153 List<UploadPropInfo> propertyList) {
2154 UploadPropInfo propertyInfo = propertyList.get(0);
2155 String propName = propertyInfo.getName();
2156 if (!currPropertiesMap.containsKey(propName)) {
2157 log.debug("failed to find property {} ", propName);
2158 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName));
2160 processProperty(allDataTypes, currPropertiesMap, instPropList, propertyInfo, propName, component.getInputs());
2163 protected void processGetInput(List<GetInputValueDataDefinition> getInputValues, List<InputDefinition> inputs,
2164 GetInputValueDataDefinition getInputIndex) {
2165 Optional<InputDefinition> optional;
2166 if (getInputIndex != null) {
2167 optional = inputs.stream().filter(p -> p.getName().equals(getInputIndex.getInputName())).findAny();
2168 if (!optional.isPresent()) {
2169 log.debug("Failed to find input {} ", getInputIndex.getInputName());
2170 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT));
2172 InputDefinition inputIndex = optional.get();
2173 getInputIndex.setInputId(inputIndex.getUniqueId());
2174 getInputValues.add(getInputIndex);
2178 private void addAttributeValueToResourceInstance(Map<String, List<AttributeDefinition>> instAttributes,
2179 Map<String, UploadAttributeInfo> attributeMap) {
2180 if (attributeMap == null) {
2183 attributeMap.forEach((attributeName, attributeValue) -> instAttributes.values()
2184 .forEach(value -> value.stream().filter(attr -> attr.getName().equals(attributeName)).forEach(attr -> {
2185 if (attributeValue.getValue() instanceof Collection<?> || attributeValue.getValue() instanceof Map<?, ?>) {
2186 Gson gson = new Gson();
2187 String json = gson.toJson(attributeValue.getValue());
2188 attr.setValue(json);
2190 attr.setValue(String.valueOf(attributeValue.getValue()));
2195 protected ResponseFormat addPropertyValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Component component,
2196 Resource originResource, ComponentInstance currentCompInstance,
2197 Map<String, List<ComponentInstanceProperty>> instProperties,
2198 Map<String, DataTypeDefinition> allDataTypes) {
2199 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
2200 Map<String, PropertyDefinition> currPropertiesMap = new HashMap<>();
2201 List<PropertyDefinition> originalPropertyList = originResource.getProperties();
2202 if (MapUtils.isNotEmpty(propMap) && CollectionUtils.isEmpty(originalPropertyList)) {
2203 log.debug("failed to find properties ");
2204 return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND);
2206 if (CollectionUtils.isEmpty(originalPropertyList)) {
2207 return componentsUtils.getResponseFormat(ActionStatus.OK);
2209 originalPropertyList.stream()
2210 .filter(property -> !currPropertiesMap.containsKey(property.getName()))
2211 .forEach(property -> currPropertiesMap.put(property.getName(), property));
2212 List<ComponentInstanceProperty> instPropList = new ArrayList<>();
2213 if (MapUtils.isNotEmpty(propMap)) {
2214 for (final List<UploadPropInfo> propertyList : propMap.values()) {
2215 UploadPropInfo propertyInfo = propertyList.get(0);
2216 String propName = propertyInfo.getName();
2217 if (!currPropertiesMap.containsKey(propName)) {
2218 log.debug("failed to find property {} ", propName);
2219 return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName);
2221 PropertyDefinition curPropertyDef = currPropertiesMap.get(propName);
2222 String value = null;
2223 final List<GetInputValueDataDefinition> getInputs = new ArrayList<>();
2224 boolean isValidate = true;
2225 if (propertyInfo.getValue() != null) {
2226 getInputs.addAll(propertyInfo.getGet_input());
2227 isValidate = getInputs.isEmpty();
2229 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
2231 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
2234 final var property = new ComponentInstanceProperty(curPropertyDef, value, null);
2235 String validatedPropValue = serviceBusinessLogic.validatePropValueBeforeCreate(property, value, true, allDataTypes);
2237 addSubPropertyYamlToscaFunctions(validatedPropValue, value, property.getType(), propertyInfo, allDataTypes);
2239 if (CollectionUtils.isNotEmpty(propertyInfo.getSubPropertyToscaFunctions())) {
2240 validatedPropValue = value;
2243 property.setValue(validatedPropValue);
2245 if (tryHandlingAsYamlToscaFunction(validatedPropValue, value, propertyInfo)) {
2247 final Object yamlValue = new Yaml().loadAs(value, Object.class);
2248 CustomYamlFunction toscaFunction = new CustomYamlFunction();
2249 toscaFunction.setYamlValue(yamlValue);
2250 property.setToscaFunction(toscaFunction);
2251 } catch (Exception exception) {
2252 log.info("Cannot create YAML value for {}", propName);
2255 property.setToscaFunction(propertyInfo.getToscaFunction());
2257 property.setSubPropertyToscaFunctions(propertyInfo.getSubPropertyToscaFunctions());
2258 if (!getInputs.isEmpty() && CollectionUtils.isEmpty(property.getSubPropertyToscaFunctions())) {
2259 final List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
2260 for (final GetInputValueDataDefinition getInput : getInputs) {
2261 final List<InputDefinition> inputs = component.getInputs();
2262 if (inputs == null || inputs.isEmpty()) {
2263 log.debug("Failed to add property {} to instance. Inputs list is empty ", property);
2264 serviceBusinessLogic.rollbackWithException(ActionStatus.INPUTS_NOT_FOUND,
2265 property.getGetInputValues().stream().map(GetInputValueDataDefinition::getInputName).collect(toList()).toString());
2267 InputDefinition input = serviceImportParseLogic.findInputByName(inputs, getInput);
2268 getInput.setInputId(input.getUniqueId());
2269 getInputValues.add(getInput);
2270 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
2271 if (getInputIndex != null) {
2272 input = serviceImportParseLogic.findInputByName(inputs, getInputIndex);
2273 getInputIndex.setInputId(input.getUniqueId());
2274 getInputValues.add(getInputIndex);
2277 property.setGetInputValues(getInputValues);
2279 instPropList.add(property);
2280 currPropertiesMap.remove(property.getName());
2283 if (!currPropertiesMap.isEmpty()) {
2284 for (PropertyDefinition value : currPropertiesMap.values()) {
2285 instPropList.add(new ComponentInstanceProperty(value));
2288 instProperties.put(currentCompInstance.getUniqueId(), instPropList);
2289 return componentsUtils.getResponseFormat(ActionStatus.OK);
2292 private boolean tryHandlingAsYamlToscaFunction(String validatedPropValue, String value, UploadPropInfo propertyInfo) {
2293 return StringUtils.isEmpty(validatedPropValue) && StringUtils.isNotEmpty(value) && propertyInfo.getToscaFunction() == null
2294 && CollectionUtils.isEmpty(propertyInfo.getSubPropertyToscaFunctions());
2297 private void addSubPropertyYamlToscaFunctions(final String validatedPropValue, final String value, final String propertyType,
2298 final UploadPropInfo propertyInfo, final Map<String, DataTypeDefinition> allDataTypes) {
2299 if (StringUtils.isNotEmpty(validatedPropValue) || StringUtils.isEmpty(value) || ToscaPropertyType.isValidType(propertyType) != null) {
2303 final JsonObject jsonObject = JsonParser.parseString(value).getAsJsonObject();
2305 final DataTypeDefinition dataTypeDefinition = allDataTypes.get(propertyType);
2306 final List<String> propertyNames =
2307 dataTypeDefinition.getProperties().stream().map(PropertyDataDefinition::getName).collect(Collectors.toList());
2309 boolean hasSubPropertyValues = jsonObject.entrySet().stream().allMatch(entry -> propertyNames.contains(entry.getKey()));
2311 if (hasSubPropertyValues) {
2312 for (final PropertyDefinition prop : dataTypeDefinition.getProperties()) {
2313 if (propertyInfo.getSubPropertyToscaFunctions().stream()
2314 .anyMatch(subPropertyToscaFunction -> subPropertyToscaFunction.getSubPropertyPath().get(0).equals(prop.getName()))) {
2317 Optional<SubPropertyToscaFunction> subPropertyToscaFunction = createSubPropertyYamlToscaFunction(jsonObject, prop, allDataTypes);
2318 if (subPropertyToscaFunction.isPresent()) {
2319 propertyInfo.getSubPropertyToscaFunctions().add(subPropertyToscaFunction.get());
2323 } catch (Exception exception) {
2324 log.info("Cannot create YAML value for {}", value);
2328 private Optional<SubPropertyToscaFunction> createSubPropertyYamlToscaFunction(final JsonObject jsonObject, final PropertyDefinition prop,
2329 final Map<String, DataTypeDefinition> allDataTypes) {
2330 JsonElement propJsonElement = jsonObject.get(prop.getName());
2331 if (propJsonElement != null) {
2332 final String subPropValue = propJsonElement.toString();
2333 final ComponentInstanceProperty subProperty = new ComponentInstanceProperty(prop, subPropValue, null);
2334 final String validateSubPropValue =
2335 serviceBusinessLogic.validatePropValueBeforeCreate(subProperty, subPropValue, true, allDataTypes);
2337 if (StringUtils.isEmpty(validateSubPropValue) && StringUtils.isNotEmpty(subPropValue)) {
2339 Object yamlValue = new Yaml().loadAs(subPropValue, Object.class);
2340 SubPropertyToscaFunction subPropertyToscaFunction = new SubPropertyToscaFunction();
2341 CustomYamlFunction toscaFunction = new CustomYamlFunction();
2342 toscaFunction.setYamlValue(yamlValue);
2343 subPropertyToscaFunction.setToscaFunction(toscaFunction);
2344 subPropertyToscaFunction.setSubPropertyPath(Collections.singletonList(prop.getName()));
2345 return Optional.of(subPropertyToscaFunction);
2346 } catch (Exception exception) {
2347 log.info("Cannot create YAML value for {}", subPropValue);
2351 return Optional.empty();
2354 protected ResponseFormat addInterfaceValuesToRi(
2355 UploadComponentInstanceInfo uploadComponentInstanceInfo,
2356 Component component,
2357 Resource originResource, ComponentInstance currentCompInstance,
2358 Map<String, Map<String, InterfaceDefinition>> instInterfaces
2360 Map<String, UploadInterfaceInfo> instanceInterfacesMap = uploadComponentInstanceInfo.getInterfaces();
2361 Map<String, InterfaceDefinition> currInterfacesMap = new HashMap<>();
2362 Map<String, InterfaceDefinition> interfacesFromNodeType = originResource.getInterfaces();
2363 if ((MapUtils.isNotEmpty(instanceInterfacesMap)) && (MapUtils.isEmpty(interfacesFromNodeType))) {
2364 log.debug("failed to find interfaces ");
2365 return componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT);
2367 if (interfacesFromNodeType == null || interfacesFromNodeType.isEmpty()) {
2368 return componentsUtils.getResponseFormat(ActionStatus.OK);
2370 for (Map.Entry<String, InterfaceDefinition> entryInstances : interfacesFromNodeType.entrySet()) {
2371 String interfaceName = entryInstances.getKey().substring(entryInstances.getKey().lastIndexOf(".") + 1);
2372 if (!currInterfacesMap.containsKey(interfaceName)) {
2373 currInterfacesMap.put(interfaceName, entryInstances.getValue());
2377 Map<String, InterfaceDefinition> instInterfacesMap = new HashMap<>();
2378 if (MapUtils.isNotEmpty(instanceInterfacesMap)) {
2379 for (UploadInterfaceInfo uploadInterfaceInfo : instanceInterfacesMap.values()) {
2380 String interfaceName = uploadInterfaceInfo.getName();
2381 if (!currInterfacesMap.containsKey(interfaceName)) {
2382 log.debug("failed to find interface {} ", interfaceName);
2383 return componentsUtils.getResponseFormat(ActionStatus.INTERFACE_NOT_FOUND_IN_COMPONENT, interfaceName);
2385 InterfaceDefinition currentInterfaceDef = currInterfacesMap.get(interfaceName);
2386 Map<String, OperationDataDefinition> operationsToAdd = new HashMap<>();
2388 Map<String, OperationDataDefinition> operations = uploadInterfaceInfo.getOperations();
2389 for (Map.Entry<String, OperationDataDefinition> operation : operations.entrySet()) {
2390 OperationDataDefinition instanceOperation = operation.getValue();
2391 OperationDataDefinition templateOperation = currentInterfaceDef.getOperationsMap().getOrDefault(operation.getKey(), new Operation(instanceOperation));
2393 ListDataDefinition<OperationInputDefinition> instanceInputs = instanceOperation.getInputs();
2394 if (null != instanceInputs) {
2395 mergeOperationInputDefinitions(templateOperation.getInputs(), instanceInputs);
2396 component.getProperties()
2397 .forEach(property -> instanceInputs.getListToscaDataDefinition().stream()
2398 .filter(instanceInput ->
2399 instanceInput.getToscaFunction() instanceof ToscaGetFunctionDataDefinition &&
2400 property.getName().equals(instanceInput.getToscaFunction() != null ?
2401 ((ToscaGetFunctionDataDefinition) instanceInput.getToscaFunction()).getPropertyName() : null))
2402 .forEach(oldInput -> oldInput.setType(property.getType()))
2404 templateOperation.setInputs(instanceInputs);
2407 templateOperation.setImplementation(instanceOperation.getImplementation());
2409 templateOperation.setDescription(instanceOperation.getDescription());
2410 operationsToAdd.put(operation.getKey(), templateOperation);
2412 InterfaceDefinition interfaceDef = new InterfaceDefinition();
2413 interfaceDef.setModel(component.getModel());
2414 interfaceDef.setType(currentInterfaceDef.getType());
2415 interfaceDef.setUniqueId(currentInterfaceDef.getType());
2416 interfaceDef.setDescription(uploadInterfaceInfo.getDescription());
2417 interfaceDef.setOperations(operationsToAdd);
2418 instInterfacesMap.put(currentInterfaceDef.getType(), interfaceDef);
2419 currInterfacesMap.remove(interfaceName);
2422 if (!currInterfacesMap.isEmpty()) {
2423 for (InterfaceDefinition value : currInterfacesMap.values()) {
2424 instInterfacesMap.put(value.getUniqueId(), value);
2427 instInterfaces.put(currentCompInstance.getUniqueId(), instInterfacesMap);
2428 return componentsUtils.getResponseFormat(ActionStatus.OK);
2431 private void mergeOperationInputDefinitions(ListDataDefinition<OperationInputDefinition> inputsFromNodeType,
2432 ListDataDefinition<OperationInputDefinition> instanceInputs) {
2433 if (inputsFromNodeType == null || CollectionUtils.isEmpty(inputsFromNodeType.getListToscaDataDefinition()) || instanceInputs == null
2434 || CollectionUtils.isEmpty(instanceInputs.getListToscaDataDefinition())) {
2437 instanceInputs.getListToscaDataDefinition().forEach(
2438 instanceInput -> inputsFromNodeType.getListToscaDataDefinition().stream().filter(
2439 templateInput -> templateInput.getName().equals(instanceInput.getName())
2441 newInstanceInput -> {
2442 instanceInput.setSourceProperty(newInstanceInput.getSourceProperty());
2443 instanceInput.setSource(newInstanceInput.getSource());
2444 instanceInput.setType(newInstanceInput.getType());
2448 instanceInputs.getListToscaDataDefinition().stream()
2449 .filter(instanceInput -> inputsFromNodeType.getListToscaDataDefinition().stream().noneMatch(
2450 inputFromNodeType -> inputFromNodeType.getName().equals(instanceInput.getName())
2452 .forEach(oldInput -> oldInput.setType("string"));
2455 protected void processComponentInstanceCapabilities(Map<String, DataTypeDefinition> allDataTypes,
2456 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
2457 UploadComponentInstanceInfo uploadComponentInstanceInfo,
2458 ComponentInstance currentCompInstance, Resource originResource) {
2459 log.debug("enter processComponentInstanceCapabilities");
2460 Map<String, List<CapabilityDefinition>> originCapabilities;
2461 if (MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities())) {
2462 originCapabilities = new HashMap<>();
2463 Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
2464 originResource.getCapabilities().forEach((k, v) -> serviceImportParseLogic.addCapabilities(originCapabilities, k, v));
2465 uploadComponentInstanceInfo.getCapabilities().values()
2466 .forEach(l -> serviceImportParseLogic.addCapabilitiesProperties(newPropertiesMap, l));
2467 updateCapabilityPropertiesValues(allDataTypes, originCapabilities, newPropertiesMap);
2469 originCapabilities = originResource.getCapabilities();
2471 instCapabilties.put(currentCompInstance, originCapabilities);
2474 protected void updateCapabilityPropertiesValues(Map<String, DataTypeDefinition> allDataTypes,
2475 Map<String, List<CapabilityDefinition>> originCapabilities,
2476 Map<String, Map<String, UploadPropInfo>> newPropertiesMap) {
2477 originCapabilities.values().stream().flatMap(Collection::stream).filter(c -> newPropertiesMap.containsKey(c.getName()))
2478 .forEach(c -> updatePropertyValues(c.getProperties(), newPropertiesMap.get(c.getName()), allDataTypes));
2481 protected void updatePropertyValues(List<ComponentInstanceProperty> properties, Map<String, UploadPropInfo> newProperties,
2482 Map<String, DataTypeDefinition> allDataTypes) {
2483 properties.forEach(p -> updatePropertyValue(p, newProperties.get(p.getName()), allDataTypes));
2486 protected String updatePropertyValue(ComponentInstanceProperty property, UploadPropInfo propertyInfo,
2487 Map<String, DataTypeDefinition> allDataTypes) {
2488 String value = null;
2489 List<GetInputValueDataDefinition> getInputs = null;
2490 boolean isValidate = true;
2491 if (null != propertyInfo && propertyInfo.getValue() != null) {
2492 getInputs = propertyInfo.getGet_input();
2493 isValidate = getInputs == null || getInputs.isEmpty();
2495 value = getPropertyJsonStringValue(propertyInfo.getValue(), property.getType());
2497 value = getPropertyJsonStringValue(propertyInfo.getValue(), TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
2500 property.setValue(value);
2501 return serviceBusinessLogic.validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
2504 protected Resource getOriginResource(String yamlName, Map<String, Resource> originCompMap, ComponentInstance currentCompInstance) {
2505 Resource originResource;
2506 log.debug("after enter ServiceImportBusinessLogic processComponentInstance, enter getOriginResource");
2507 if (!originCompMap.containsKey(currentCompInstance.getComponentUid())) {
2508 Either<Resource, StorageOperationStatus> getOriginResourceRes = toscaOperationFacade
2509 .getToscaFullElement(currentCompInstance.getComponentUid());
2510 if (getOriginResourceRes.isRight()) {
2511 ResponseFormat responseFormat = componentsUtils
2512 .getResponseFormat(componentsUtils.convertFromStorageResponse(getOriginResourceRes.right().value()), yamlName);
2513 throw new ComponentException(responseFormat);
2515 originResource = getOriginResourceRes.left().value();
2516 originCompMap.put(originResource.getUniqueId(), originResource);
2518 originResource = originCompMap.get(currentCompInstance.getComponentUid());
2520 return originResource;
2523 protected Either<Resource, StorageOperationStatus> updateCalculatedCapReqWithSubstitutionMappings(Resource resource,
2524 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
2525 Either<Resource, StorageOperationStatus> updateRes = null;
2526 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities = new HashMap<>();
2527 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements = new HashMap<>();
2528 StorageOperationStatus status = toscaOperationFacade.deleteAllCalculatedCapabilitiesRequirements(resource.getUniqueId());
2529 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
2530 log.debug("Failed to delete all calculated capabilities and requirements of resource {} upon update. Status is {}",
2531 resource.getUniqueId(), status);
2532 updateRes = Either.right(status);
2534 if (updateRes == null) {
2535 fillUpdatedInstCapabilitiesRequirements(resource.getComponentInstances(), uploadResInstancesMap, updatedInstCapabilities,
2536 updatedInstRequirements);
2537 status = toscaOperationFacade.associateOrAddCalculatedCapReq(updatedInstCapabilities, updatedInstRequirements, resource);
2538 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
2539 updateRes = Either.right(status);
2542 if (updateRes == null) {
2543 updateRes = Either.left(resource);
2548 protected void fillUpdatedInstCapabilitiesRequirements(List<ComponentInstance> componentInstances,
2549 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
2550 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities,
2551 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements) {
2552 componentInstances.stream().forEach(i -> {
2553 fillUpdatedInstCapabilities(updatedInstCapabilities, i, uploadResInstancesMap.get(i.getName()).getCapabilitiesNamesToUpdate());
2554 fillUpdatedInstRequirements(updatedInstRequirements, i, uploadResInstancesMap.get(i.getName()).getRequirementsNamesToUpdate());
2558 protected void fillUpdatedInstCapabilities(Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilties,
2559 ComponentInstance instance, Map<String, String> capabilitiesNamesToUpdate) {
2560 Map<String, List<CapabilityDefinition>> updatedCapabilities = new HashMap<>();
2561 Set<String> updatedCapNames = new HashSet<>();
2562 if (MapUtils.isNotEmpty(capabilitiesNamesToUpdate)) {
2563 for (Map.Entry<String, List<CapabilityDefinition>> requirements : instance.getCapabilities().entrySet()) {
2564 updatedCapabilities.put(requirements.getKey(), requirements.getValue().stream().filter(
2565 c -> capabilitiesNamesToUpdate.containsKey(c.getName()) && !updatedCapNames.contains(capabilitiesNamesToUpdate.get(c.getName())))
2567 c.setParentName(c.getName());
2568 c.setName(capabilitiesNamesToUpdate.get(c.getName()));
2569 updatedCapNames.add(c.getName());
2571 }).collect(toList()));
2574 if (MapUtils.isNotEmpty(updatedCapabilities)) {
2575 updatedInstCapabilties.put(instance, updatedCapabilities);
2579 protected void fillUpdatedInstRequirements(Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements,
2580 ComponentInstance instance, Map<String, String> requirementsNamesToUpdate) {
2581 Map<String, List<RequirementDefinition>> updatedRequirements = new HashMap<>();
2582 Set<String> updatedReqNames = new HashSet<>();
2583 if (MapUtils.isNotEmpty(requirementsNamesToUpdate)) {
2584 for (Map.Entry<String, List<RequirementDefinition>> requirements : instance.getRequirements().entrySet()) {
2585 updatedRequirements.put(requirements.getKey(), requirements.getValue().stream().filter(
2586 r -> requirementsNamesToUpdate.containsKey(r.getName()) && !updatedReqNames.contains(requirementsNamesToUpdate.get(r.getName())))
2588 r.setParentName(r.getName());
2589 r.setName(requirementsNamesToUpdate.get(r.getName()));
2590 updatedReqNames.add(r.getName());
2592 }).collect(toList()));
2595 if (MapUtils.isNotEmpty(updatedRequirements)) {
2596 updatedInstRequirements.put(instance, updatedRequirements);
2600 protected void addRelationsToRI(String yamlName, Service service, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
2601 List<ComponentInstance> componentInstancesList, List<RequirementCapabilityRelDef> relations) {
2602 for (Map.Entry<String, UploadComponentInstanceInfo> entry : uploadResInstancesMap.entrySet()) {
2603 UploadComponentInstanceInfo uploadComponentInstanceInfo = entry.getValue();
2604 ComponentInstance currentCompInstance = null;
2605 for (ComponentInstance compInstance : componentInstancesList) {
2606 if (compInstance.getName().equals(uploadComponentInstanceInfo.getName())) {
2607 currentCompInstance = compInstance;
2611 if (currentCompInstance == null) {
2612 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(), service.getUniqueId());
2613 BeEcompErrorManager.getInstance()
2614 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE, service.getUniqueId(),
2615 BeEcompErrorManager.ErrorSeverity.ERROR);
2616 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2617 throw new ComponentException(responseFormat);
2619 ResponseFormat addRelationToRiRes = addRelationToRI(yamlName, service, entry.getValue(), relations);
2620 if (addRelationToRiRes.getStatus() != 200) {
2621 throw new ComponentException(addRelationToRiRes);
2626 protected ResponseFormat addRelationToRI(String yamlName, Service service, UploadComponentInstanceInfo nodesInfoValue,
2627 List<RequirementCapabilityRelDef> relations) {
2628 List<ComponentInstance> componentInstancesList = service.getComponentInstances();
2629 ComponentInstance currentCompInstance = null;
2630 for (ComponentInstance compInstance : componentInstancesList) {
2631 if (compInstance.getName().equals(nodesInfoValue.getName())) {
2632 currentCompInstance = compInstance;
2636 if (currentCompInstance == null) {
2637 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, nodesInfoValue.getName(), service.getUniqueId());
2638 BeEcompErrorManager.getInstance()
2639 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + nodesInfoValue.getName() + IN_RESOURCE, service.getUniqueId(),
2640 BeEcompErrorManager.ErrorSeverity.ERROR);
2641 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2643 String resourceInstanceId = currentCompInstance.getUniqueId();
2644 Map<String, List<UploadReqInfo>> regMap = nodesInfoValue.getRequirements();
2645 if (regMap != null) {
2646 Iterator<Map.Entry<String, List<UploadReqInfo>>> nodesRegValue = regMap.entrySet().iterator();
2647 while (nodesRegValue.hasNext()) {
2648 Map.Entry<String, List<UploadReqInfo>> nodesRegInfoEntry = nodesRegValue.next();
2649 List<UploadReqInfo> uploadRegInfoList = nodesRegInfoEntry.getValue();
2650 for (UploadReqInfo uploadRegInfo : uploadRegInfoList) {
2651 log.debug("Going to create relation {}", uploadRegInfo.getName());
2652 String regName = uploadRegInfo.getName();
2653 RequirementCapabilityRelDef regCapRelDef = new RequirementCapabilityRelDef();
2654 regCapRelDef.setFromNode(resourceInstanceId);
2655 log.debug("try to find available requirement {} ", regName);
2656 Either<RequirementDefinition, ResponseFormat> eitherReqStatus = serviceImportParseLogic
2657 .findAvailableRequirement(regName, yamlName, nodesInfoValue, currentCompInstance, uploadRegInfo.getCapabilityName());
2658 if (eitherReqStatus.isRight()) {
2659 log.debug("failed to find available requirement {} status is {}", regName, eitherReqStatus.right().value());
2660 return eitherReqStatus.right().value();
2662 RequirementDefinition validReq = eitherReqStatus.left().value();
2663 List<CapabilityRequirementRelationship> reqAndRelationshipPairList = regCapRelDef.getRelationships();
2664 if (reqAndRelationshipPairList == null) {
2665 reqAndRelationshipPairList = new ArrayList<>();
2667 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
2668 reqAndRelationshipPair.setRequirement(regName);
2669 reqAndRelationshipPair.setRequirementOwnerId(validReq.getOwnerId());
2670 reqAndRelationshipPair.setRequirementUid(validReq.getUniqueId());
2671 RelationshipImpl relationship = new RelationshipImpl();
2672 relationship.setType(validReq.getCapability());
2673 reqAndRelationshipPair.setRelationships(relationship);
2674 ComponentInstance currentCapCompInstance = null;
2675 for (ComponentInstance compInstance : componentInstancesList) {
2676 if (compInstance.getName().equals(uploadRegInfo.getNode())) {
2677 currentCapCompInstance = compInstance;
2681 if (currentCapCompInstance == null) {
2682 log.debug("The component instance with name {} not found on resource {} ", uploadRegInfo.getNode(), service.getUniqueId());
2683 BeEcompErrorManager.getInstance()
2684 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + uploadRegInfo.getNode() + IN_RESOURCE, service.getUniqueId(),
2685 BeEcompErrorManager.ErrorSeverity.ERROR);
2686 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2688 regCapRelDef.setToNode(currentCapCompInstance.getUniqueId());
2689 log.debug("try to find aviable Capability req name is {} ", validReq.getName());
2690 CapabilityDefinition aviableCapForRel = serviceImportParseLogic
2691 .findAvailableCapabilityByTypeOrName(validReq, currentCapCompInstance, uploadRegInfo);
2692 if (aviableCapForRel == null) {
2693 BeEcompErrorManager.getInstance().logInternalDataError(
2694 "aviable capability was not found. req name is " + validReq.getName() + " component instance is " + currentCapCompInstance
2695 .getUniqueId(), service.getUniqueId(), BeEcompErrorManager.ErrorSeverity.ERROR);
2696 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2698 reqAndRelationshipPair.setCapability(aviableCapForRel.getName());
2699 reqAndRelationshipPair.setCapabilityUid(aviableCapForRel.getUniqueId());
2700 reqAndRelationshipPair.setCapabilityOwnerId(aviableCapForRel.getOwnerId());
2701 CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship();
2702 capReqRel.setRelation(reqAndRelationshipPair);
2703 if (StringUtils.isNotEmpty(uploadRegInfo.getRelationshipTemplate())) {
2704 capReqRel.setOperations(getOperations(nodesInfoValue.getOperations(), uploadRegInfo.getRelationshipTemplate()));
2706 reqAndRelationshipPairList.add(capReqRel);
2707 regCapRelDef.setRelationships(reqAndRelationshipPairList);
2708 relations.add(regCapRelDef);
2712 return componentsUtils.getResponseFormat(ActionStatus.OK, yamlName);
2715 private List<OperationUi> getOperations(final Map<String, List<OperationUi>> operations, final String relationshipTemplate) {
2716 final List<OperationUi> operationUiList = new ArrayList<>();
2717 operations.forEach((operationKey, operationValues) -> {
2718 if (operationKey.equals(relationshipTemplate)) {
2719 operationUiList.addAll(operationValues);
2722 return operationUiList;
2725 protected Service getResourceAfterCreateRelations(Service service) {
2726 ComponentParametersView parametersView = serviceImportParseLogic.getComponentFilterAfterCreateRelations();
2727 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade.getToscaElement(service.getUniqueId(), parametersView);
2728 if (eitherGetResource.isRight()) {
2729 serviceImportParseLogic.throwComponentExceptionByResource(eitherGetResource.right().value(), service);
2731 return eitherGetResource.left().value();
2734 protected Service createServiceInstances(String yamlName, Service service, Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
2735 Map<String, Resource> nodeNamespaceMap) {
2736 Either<Resource, ResponseFormat> eitherResource = null;
2737 log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
2738 if (MapUtils.isEmpty(uploadResInstancesMap)) { // PNF can have no resource instances
2739 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
2740 throw new ComponentException(responseFormat);
2742 Map<String, Resource> existingNodeTypeMap = new HashMap<>();
2743 if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
2744 nodeNamespaceMap.forEach((k, v) -> existingNodeTypeMap.put(v.getToscaResourceName(), v));
2746 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
2747 uploadResInstancesMap.values()
2748 .forEach(i -> createAndAddResourceInstance(i, yamlName, service, nodeNamespaceMap, existingNodeTypeMap, resourcesInstancesMap));
2749 if (MapUtils.isNotEmpty(resourcesInstancesMap)) {
2751 toscaOperationFacade.associateComponentInstancesToComponent(service, resourcesInstancesMap, false, false);
2752 } catch (StorageException exp) {
2753 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
2754 log.debug("Failed to add component instances to container component {}", service.getName());
2755 ResponseFormat responseFormat = componentsUtils
2756 .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
2757 eitherResource = Either.right(responseFormat);
2758 throw new ComponentException(eitherResource.right().value());
2762 Either<Service, StorageOperationStatus> eitherGetResource = toscaOperationFacade
2763 .getToscaElement(service.getUniqueId(), serviceImportParseLogic.getComponentWithInstancesFilter());
2764 log.debug("*************finished to get resource {}", service.getUniqueId());
2765 if (eitherGetResource.isRight()) {
2766 ResponseFormat responseFormat = componentsUtils
2767 .getResponseFormatByComponent(componentsUtils.convertFromStorageResponse(eitherGetResource.right().value()), service,
2768 ComponentTypeEnum.SERVICE);
2769 throw new ComponentException(responseFormat);
2771 if (CollectionUtils.isEmpty(eitherGetResource.left().value().getComponentInstances())) { // PNF can have no resource instances
2772 log.debug("Error when create resource instance from csar. ComponentInstances list empty");
2773 BeEcompErrorManager.getInstance().logBeDaoSystemError("Error when create resource instance from csar. ComponentInstances list empty");
2774 throw new ComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
2776 return eitherGetResource.left().value();
2779 protected void createAndAddResourceInstance(UploadComponentInstanceInfo uploadComponentInstanceInfo, String yamlName, Component component,
2780 Map<String, Resource> nodeNamespaceMap, Map<String, Resource> existingnodeTypeMap,
2781 Map<ComponentInstance, Resource> resourcesInstancesMap) {
2782 log.debug("*************Going to create resource instances {}", uploadComponentInstanceInfo.getName());
2784 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
2785 uploadComponentInstanceInfo.setType(nodeNamespaceMap.get(uploadComponentInstanceInfo.getType()).getToscaResourceName());
2787 Resource refResource =
2788 validateResourceInstanceBeforeCreate(yamlName, component.getModel(), uploadComponentInstanceInfo, existingnodeTypeMap);
2789 ComponentInstance componentInstance = new ComponentInstance();
2790 componentInstance.setComponentUid(refResource.getUniqueId());
2791 Collection<String> directives = uploadComponentInstanceInfo.getDirectives();
2792 if (directives != null && !directives.isEmpty()) {
2793 componentInstance.setDirectives(new ArrayList<>(directives));
2795 UploadNodeFilterInfo uploadNodeFilterInfo = uploadComponentInstanceInfo.getUploadNodeFilterInfo();
2796 if (uploadNodeFilterInfo != null) {
2798 .setNodeFilter(new CINodeFilterUtils().getNodeFilterDataDefinition(uploadNodeFilterInfo, componentInstance.getUniqueId()));
2800 ComponentTypeEnum containerComponentType = component.getComponentType();
2801 NodeTypeEnum containerNodeType = containerComponentType.getNodeType();
2802 if (containerNodeType.equals(NodeTypeEnum.Resource) && MapUtils.isNotEmpty(uploadComponentInstanceInfo.getCapabilities()) && MapUtils
2803 .isNotEmpty(refResource.getCapabilities())) {
2804 serviceImportParseLogic.setCapabilityNamesTypes(refResource.getCapabilities(), uploadComponentInstanceInfo.getCapabilities());
2805 Map<String, List<CapabilityDefinition>> validComponentInstanceCapabilities = serviceImportParseLogic
2806 .getValidComponentInstanceCapabilities(refResource.getUniqueId(), refResource.getCapabilities(),
2807 uploadComponentInstanceInfo.getCapabilities());
2808 componentInstance.setCapabilities(validComponentInstanceCapabilities);
2810 if (!existingnodeTypeMap.containsKey(uploadComponentInstanceInfo.getType())) {
2811 ResponseFormat responseFormat = componentsUtils
2812 .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(),
2813 uploadComponentInstanceInfo.getType());
2814 throw new ComponentException(responseFormat);
2816 Resource origResource = existingnodeTypeMap.get(uploadComponentInstanceInfo.getType());
2817 componentInstance.setName(uploadComponentInstanceInfo.getName());
2818 componentInstance.setIcon(origResource.getIcon());
2819 componentInstance.setMinOccurrences(uploadComponentInstanceInfo.getMinOccurrences());
2820 componentInstance.setMaxOccurrences(uploadComponentInstanceInfo.getMaxOccurrences());
2821 componentInstance.setInstanceCount(uploadComponentInstanceInfo.getInstanceCount());
2822 resourcesInstancesMap.put(componentInstance, origResource);
2823 } catch (final ComponentException e) {
2825 } catch (final Exception e) {
2826 throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
2830 protected Resource validateResourceInstanceBeforeCreate(String yamlName, String model, UploadComponentInstanceInfo uploadComponentInstanceInfo,
2831 Map<String, Resource> nodeNamespaceMap) {
2832 Resource refResource;
2834 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
2835 refResource = nodeNamespaceMap.get(uploadComponentInstanceInfo.getType());
2837 final Either<Component, StorageOperationStatus> resourceEither =
2838 toscaOperationFacade.getLatestByToscaResourceName(uploadComponentInstanceInfo.getType(), model);
2839 if (resourceEither.isRight()) {
2840 ResponseFormat responseFormat = componentsUtils
2841 .getResponseFormat(componentsUtils.convertFromStorageResponse(resourceEither.right().value()));
2842 throw new ComponentException(responseFormat);
2844 refResource = (Resource) resourceEither.left().value();
2845 nodeNamespaceMap.put(refResource.getToscaResourceName(), refResource);
2847 String componentState = refResource.getComponentMetadataDefinition().getMetadataDataDefinition().getState();
2848 if (componentState.equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
2849 ResponseFormat responseFormat = componentsUtils
2850 .getResponseFormat(ActionStatus.ILLEGAL_COMPONENT_STATE, refResource.getComponentType().getValue(), refResource.getName(),
2852 throw new ComponentException(responseFormat);
2854 if (!ModelConverter.isAtomicComponent(refResource) && refResource.getResourceType() != ResourceTypeEnum.VF) {
2855 log.debug("validateResourceInstanceBeforeCreate - ref resource type is ", refResource.getResourceType());
2856 ResponseFormat responseFormat = componentsUtils
2857 .getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE, yamlName, uploadComponentInstanceInfo.getName(),
2858 uploadComponentInstanceInfo.getType());
2859 throw new ComponentException(responseFormat);
2862 } catch (final ComponentException e) {
2864 } catch (final Exception e) {
2865 throw new ComponentException(ActionStatus.GENERAL_ERROR, e.getMessage());
2869 protected void handleServiceNodeTypes(String yamlName, Service service, String topologyTemplateYaml, boolean needLock,
2870 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2871 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo,
2872 CsarInfo csarInfo, String nodeName) {
2874 for (Map.Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
2875 boolean isResourceNotExisted = validateResourceNotExisted(nodeTypeEntry.getKey());
2876 if (nodeTypeEntry.getValue().isNested() && isResourceNotExisted) {
2877 handleNestedVF(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
2878 nodeTypeEntry.getKey());
2879 log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
2882 Map<String, Object> mappedToscaTemplate = null;
2883 if (org.apache.commons.lang.StringUtils.isNotEmpty(nodeName) && MapUtils.isNotEmpty(nodeTypesInfo) && nodeTypesInfo
2884 .containsKey(nodeName)) {
2885 mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
2887 if (MapUtils.isEmpty(mappedToscaTemplate)) {
2888 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
2890 createResourcesFromYamlNodeTypesList(yamlName, service, mappedToscaTemplate, needLock, nodeTypesArtifactsToHandle,
2891 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
2892 } catch (ComponentException | StorageException e) {
2894 } catch (Exception e) {
2895 log.debug("Exception occured when handleServiceNodeTypes, error is:{}", e.getMessage(), e);
2896 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2900 protected boolean validateResourceNotExisted(String type) {
2902 Either<Resource, StorageOperationStatus> latestResource = toscaOperationFacade.getLatestResourceByToscaResourceName(type);
2903 return latestResource.isRight();
2904 } catch (Exception e) {
2905 log.debug("Exception occured when validateResourceNotExisted, error is:{}", e.getMessage(), e);
2906 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2910 protected Resource handleNestedVF(Service service,
2911 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2912 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
2915 String yamlName = nodesInfo.get(nodeName).getTemplateFileName();
2916 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName).getMappedToscaTemplate();
2917 createResourcesFromYamlNodeTypesList(yamlName, service, nestedVfcJsonMap, false, nodesArtifactsToHandle, createdArtifacts, nodesInfo,
2919 log.debug("************* Finished to create node types from yaml {}", yamlName);
2920 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
2921 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
2922 return handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName);
2924 return new Resource();
2925 } catch (Exception e) {
2926 log.debug("Exception occured when handleNestedVF, error is:{}", e.getMessage(), e);
2927 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2931 protected Resource handleComplexVfc(
2932 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2933 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName) {
2935 Resource oldComplexVfc = null;
2936 Resource newComplexVfc = serviceImportParseLogic.buildValidComplexVfc(csarInfo, nodeName, nodesInfo);
2937 Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
2938 .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
2939 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
2940 oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
2941 serviceImportParseLogic.buildNestedToscaResourceName(ResourceTypeEnum.VF.name(), csarInfo.getVfResourceName(), nodeName)
2944 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
2945 log.debug("Failed to fetch previous complex VFC by tosca resource name {}. Status is {}. ", newComplexVfc.getToscaResourceName(),
2946 oldComplexVfcRes.right().value());
2947 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2948 } else if (oldComplexVfcRes.isLeft()) {
2949 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
2950 Either<Boolean, ResponseFormat> eitherValidation = serviceImportParseLogic
2951 .validateNestedDerivedFromDuringUpdate(oldComplexVfcRes.left().value(), newComplexVfc,
2952 ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
2953 if (eitherValidation.isLeft()) {
2954 oldComplexVfc = oldComplexVfcRes.left().value();
2957 newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName, yamlName, oldComplexVfc,
2959 csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
2960 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
2961 LifecycleChangeInfoWithAction.LifecycleChanceActionEnum.CREATE_FROM_CSAR);
2962 log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
2963 final Resource result = serviceImportParseLogic
2964 .propagateStateToCertified(csarInfo.getModifier(), newComplexVfc, lifecycleChangeInfo, true, false, true);
2965 csarInfo.getCreatedNodes().put(nodeName, result);
2966 csarInfo.removeNodeFromQueue();
2968 } catch (Exception e) {
2969 log.debug("Exception occured when handleComplexVfc, error is:{}", e.getMessage(), e);
2970 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2974 protected Resource handleComplexVfc(
2975 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
2976 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo, String nodeName, String yamlName,
2977 Resource oldComplexVfc, Resource newComplexVfc) {
2978 Resource handleComplexVfcRes;
2980 Map<String, Object> mappedToscaTemplate = nodesInfo.get(nodeName).getMappedToscaTemplate();
2981 String yamlContent = new String(csarInfo.getCsar().get(yamlName));
2982 Map<String, NodeTypeInfo> newNodeTypesInfo = nodesInfo.entrySet().stream()
2983 .collect(toMap(Map.Entry::getKey, e -> e.getValue().getUnmarkedCopy()));
2984 CsarInfo.markNestedVfc(mappedToscaTemplate, newNodeTypesInfo);
2985 if (oldComplexVfc == null) {
2986 handleComplexVfcRes = createResourceFromYaml(newComplexVfc, yamlContent, yamlName, newNodeTypesInfo, csarInfo, nodesArtifactsToHandle,
2987 false, true, nodeName);
2989 handleComplexVfcRes = updateResourceFromYaml(oldComplexVfc, newComplexVfc, AuditingActionEnum.UPDATE_RESOURCE_METADATA,
2990 createdArtifacts, yamlContent, yamlName, csarInfo, newNodeTypesInfo, nodesArtifactsToHandle, nodeName, true);
2992 return handleComplexVfcRes;
2993 } catch (Exception e) {
2994 log.debug("Exception occured when handleComplexVfc, error is:{}", e.getMessage(), e);
2995 throw new ComponentException(ActionStatus.GENERAL_ERROR);
2999 protected Resource updateResourceFromYaml(Resource oldRresource, Resource newRresource, AuditingActionEnum actionEnum,
3000 List<ArtifactDefinition> createdArtifacts, String yamlFileName, String yamlFileContent,
3001 CsarInfo csarInfo, Map<String, NodeTypeInfo> nodeTypesInfo,
3002 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
3003 String nodeName, boolean isNested) {
3004 boolean inTransaction = true;
3005 boolean shouldLock = false;
3006 Resource preparedResource = null;
3007 ParsedToscaYamlInfo uploadComponentInstanceInfoMap = null;
3009 uploadComponentInstanceInfoMap = csarBusinessLogic
3010 .getParsedToscaYamlInfo(yamlFileContent, yamlFileName, nodeTypesInfo, csarInfo, nodeName, oldRresource);
3011 Map<String, UploadComponentInstanceInfo> instances = uploadComponentInstanceInfoMap.getInstances();
3012 if (MapUtils.isEmpty(instances) && newRresource.getResourceType() != ResourceTypeEnum.PNF) {
3013 throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlFileName);
3015 preparedResource = updateExistingResourceByImport(newRresource, oldRresource, csarInfo.getModifier(), inTransaction, shouldLock,
3017 log.trace("YAML topology file found in CSAR, file name: {}, contents: {}", yamlFileName, yamlFileContent);
3018 serviceImportParseLogic.handleResourceGenericType(preparedResource);
3019 handleNodeTypes(yamlFileName, preparedResource, yamlFileContent, shouldLock, nodeTypesArtifactsToHandle, createdArtifacts, nodeTypesInfo,
3020 csarInfo, nodeName);
3021 preparedResource = serviceImportParseLogic.createInputsOnResource(preparedResource, uploadComponentInstanceInfoMap.getInputs());
3022 preparedResource = createResourceInstances(yamlFileName, preparedResource, instances, csarInfo.getCreatedNodes());
3023 preparedResource = createResourceInstancesRelations(csarInfo.getModifier(), yamlFileName, preparedResource, instances);
3024 } catch (ComponentException e) {
3025 ResponseFormat responseFormat =
3026 e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
3027 log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat);
3029 .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum);
3031 } catch (StorageException e) {
3032 ResponseFormat responseFormat = componentsUtils
3033 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
3034 log.debug("#updateResourceFromYaml - failed to update resource from yaml {} .The error is {}", yamlFileName, responseFormat);
3036 .auditResource(responseFormat, csarInfo.getModifier(), preparedResource == null ? oldRresource : preparedResource, actionEnum);
3039 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic.validateUpdateVfGroupNames(
3040 uploadComponentInstanceInfoMap.getGroups(), preparedResource.getSystemName());
3041 if (validateUpdateVfGroupNamesRes.isRight()) {
3042 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
3044 Map<String, GroupDefinition> groups;
3045 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
3046 groups = validateUpdateVfGroupNamesRes.left().value();
3048 groups = uploadComponentInstanceInfoMap.getGroups();
3050 serviceImportParseLogic.handleGroupsProperties(preparedResource, groups);
3051 preparedResource = serviceImportParseLogic.updateGroupsOnResource(preparedResource, groups);
3052 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToHandle);
3053 Either<Resource, ResponseFormat> updateArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.UPDATE,
3054 createdArtifacts, yamlFileName, csarInfo, preparedResource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
3055 if (updateArtifactsEither.isRight()) {
3056 log.debug("failed to update artifacts {}", updateArtifactsEither.right().value());
3057 throw new ComponentException(updateArtifactsEither.right().value());
3059 preparedResource = serviceImportParseLogic.getResourceWithGroups(updateArtifactsEither.left().value().getUniqueId());
3060 ActionStatus mergingPropsAndInputsStatus = resourceDataMergeBusinessLogic.mergeResourceEntities(oldRresource, preparedResource);
3061 if (mergingPropsAndInputsStatus != ActionStatus.OK) {
3062 ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(mergingPropsAndInputsStatus, preparedResource);
3063 throw new ComponentException(responseFormat);
3065 compositionBusinessLogic.setPositionsForComponentInstances(preparedResource, csarInfo.getModifier().getUserId());
3066 return preparedResource;
3069 protected Resource createResourceFromYaml(Resource resource, String topologyTemplateYaml, String yamlName,
3070 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
3071 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
3072 boolean shouldLock, boolean inTransaction, String nodeName) {
3073 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
3074 Resource createdResource;
3076 ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic
3077 .getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName, resource);
3078 if (MapUtils.isEmpty(parsedToscaYamlInfo.getInstances()) && resource.getResourceType() != ResourceTypeEnum.PNF) {
3079 throw new ComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
3081 log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", resource.getName());
3082 createdResource = createResourceAndRIsFromYaml(yamlName, resource, parsedToscaYamlInfo, AuditingActionEnum.IMPORT_RESOURCE, false,
3083 createdArtifacts, topologyTemplateYaml, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName);
3084 log.debug("#createResourceFromYaml - The resource {} has been created ", resource.getName());
3085 } catch (ComponentException e) {
3086 ResponseFormat responseFormat =
3087 e.getResponseFormat() == null ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
3088 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
3090 } catch (StorageException e) {
3091 ResponseFormat responseFormat = componentsUtils
3092 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
3093 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, AuditingActionEnum.IMPORT_RESOURCE);
3096 return createdResource;
3099 protected Resource createResourceAndRIsFromYaml(String yamlName, Resource resource, ParsedToscaYamlInfo parsedToscaYamlInfo,
3100 AuditingActionEnum actionEnum, boolean isNormative, List<ArtifactDefinition> createdArtifacts,
3101 String topologyTemplateYaml, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
3102 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
3103 boolean shouldLock, boolean inTransaction, String nodeName) {
3104 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
3106 Either<Boolean, ResponseFormat> lockResult = serviceBusinessLogic
3107 .lockComponentByName(resource.getSystemName(), resource, CREATE_RESOURCE);
3108 if (lockResult.isRight()) {
3109 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
3110 throw new ComponentException(lockResult.right().value());
3112 log.debug("name is locked {} status = {}", resource.getSystemName(), lockResult);
3115 log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
3116 Resource genericResource = serviceBusinessLogic.fetchAndSetDerivedFromGenericType(resource);
3117 resource = createResourceTransaction(resource, csarInfo.getModifier(), isNormative);
3118 log.trace("************* Going to add inputs from yaml {}", yamlName);
3119 Map<String, Object> yamlMap = ImportUtils.loadYamlAsStrictMap(csarInfo.getMainTemplateContent());
3120 Map<String, Object> metadata = (Map<String, Object>) yamlMap.get("metadata");
3121 String type = (String) metadata.get("type");
3122 if (resource.shouldGenerateInputs() && !"Service".equalsIgnoreCase(type)) {
3123 serviceBusinessLogic.generateAndAddInputsFromGenericTypeProperties(resource, genericResource);
3125 Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
3126 resource = serviceImportParseLogic.createInputsOnResource(resource, inputs);
3127 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo.getInstances();
3128 resource = createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap, topologyTemplateYaml,
3129 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate, nodeName);
3130 log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName);
3131 // validate update vf module group names
3132 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic.validateUpdateVfGroupNames(
3133 parsedToscaYamlInfo.getGroups(), resource.getSystemName());
3134 if (validateUpdateVfGroupNamesRes.isRight()) {
3135 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
3136 throw new ComponentException(validateUpdateVfGroupNamesRes.right().value());
3138 Map<String, GroupDefinition> groups;
3139 log.trace("************* Going to add groups from yaml {}", yamlName);
3140 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
3141 groups = validateUpdateVfGroupNamesRes.left().value();
3143 groups = parsedToscaYamlInfo.getGroups();
3145 Either<Resource, ResponseFormat> createGroupsOnResource = createGroupsOnResource(resource, groups);
3146 if (createGroupsOnResource.isRight()) {
3147 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
3148 throw new ComponentException(createGroupsOnResource.right().value());
3150 resource = createGroupsOnResource.left().value();
3151 log.trace("************* Going to add artifacts from yaml {}", yamlName);
3152 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
3153 Either<Resource, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(ArtifactsBusinessLogic.ArtifactOperationEnum.CREATE,
3154 createdArtifacts, yamlName, csarInfo, resource, nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
3155 if (createArtifactsEither.isRight()) {
3156 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
3157 throw new ComponentException(createArtifactsEither.right().value());
3159 resource = serviceImportParseLogic.getResourceWithGroups(createArtifactsEither.left().value().getUniqueId());
3160 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.CREATED);
3161 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, actionEnum);
3162 ASDCKpiApi.countCreatedResourcesKPI();
3164 } catch (ComponentException | StorageException e) {
3165 serviceImportParseLogic.rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
3168 if (!inTransaction) {
3169 janusGraphDao.commit();
3172 graphLockOperation.unlockComponentByName(resource.getSystemName(), resource.getUniqueId(), NodeTypeEnum.Resource);
3177 protected Either<Resource, ResponseFormat> createGroupsOnResource(Resource resource, Map<String, GroupDefinition> groups) {
3178 if (groups != null && !groups.isEmpty()) {
3179 List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, resource);
3180 serviceImportParseLogic.handleGroupsProperties(resource, groups);
3181 serviceImportParseLogic.fillGroupsFinalFields(groupsAsList);
3182 Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic.createGroups(resource, groupsAsList, true);
3183 if (createGroups.isRight()) {
3184 return Either.right(createGroups.right().value());
3187 return Either.left(resource);
3189 Either<Resource, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(resource.getUniqueId());
3190 if (updatedResource.isRight()) {
3191 ResponseFormat responseFormat = componentsUtils
3192 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(updatedResource.right().value()), resource);
3193 return Either.right(responseFormat);
3195 return Either.left(updatedResource.left().value());
3198 protected List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups, Resource component) {
3199 List<GroupDefinition> result = new ArrayList<>();
3200 List<ComponentInstance> componentInstances = component.getComponentInstances();
3201 if (groups != null) {
3202 for (Map.Entry<String, GroupDefinition> entry : groups.entrySet()) {
3203 String groupName = entry.getKey();
3204 GroupDefinition groupDefinition = entry.getValue();
3205 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
3206 updatedGroupDefinition.setMembers(null);
3207 Map<String, String> members = groupDefinition.getMembers();
3208 if (members != null) {
3209 updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName, members);
3211 result.add(updatedGroupDefinition);
3217 protected void updateGroupMembers(Map<String, GroupDefinition> groups, GroupDefinition updatedGroupDefinition, Resource component,
3218 List<ComponentInstance> componentInstances, String groupName, Map<String, String> members) {
3219 Set<String> compInstancesNames = members.keySet();
3220 if (CollectionUtils.isEmpty(componentInstances)) {
3221 String membersAstString = compInstancesNames.stream().collect(joining(","));
3222 log.debug("The members: {}, in group: {}, cannot be found in component {}. There are no component instances.", membersAstString,
3223 groupName, component.getNormalizedName());
3224 throw new ComponentException(componentsUtils
3225 .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(),
3226 serviceImportParseLogic.getComponentTypeForResponse(component)));
3228 Map<String, String> memberNames = componentInstances.stream().collect(toMap(ComponentInstance::getName, ComponentInstance::getUniqueId));
3229 memberNames.putAll(groups.keySet().stream().collect(toMap(g -> g, g -> "")));
3230 Map<String, String> relevantInstances = memberNames.entrySet().stream().filter(n -> compInstancesNames.contains(n.getKey()))
3231 .collect(toMap(Map.Entry::getKey, Map.Entry::getValue));
3232 if (relevantInstances == null || relevantInstances.size() != compInstancesNames.size()) {
3233 List<String> foundMembers = new ArrayList<>();
3234 if (relevantInstances != null) {
3235 foundMembers = relevantInstances.keySet().stream().collect(toList());
3237 compInstancesNames.removeAll(foundMembers);
3238 String membersAstString = compInstancesNames.stream().collect(joining(","));
3239 throw new ComponentException(componentsUtils
3240 .getResponseFormat(ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString, groupName, component.getNormalizedName(),
3241 serviceImportParseLogic.getComponentTypeForResponse(component)));
3243 updatedGroupDefinition.setMembers(relevantInstances);
3246 protected Resource createResourceTransaction(Resource resource, User user, boolean isNormative) {
3247 Either<Boolean, StorageOperationStatus> eitherValidation = toscaOperationFacade
3248 .validateComponentNameExists(resource.getName(), resource.getResourceType(), resource.getComponentType());
3249 if (eitherValidation.isRight()) {
3250 ResponseFormat errorResponse = componentsUtils
3251 .getResponseFormat(componentsUtils.convertFromStorageResponse(eitherValidation.right().value()));
3252 throw new ComponentException(errorResponse);
3254 if (Boolean.TRUE.equals(eitherValidation.left().value())) {
3255 log.debug("resource with name: {}, already exists", resource.getName());
3256 ResponseFormat errorResponse = componentsUtils
3257 .getResponseFormat(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), resource.getName());
3258 throw new ComponentException(errorResponse);
3260 log.debug("send resource {} to dao for create", resource.getName());
3261 serviceImportParseLogic.createArtifactsPlaceHolderData(resource, user);
3263 log.debug("enrich resource with creator, version and state");
3264 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
3265 resource.setVersion(INITIAL_VERSION);
3266 resource.setHighestVersion(true);
3267 if (resource.getResourceType() != null && resource.getResourceType() != ResourceTypeEnum.VF) {
3268 resource.setAbstract(false);
3271 return toscaOperationFacade.createToscaComponent(resource).left()
3272 .on(r -> serviceImportParseLogic.throwComponentExceptionByResource(r, resource));
3275 protected ImmutablePair<Resource, ActionStatus> updateExistingResourceByImport(Resource newResource, Resource oldResource, User user,
3276 boolean inTransaction, boolean needLock, boolean isNested) {
3277 String lockedResourceId = oldResource.getUniqueId();
3278 log.debug("found resource: name={}, id={}, version={}, state={}", oldResource.getName(), lockedResourceId, oldResource.getVersion(),
3279 oldResource.getLifecycleState());
3280 ImmutablePair<Resource, ActionStatus> resourcePair = null;
3282 serviceBusinessLogic.lockComponent(lockedResourceId, oldResource, needLock, "Update Resource by Import");
3283 oldResource = serviceImportParseLogic.prepareResourceForUpdate(oldResource, newResource, user, inTransaction, false);
3284 serviceImportParseLogic.mergeOldResourceMetadataWithNew(oldResource, newResource);
3285 serviceImportParseLogic.validateResourceFieldsBeforeUpdate(oldResource, newResource, inTransaction, isNested);
3286 serviceImportParseLogic.validateCapabilityTypesCreate(user, serviceImportParseLogic.getCapabilityTypeOperation(), newResource,
3287 AuditingActionEnum.IMPORT_RESOURCE, inTransaction);
3288 createNewResourceToOldResource(newResource, oldResource, user);
3289 Either<Resource, StorageOperationStatus> overrideResource = toscaOperationFacade.overrideComponent(newResource, oldResource);
3290 if (overrideResource.isRight()) {
3291 ResponseFormat responseFormat = new ResponseFormat();
3292 serviceBusinessLogic.throwComponentException(responseFormat);
3294 log.debug("Resource updated successfully!!!");
3295 resourcePair = new ImmutablePair<>(overrideResource.left().value(), ActionStatus.OK);
3296 return resourcePair;
3298 if (resourcePair == null) {
3299 BeEcompErrorManager.getInstance().logBeSystemError("Change LifecycleState - Certify");
3300 janusGraphDao.rollback();
3301 } else if (!inTransaction) {
3302 janusGraphDao.commit();
3305 log.debug("unlock resource {}", lockedResourceId);
3306 graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource);
3311 protected void createNewResourceToOldResource(Resource newResource, Resource oldResource, User user) {
3312 newResource.setContactId(newResource.getContactId().toLowerCase());
3313 newResource.setCreatorUserId(user.getUserId());
3314 newResource.setCreatorFullName(user.getFullName());
3315 newResource.setLastUpdaterUserId(user.getUserId());
3316 newResource.setLastUpdaterFullName(user.getFullName());
3317 newResource.setUniqueId(oldResource.getUniqueId());
3318 newResource.setVersion(oldResource.getVersion());
3319 newResource.setInvariantUUID(oldResource.getInvariantUUID());
3320 newResource.setLifecycleState(oldResource.getLifecycleState());
3321 newResource.setUUID(oldResource.getUUID());
3322 newResource.setNormalizedName(oldResource.getNormalizedName());
3323 newResource.setSystemName(oldResource.getSystemName());
3324 if (oldResource.getCsarUUID() != null) {
3325 newResource.setCsarUUID(oldResource.getCsarUUID());
3327 if (oldResource.getCsarVersionId() != null) {
3328 newResource.setCsarVersionId(oldResource.getCsarVersionId());
3330 if (oldResource.getImportedToscaChecksum() != null) {
3331 newResource.setImportedToscaChecksum(oldResource.getImportedToscaChecksum());
3333 if (newResource.getDerivedFromGenericType() == null || newResource.getDerivedFromGenericType().isEmpty()) {
3334 newResource.setDerivedFromGenericType(oldResource.getDerivedFromGenericType());
3336 if (newResource.getDerivedFromGenericVersion() == null || newResource.getDerivedFromGenericVersion().isEmpty()) {
3337 newResource.setDerivedFromGenericVersion(oldResource.getDerivedFromGenericVersion());
3339 if (newResource.getToscaArtifacts() == null || newResource.getToscaArtifacts().isEmpty()) {
3340 serviceBusinessLogic.setToscaArtifactsPlaceHolders(newResource, user);
3342 if (newResource.getInterfaces() == null || newResource.getInterfaces().isEmpty()) {
3343 newResource.setInterfaces(oldResource.getInterfaces());
3345 if (CollectionUtils.isEmpty(newResource.getProperties())) {
3346 newResource.setProperties(oldResource.getProperties());
3348 if (newResource.getModel() == null) {
3349 newResource.setModel(oldResource.getModel());
3353 protected Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Service service, Map<String, Object> mappedToscaTemplate,
3355 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
3356 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
3357 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
3359 Either<String, ImportUtils.ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
3360 TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
3361 if (toscaVersion.isRight()) {
3362 throw new ComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
3364 Map<String, Object> mapToConvert = new HashMap<>();
3365 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left().value());
3366 Map<String, Object> nodeTypes = serviceImportParseLogic.getNodeTypesFromTemplate(mappedToscaTemplate);
3367 createNodeTypes(yamlName, service, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
3368 mapToConvert, nodeTypes);
3369 return csarInfo.getCreatedNodes();
3370 } catch (Exception e) {
3371 log.debug("Exception occured when createResourcesFromYamlNodeTypesList,error is:{}", e.getMessage(), e);
3372 throw new ComponentException(ActionStatus.GENERAL_ERROR);
3376 protected void createNodeTypes(String yamlName, Service service, boolean needLock,
3377 Map<String, EnumMap<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
3378 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
3379 Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
3380 Iterator<Map.Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet().iterator();
3381 Resource vfcCreated = null;
3382 while (nodesNameValueIter.hasNext()) {
3383 Map.Entry<String, Object> nodeType = nodesNameValueIter.next();
3384 String nodeTypeKey = nodeType.getKey();
3385 Map<ArtifactsBusinessLogic.ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle =
3386 nodeTypesArtifactsToHandle == null || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeTypeKey);
3387 if (nodeTypesInfo.containsKey(nodeTypeKey)) {
3388 vfcCreated = handleNestedVfc(service, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo,
3390 log.trace("************* Finished to handle nested vfc {}", nodeTypeKey);
3391 } else if (csarInfo.getCreatedNodesToscaResourceNames() != null && !csarInfo.getCreatedNodesToscaResourceNames()
3392 .containsKey(nodeTypeKey)) {
3393 ImmutablePair<Resource, ActionStatus> resourceCreated = serviceImportParseLogic
3394 .createNodeTypeResourceFromYaml(yamlName, nodeType, csarInfo.getModifier(), mapToConvert, service, needLock,
3395 nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, true, csarInfo, true);
3396 log.debug("************* Finished to create node {}", nodeTypeKey);
3397 vfcCreated = resourceCreated.getLeft();
3398 csarInfo.getCreatedNodesToscaResourceNames().put(nodeTypeKey, vfcCreated.getName());
3400 if (vfcCreated != null) {
3401 csarInfo.getCreatedNodes().put(nodeTypeKey, vfcCreated);
3403 mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());