2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
21 package org.openecomp.sdc.be.components.impl;
23 import static java.util.stream.Collectors.joining;
24 import static java.util.stream.Collectors.toList;
25 import static java.util.stream.Collectors.toMap;
26 import static java.util.stream.Collectors.toSet;
27 import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
28 import static org.apache.commons.collections.MapUtils.isEmpty;
29 import static org.apache.commons.collections.MapUtils.isNotEmpty;
30 import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaStringElement;
31 import static org.openecomp.sdc.be.components.impl.ImportUtils.getPropertyJsonStringValue;
32 import static org.openecomp.sdc.be.tosca.CsarUtils.VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN;
33 import static org.openecomp.sdc.common.api.Constants.DEFAULT_GROUP_VF_MODULE;
35 import com.google.common.annotations.VisibleForTesting;
36 import fj.data.Either;
37 import java.util.ArrayList;
38 import java.util.Collection;
39 import java.util.Collections;
40 import java.util.EnumMap;
41 import java.util.HashMap;
42 import java.util.HashSet;
43 import java.util.Iterator;
44 import java.util.List;
45 import java.util.ListIterator;
47 import java.util.Map.Entry;
48 import java.util.Optional;
50 import java.util.function.Function;
51 import java.util.regex.Pattern;
52 import java.util.stream.Collectors;
53 import javax.servlet.ServletContext;
54 import org.apache.commons.codec.binary.Base64;
55 import org.apache.commons.collections.CollectionUtils;
56 import org.apache.commons.collections.MapUtils;
57 import org.apache.commons.collections4.ListUtils;
58 import org.apache.commons.lang.StringUtils;
59 import org.apache.commons.lang3.tuple.ImmutablePair;
60 import org.openecomp.sdc.be.catalog.enums.ChangeTypeEnum;
61 import org.openecomp.sdc.be.components.csar.CsarArtifactsAndGroupsBusinessLogic;
62 import org.openecomp.sdc.be.components.csar.CsarBusinessLogic;
63 import org.openecomp.sdc.be.components.csar.CsarInfo;
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.ImportUtils.ResultStatusEnum;
67 import org.openecomp.sdc.be.components.impl.exceptions.BusinessLogicException;
68 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
69 import org.openecomp.sdc.be.components.impl.exceptions.ByResponseFormatComponentException;
70 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
71 import org.openecomp.sdc.be.components.impl.utils.CINodeFilterUtils;
72 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
73 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
74 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction.LifecycleChanceActionEnum;
75 import org.openecomp.sdc.be.components.merge.TopologyComparator;
76 import org.openecomp.sdc.be.components.merge.property.PropertyDataValueMergeBusinessLogic;
77 import org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic;
78 import org.openecomp.sdc.be.components.merge.utils.MergeInstanceUtils;
79 import org.openecomp.sdc.be.components.property.PropertyConstraintsUtils;
80 import org.openecomp.sdc.be.components.validation.component.ComponentContactIdValidator;
81 import org.openecomp.sdc.be.components.validation.component.ComponentDescriptionValidator;
82 import org.openecomp.sdc.be.components.validation.component.ComponentIconValidator;
83 import org.openecomp.sdc.be.components.validation.component.ComponentNameValidator;
84 import org.openecomp.sdc.be.components.validation.component.ComponentProjectCodeValidator;
85 import org.openecomp.sdc.be.components.validation.component.ComponentTagsValidator;
86 import org.openecomp.sdc.be.components.validation.component.ComponentValidator;
87 import org.openecomp.sdc.be.config.BeEcompErrorManager;
88 import org.openecomp.sdc.be.config.BeEcompErrorManager.ErrorSeverity;
89 import org.openecomp.sdc.be.config.ConfigurationManager;
90 import org.openecomp.sdc.be.dao.api.ActionStatus;
91 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
92 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
93 import org.openecomp.sdc.be.datamodel.api.HighestFilterEnum;
94 import org.openecomp.sdc.be.datamodel.utils.ArtifactUtils;
95 import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter;
96 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
97 import org.openecomp.sdc.be.datatypes.elements.AttributeDataDefinition;
98 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
99 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
100 import org.openecomp.sdc.be.datatypes.elements.GroupDataDefinition;
101 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
102 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
103 import org.openecomp.sdc.be.datatypes.elements.ToscaArtifactDataDefinition;
104 import org.openecomp.sdc.be.datatypes.enums.ComponentFieldsEnum;
105 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
106 import org.openecomp.sdc.be.datatypes.enums.CreatedFrom;
107 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
108 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
109 import org.openecomp.sdc.be.impl.ComponentsUtils;
110 import org.openecomp.sdc.be.impl.WebAppContextWrapper;
111 import org.openecomp.sdc.be.info.NodeTypeInfoToUpdateArtifacts;
112 import org.openecomp.sdc.be.model.ArtifactDefinition;
113 import org.openecomp.sdc.be.model.AttributeDefinition;
114 import org.openecomp.sdc.be.model.CapabilityDefinition;
115 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
116 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
117 import org.openecomp.sdc.be.model.Component;
118 import org.openecomp.sdc.be.model.ComponentInstance;
119 import org.openecomp.sdc.be.model.ComponentInstanceInput;
120 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
121 import org.openecomp.sdc.be.model.ComponentParametersView;
122 import org.openecomp.sdc.be.model.DataTypeDefinition;
123 import org.openecomp.sdc.be.model.GroupDefinition;
124 import org.openecomp.sdc.be.model.InputDefinition;
125 import org.openecomp.sdc.be.model.InterfaceDefinition;
126 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
127 import org.openecomp.sdc.be.model.LifecycleStateEnum;
128 import org.openecomp.sdc.be.model.NodeTypeInfo;
129 import org.openecomp.sdc.be.model.Operation;
130 import org.openecomp.sdc.be.model.ParsedToscaYamlInfo;
131 import org.openecomp.sdc.be.model.PolicyDefinition;
132 import org.openecomp.sdc.be.model.PropertyDefinition;
133 import org.openecomp.sdc.be.model.RelationshipImpl;
134 import org.openecomp.sdc.be.model.RelationshipInfo;
135 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
136 import org.openecomp.sdc.be.model.RequirementDefinition;
137 import org.openecomp.sdc.be.model.Resource;
138 import org.openecomp.sdc.be.model.UploadArtifactInfo;
139 import org.openecomp.sdc.be.model.UploadCapInfo;
140 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
141 import org.openecomp.sdc.be.model.UploadInfo;
142 import org.openecomp.sdc.be.model.UploadNodeFilterInfo;
143 import org.openecomp.sdc.be.model.UploadPropInfo;
144 import org.openecomp.sdc.be.model.UploadReqInfo;
145 import org.openecomp.sdc.be.model.UploadResourceInfo;
146 import org.openecomp.sdc.be.model.User;
147 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
148 import org.openecomp.sdc.be.model.category.CategoryDefinition;
149 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
150 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations;
151 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation;
152 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.ToscaOperationException;
153 import org.openecomp.sdc.be.model.jsonjanusgraph.utils.ModelConverter;
154 import org.openecomp.sdc.be.model.operations.StorageException;
155 import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation;
156 import org.openecomp.sdc.be.model.operations.api.IElementOperation;
157 import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation;
158 import org.openecomp.sdc.be.model.operations.api.IGroupOperation;
159 import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation;
160 import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation;
161 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
162 import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter;
163 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
164 import org.openecomp.sdc.be.model.operations.impl.UniqueIdBuilder;
165 import org.openecomp.sdc.be.model.operations.utils.ComponentValidationUtils;
166 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
167 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
168 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceVersionInfo;
169 import org.openecomp.sdc.be.tosca.CsarUtils;
170 import org.openecomp.sdc.be.tosca.CsarUtils.NonMetaArtifactInfo;
171 import org.openecomp.sdc.be.ui.model.UiComponentDataTransfer;
172 import org.openecomp.sdc.be.user.UserBusinessLogic;
173 import org.openecomp.sdc.be.utils.CommonBeUtils;
174 import org.openecomp.sdc.be.utils.TypeUtils;
175 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
176 import org.openecomp.sdc.common.api.ArtifactTypeEnum;
177 import org.openecomp.sdc.common.api.Constants;
178 import org.openecomp.sdc.common.datastructure.Wrapper;
179 import org.openecomp.sdc.common.kpi.api.ASDCKpiApi;
180 import org.openecomp.sdc.common.log.elements.LoggerSupportability;
181 import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
182 import org.openecomp.sdc.common.log.enums.LoggerSupportabilityActions;
183 import org.openecomp.sdc.common.log.enums.StatusCode;
184 import org.openecomp.sdc.common.log.wrappers.Logger;
185 import org.openecomp.sdc.common.util.GeneralUtility;
186 import org.openecomp.sdc.common.util.ValidationUtils;
187 import org.openecomp.sdc.exception.ResponseFormat;
188 import org.springframework.beans.factory.annotation.Autowired;
189 import org.springframework.context.annotation.Lazy;
190 import org.springframework.web.context.WebApplicationContext;
191 import org.yaml.snakeyaml.DumperOptions;
192 import org.yaml.snakeyaml.Yaml;
194 @org.springframework.stereotype.Component("resourceBusinessLogic")
195 public class ResourceBusinessLogic extends ComponentBusinessLogic {
197 private static final String DELETE_RESOURCE = "Delete Resource";
198 private static final String IN_RESOURCE = " in resource {} ";
199 private static final String PLACE_HOLDER_RESOURCE_TYPES = "validForResourceTypes";
200 public static final String INITIAL_VERSION = "0.1";
201 private static final Logger log = Logger.getLogger(ResourceBusinessLogic.class);
202 private static final String CERTIFICATION_ON_IMPORT = "certification on import";
203 private static final String CREATE_RESOURCE = "Create Resource";
204 private static final String VALIDATE_DERIVED_BEFORE_UPDATE = "validate derived before update";
205 private static final String CATEGORY_IS_EMPTY = "Resource category is empty";
206 private static final String CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES = "Create Resource - validateCapabilityTypesCreate";
207 private static final String COMPONENT_INSTANCE_WITH_NAME = "component instance with name ";
208 private static final String COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE = "component instance with name {} in resource {} ";
209 private static final LoggerSupportability loggerSupportability = LoggerSupportability.getLogger(ResourceBusinessLogic.class.getName());
212 private IInterfaceLifecycleOperation interfaceTypeOperation;
213 private LifecycleBusinessLogic lifecycleBusinessLogic;
215 private final ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
216 private final ResourceImportManager resourceImportManager;
217 private final InputsBusinessLogic inputsBusinessLogic;
218 private final CompositionBusinessLogic compositionBusinessLogic;
219 private final ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic;
220 private final CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic;
221 private final MergeInstanceUtils mergeInstanceUtils;
222 private final UiComponentDataConverter uiComponentDataConverter;
223 private final CsarBusinessLogic csarBusinessLogic;
224 private final PropertyBusinessLogic propertyBusinessLogic;
225 private final PolicyBusinessLogic policyBusinessLogic;
228 public ResourceBusinessLogic(IElementOperation elementDao,
229 IGroupOperation groupOperation,
230 IGroupInstanceOperation groupInstanceOperation,
231 IGroupTypeOperation groupTypeOperation,
232 GroupBusinessLogic groupBusinessLogic,
233 InterfaceOperation interfaceOperation,
234 InterfaceLifecycleOperation interfaceLifecycleTypeOperation,
235 ArtifactsBusinessLogic artifactsBusinessLogic,
236 ComponentInstanceBusinessLogic componentInstanceBusinessLogic, @Lazy ResourceImportManager resourceImportManager,
237 InputsBusinessLogic inputsBusinessLogic, CompositionBusinessLogic compositionBusinessLogic,
238 ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic,
239 CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic, MergeInstanceUtils mergeInstanceUtils,
240 UiComponentDataConverter uiComponentDataConverter, CsarBusinessLogic csarBusinessLogic,
241 ArtifactsOperations artifactToscaOperation, PropertyBusinessLogic propertyBusinessLogic,
242 ComponentContactIdValidator componentContactIdValidator,
243 ComponentNameValidator componentNameValidator, ComponentTagsValidator componentTagsValidator,
244 ComponentValidator componentValidator,
245 ComponentIconValidator componentIconValidator,
246 ComponentProjectCodeValidator componentProjectCodeValidator,
247 ComponentDescriptionValidator componentDescriptionValidator, PolicyBusinessLogic policyBusinessLogic) {
248 super(elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, groupBusinessLogic,
249 interfaceOperation, interfaceLifecycleTypeOperation, artifactsBusinessLogic, artifactToscaOperation,
250 componentContactIdValidator, componentNameValidator, componentTagsValidator, componentValidator,
251 componentIconValidator, componentProjectCodeValidator, componentDescriptionValidator);
252 this.componentInstanceBusinessLogic = componentInstanceBusinessLogic;
253 this.resourceImportManager = resourceImportManager;
254 this.inputsBusinessLogic = inputsBusinessLogic;
255 this.compositionBusinessLogic = compositionBusinessLogic;
256 this.resourceDataMergeBusinessLogic = resourceDataMergeBusinessLogic;
257 this.csarArtifactsAndGroupsBusinessLogic = csarArtifactsAndGroupsBusinessLogic;
258 this.mergeInstanceUtils = mergeInstanceUtils;
259 this.uiComponentDataConverter = uiComponentDataConverter;
260 this.csarBusinessLogic = csarBusinessLogic;
261 this.propertyBusinessLogic = propertyBusinessLogic;
262 this.policyBusinessLogic = policyBusinessLogic;
266 private ICapabilityTypeOperation capabilityTypeOperation;
269 private TopologyComparator topologyComparator;
272 private ComponentValidator componentValidator;
275 private PropertyDataValueMergeBusinessLogic propertyDataValueMergeBusinessLogic;
278 private SoftwareInformationBusinessLogic softwareInformationBusinessLogic;
280 public LifecycleBusinessLogic getLifecycleBusinessLogic() {
281 return lifecycleBusinessLogic;
285 public void setLifecycleManager(LifecycleBusinessLogic lifecycleBusinessLogic) {
286 this.lifecycleBusinessLogic = lifecycleBusinessLogic;
290 protected void setComponentValidator(ComponentValidator componentValidator) {
291 this.componentValidator = componentValidator;
294 public IElementOperation getElementDao() {
298 public void setElementDao(IElementOperation elementDao) {
299 this.elementDao = elementDao;
302 public UserBusinessLogic getUserAdmin() {
303 return this.userAdmin;
307 public void setUserAdmin(UserBusinessLogic userAdmin) {
308 this.userAdmin = userAdmin;
311 public ComponentsUtils getComponentsUtils() {
312 return this.componentsUtils;
316 public void setComponentsUtils(ComponentsUtils componentsUtils) {
317 this.componentsUtils = componentsUtils;
320 public ArtifactsBusinessLogic getArtifactsManager() {
321 return artifactsBusinessLogic;
324 public void setArtifactsManager(ArtifactsBusinessLogic artifactsManager) {
325 this.artifactsBusinessLogic = artifactsManager;
328 public ApplicationDataTypeCache getApplicationDataTypeCache() {
329 return applicationDataTypeCache;
333 public void setApplicationDataTypeCache(ApplicationDataTypeCache applicationDataTypeCache) {
334 this.applicationDataTypeCache = applicationDataTypeCache;
338 public void setInterfaceTypeOperation(IInterfaceLifecycleOperation interfaceTypeOperation) {
339 this.interfaceTypeOperation = interfaceTypeOperation;
343 * the method returns a list of all the resources that are certified, the
344 * returned resources are only abstract or only none abstract according to
352 public List<Resource> getAllCertifiedResources(boolean getAbstract, HighestFilterEnum highestFilter,
354 User user = validateUserExists(userId);
355 Boolean isHighest = null;
356 switch (highestFilter) {
362 case NON_HIGHEST_ONLY:
368 Either<List<Resource>, StorageOperationStatus> getResponse = toscaOperationFacade
369 .getAllCertifiedResources(getAbstract, isHighest);
371 if (getResponse.isRight()) {
372 throw new StorageException(getResponse.right()
376 return getResponse.left()
380 public Either<Map<String, Boolean>, ResponseFormat> validateResourceNameExists(String resourceName,
381 ResourceTypeEnum resourceTypeEnum, String userId) {
383 validateUserExists(userId);
385 Either<Boolean, StorageOperationStatus> dataModelResponse = toscaOperationFacade
386 .validateComponentNameUniqueness(resourceName, resourceTypeEnum, ComponentTypeEnum.RESOURCE);
388 janusGraphDao.commit();
390 if (dataModelResponse.isLeft()) {
391 Map<String, Boolean> result = new HashMap<>();
392 result.put("isValid", dataModelResponse.left()
394 log.debug("validation was successfully performed.");
395 return Either.left(result);
398 ResponseFormat responseFormat = componentsUtils
399 .getResponseFormat(componentsUtils.convertFromStorageResponse(dataModelResponse.right()
402 return Either.right(responseFormat);
405 public Resource createResource(Resource resource, AuditingActionEnum auditingAction, User user,
406 Map<String, byte[]> csarUIPayload, String payloadName) {
407 validateResourceBeforeCreate(resource, user, false);
408 String csarUUID = payloadName == null ? resource.getCsarUUID() : payloadName;
409 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE,resource.getComponentMetadataForSupportLog(), StatusCode.STARTED,"Starting to create resource from CSAR by user {} ", user.getUserId());
410 if (StringUtils.isNotEmpty(csarUUID)) {
411 csarBusinessLogic.validateCsarBeforeCreate(resource, auditingAction, user, csarUUID);
412 log.debug("CsarUUID is {} - going to create resource from CSAR", csarUUID);
414 Resource createResourceFromCsar = createResourceFromCsar(resource, user, csarUIPayload, csarUUID);
415 return updateCatalog(createResourceFromCsar, ChangeTypeEnum.LIFECYCLE).left()
416 .map(r -> (Resource) r)
421 final Resource createResourceByDao = createResourceByDao(resource, user, auditingAction, false, false);
422 return updateCatalog(createResourceByDao, ChangeTypeEnum.LIFECYCLE).left()
423 .map(r -> (Resource) r)
428 public Resource validateAndUpdateResourceFromCsar(Resource resource, User user, Map<String, byte[]> csarUIPayload,
429 String payloadName, String resourceUniqueId) {
430 String csarUUID = payloadName;
431 String csarVersion = null;
432 Resource updatedResource = null;
433 if (payloadName == null) {
434 csarUUID = resource.getCsarUUID();
435 csarVersion = resource.getCsarVersion();
437 if (csarUUID != null && !csarUUID.isEmpty()) {
438 Resource oldResource = getResourceByUniqueId(resourceUniqueId);
439 validateCsarUuidMatching(oldResource, resource, csarUUID, resourceUniqueId, user);
440 validateCsarIsNotAlreadyUsed(oldResource, resource, csarUUID, user);
441 if (oldResource != null && ValidationUtils.hasBeenCertified(oldResource.getVersion())) {
442 overrideImmutableMetadata(oldResource, resource);
444 validateResourceBeforeCreate(resource, user, false);
445 String oldCsarVersion = oldResource != null ? oldResource.getCsarVersion() : null;
446 log.debug("CsarUUID is {} - going to update resource with UniqueId {} from CSAR", csarUUID,
448 // (on boarding flow): If the update includes same csarUUID and
449 // same csarVersion as already in the VF - no need to import the
450 // csar (do only metadata changes if there are).
451 if (csarVersion != null && oldCsarVersion != null && oldCsarVersion.equals(csarVersion)) {
452 updatedResource = updateResourceMetadata(resourceUniqueId, resource, oldResource, user, false);
454 updatedResource = updateResourceFromCsar(oldResource, resource, user,
455 AuditingActionEnum.UPDATE_RESOURCE_METADATA, false, csarUIPayload, csarUUID);
458 log.debug("Failed to update resource {}, csarUUID or payload name is missing", resource.getSystemName());
459 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_CSAR_UUID,
461 componentsUtils.auditResource(errorResponse, user, resource, AuditingActionEnum.CREATE_RESOURCE);
462 throw new ByActionStatusComponentException(ActionStatus.MISSING_CSAR_UUID, resource.getName());
464 return updatedResource;
467 private void validateCsarIsNotAlreadyUsed(Resource oldResource, Resource resource, String csarUUID, User user) {
468 // (on boarding flow): If the update includes a csarUUID: verify this
469 // csarUUID is not in use by another VF, If it is - use same error as
471 // "Error: The VSP with UUID %1 was already imported for VF %2. Please
472 // select another or update the existing VF." %1 - csarUUID, %2 - VF
474 Either<Resource, StorageOperationStatus> resourceLinkedToCsarRes = toscaOperationFacade
475 .getLatestComponentByCsarOrName(ComponentTypeEnum.RESOURCE, csarUUID, resource.getSystemName());
476 if (resourceLinkedToCsarRes.isRight()) {
477 if (StorageOperationStatus.NOT_FOUND != resourceLinkedToCsarRes.right().value()) {
478 log.debug("Failed to find previous resource by CSAR {} and system name {}", csarUUID,
479 resource.getSystemName());
480 throw new StorageException(resourceLinkedToCsarRes.right()
483 } else if (!resourceLinkedToCsarRes.left()
486 .equals(oldResource.getUniqueId())
487 && !resourceLinkedToCsarRes.left()
490 .equals(oldResource.getName())) {
491 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.VSP_ALREADY_EXISTS, csarUUID,
492 resourceLinkedToCsarRes.left()
495 componentsUtils.auditResource(errorResponse, user, resource, AuditingActionEnum.UPDATE_RESOURCE_METADATA);
496 throw new ByActionStatusComponentException(ActionStatus.VSP_ALREADY_EXISTS, csarUUID, resourceLinkedToCsarRes.left()
502 private void validateCsarUuidMatching(Resource resource, Resource oldResource, String csarUUID,
503 String resourceUniqueId, User user) {
504 // (on boarding flow): If the update includes csarUUID which is
505 // different from the csarUUID of the VF - fail with
506 // error: "Error: Resource %1 cannot be updated using since it is linked
507 // to a different VSP" %1 - VF name
508 String oldCsarUUID = oldResource.getCsarUUID();
509 if (oldCsarUUID != null && !oldCsarUUID.isEmpty() && !csarUUID.equals(oldCsarUUID)) {
511 "Failed to update resource with UniqueId {} using Csar {}, since the resource is linked to a different VSP {}",
512 resourceUniqueId, csarUUID, oldCsarUUID);
513 ResponseFormat errorResponse = componentsUtils.getResponseFormat(
514 ActionStatus.RESOURCE_LINKED_TO_DIFFERENT_VSP, resource.getName(), csarUUID, oldCsarUUID);
515 componentsUtils.auditResource(errorResponse, user, resource, AuditingActionEnum.UPDATE_RESOURCE_METADATA);
516 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_LINKED_TO_DIFFERENT_VSP, resource.getName(), csarUUID,
521 private Resource getResourceByUniqueId(String resourceUniqueId) {
522 Either<Resource, StorageOperationStatus> oldResourceRes = toscaOperationFacade
523 .getToscaFullElement(resourceUniqueId);
524 if (oldResourceRes.isRight()) {
525 log.debug("Failed to find previous resource by UniqueId {}, status: {}", resourceUniqueId,
526 oldResourceRes.right()
528 throw new StorageException(oldResourceRes.right()
531 return oldResourceRes.left()
535 private void overrideImmutableMetadata(Resource oldResource, Resource resource) {
536 resource.setName(oldResource.getName());
537 resource.setIcon(oldResource.getIcon());
538 resource.setTags(oldResource.getTags());
539 resource.setCategories(oldResource.getCategories());
540 resource.setDerivedFrom(oldResource.getDerivedFrom());
543 private Resource updateResourceFromCsar(Resource oldResource, Resource newResource, User user,
544 AuditingActionEnum updateResource, boolean inTransaction, Map<String, byte[]> csarUIPayload,
546 Resource updatedResource = null;
547 validateLifecycleState(oldResource, user);
548 String lockedResourceId = oldResource.getUniqueId();
549 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
550 CsarInfo csarInfo = csarBusinessLogic.getCsarInfo(newResource, oldResource, user, csarUIPayload, csarUUID);
551 lockComponent(lockedResourceId, oldResource, "update Resource From Csar");
553 Map<String, NodeTypeInfo> nodeTypesInfo = csarInfo.extractNodeTypesInfo();
555 Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandleRes = findNodeTypesArtifactsToHandle(
556 nodeTypesInfo, csarInfo, oldResource);
557 if (findNodeTypesArtifactsToHandleRes.isRight()) {
558 log.debug("failed to find node types for update with artifacts during import csar {}. ",
559 csarInfo.getCsarUUID());
560 throw new ByResponseFormatComponentException(findNodeTypesArtifactsToHandleRes.right()
563 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = findNodeTypesArtifactsToHandleRes
567 updatedResource = updateResourceFromYaml(oldResource, newResource, updateResource, createdArtifacts,
568 csarInfo.getMainTemplateName(), csarInfo.getMainTemplateContent(), csarInfo, nodeTypesInfo,
569 nodeTypesArtifactsToHandle, null, false);
571 } catch (ComponentException | StorageException e) {
572 rollback(inTransaction, newResource, createdArtifacts, null);
576 janusGraphDao.commit();
577 log.debug("unlock resource {}", lockedResourceId);
578 graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource);
580 return updatedResource;
584 private void validateLifecycleState(Resource oldResource, User user) {
585 if (LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT == oldResource.getLifecycleState()
586 && !oldResource.getLastUpdaterUserId()
587 .equals(user.getUserId())) {
589 "#validateLifecycleState - Current user is not last updater, last updater userId: {}, current user userId: {}",
590 oldResource.getLastUpdaterUserId(), user.getUserId());
591 throw new ByActionStatusComponentException(ActionStatus.RESTRICTED_OPERATION);
595 private Resource updateResourceFromYaml(Resource oldResource, Resource newResource, AuditingActionEnum actionEnum,
596 List<ArtifactDefinition> createdArtifacts, String yamlFileName, String yamlFileContent, CsarInfo csarInfo,
597 Map<String, NodeTypeInfo> nodeTypesInfo,
598 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
599 String nodeName, boolean isNested) {
600 boolean inTransaction = true;
601 boolean shouldLock = false;
602 Resource preparedResource = null;
603 ParsedToscaYamlInfo uploadComponentInstanceInfoMap;
605 uploadComponentInstanceInfoMap = csarBusinessLogic.getParsedToscaYamlInfo(yamlFileContent, yamlFileName,
606 nodeTypesInfo, csarInfo, nodeName);
607 Map<String, UploadComponentInstanceInfo> instances = uploadComponentInstanceInfoMap.getInstances();
608 if (MapUtils.isEmpty(instances) && newResource.getResourceType() != ResourceTypeEnum.PNF) {
609 throw new ByActionStatusComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlFileName);
611 preparedResource = updateExistingResourceByImport(newResource, oldResource, csarInfo.getModifier(),
612 inTransaction, shouldLock, isNested).left;
613 log.trace("YAML topology file found in CSAR, file name: {}, contents: {}", yamlFileName, yamlFileContent);
614 handleResourceGenericType(preparedResource);
615 handleNodeTypes(yamlFileName, preparedResource, yamlFileContent, shouldLock, nodeTypesArtifactsToHandle,
616 createdArtifacts, nodeTypesInfo, csarInfo, nodeName);
617 preparedResource = createInputsOnResource(preparedResource, uploadComponentInstanceInfoMap.getInputs());
618 Map<String, Resource> existingNodeTypesByResourceNames = new HashMap<>();
619 preparedResource = createResourceInstances(yamlFileName, preparedResource, oldResource, instances, csarInfo.getCreatedNodes(), existingNodeTypesByResourceNames);
620 preparedResource = createResourceInstancesRelations(csarInfo.getModifier(), yamlFileName, preparedResource, oldResource, instances, existingNodeTypesByResourceNames);
621 } catch (ComponentException e) {
622 ResponseFormat responseFormat = e.getResponseFormat() == null
623 ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
624 log.debug("#updateResourceFromYaml - failed to update newResource from yaml {} .The error is {}", yamlFileName,
626 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(),
627 preparedResource == null ? oldResource : preparedResource, actionEnum);
629 } catch (StorageException e) {
630 ResponseFormat responseFormat = componentsUtils
631 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
632 log.debug("#updateResourceFromYaml - failed to update newResource from yaml {} .The error is {}", yamlFileName,
634 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(),
635 preparedResource == null ? oldResource : preparedResource, actionEnum);
638 Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic
639 .validateUpdateVfGroupNames(uploadComponentInstanceInfoMap.getGroups(),
640 preparedResource.getSystemName());
641 if (validateUpdateVfGroupNamesRes.isRight()) {
643 throw new ByResponseFormatComponentException(validateUpdateVfGroupNamesRes.right()
646 // add groups to newResource
647 Map<String, GroupDefinition> groups;
649 if (!validateUpdateVfGroupNamesRes.left()
652 groups = validateUpdateVfGroupNamesRes.left()
655 groups = uploadComponentInstanceInfoMap.getGroups();
657 handleGroupsProperties(preparedResource, groups);
658 Either<Boolean, ActionStatus> isTopologyChanged = topologyComparator.isTopologyChanged(oldResource, preparedResource);
660 preparedResource = updateGroupsOnResource(preparedResource, groups);
662 NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts = new NodeTypeInfoToUpdateArtifacts(nodeName,
663 nodeTypesArtifactsToHandle);
665 Either<Resource, ResponseFormat> updateArtifactsEither = createOrUpdateArtifacts(ArtifactOperationEnum.UPDATE,
666 createdArtifacts, yamlFileName, csarInfo, preparedResource, nodeTypeInfoToUpdateArtifacts,
667 inTransaction, shouldLock);
668 if (updateArtifactsEither.isRight()) {
669 log.debug("failed to update artifacts {}", updateArtifactsEither.right()
671 throw new ByResponseFormatComponentException(updateArtifactsEither.right()
674 preparedResource = getResourceWithGroups(updateArtifactsEither.left()
678 updateGroupsName(oldResource, preparedResource, isTopologyChanged.left().value());
679 updateResourceInstancesNames(oldResource, csarInfo, preparedResource, isTopologyChanged.left().value());
681 final String preparedResourceId = preparedResource != null ? preparedResource.getUniqueId() : "";
682 preparedResource = getResourceWithGroups(preparedResourceId);
684 updateVolumeGroup(preparedResource);
686 ActionStatus mergingPropsAndInputsStatus = resourceDataMergeBusinessLogic.mergeResourceEntities(oldResource, preparedResource);
687 if (mergingPropsAndInputsStatus != ActionStatus.OK) {
688 ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(mergingPropsAndInputsStatus,
690 throw new ByResponseFormatComponentException(responseFormat);
692 compositionBusinessLogic.setPositionsForComponentInstances(preparedResource, csarInfo.getModifier()
694 return preparedResource;
697 protected void updateVolumeGroup(Resource preparedResource) {
698 List<GroupDefinition> groups = preparedResource.safeGetGroups();
699 for (GroupDefinition group : groups) {
700 Map<String, ArtifactDefinition> createdNewArtifacts = preparedResource.getDeploymentArtifacts();
701 if (DEFAULT_GROUP_VF_MODULE.equals(group.getType())) {
702 List<PropertyDataDefinition> volumePropList = group.getProperties().stream().filter(p -> "volume_group".equals(p.getName())).collect(Collectors.toList());
703 if (!volumePropList.isEmpty()) {
704 PropertyDataDefinition volumeProp = volumePropList.get(0);
705 if (volumeProp != null) {
706 boolean isVolumeGroup = isVolumeGroup(group.getArtifacts(), new ArrayList<>(createdNewArtifacts.values()));
708 if (!volumePropList.get(0).getValue().equals(String.valueOf(isVolumeGroup))) {
709 volumeProp.setValue(String.valueOf(isVolumeGroup));
710 volumeProp.setDefaultValue(String.valueOf(isVolumeGroup));
718 private void updateGroupsName(Resource oldResource, Resource preparedResource, boolean isTopologyChanged) {
719 if (oldResource == null || preparedResource == null) {
720 log.debug("Failed to update groups name : oldResource or preparedResource is null");
721 } else if (CollectionUtils.isNotEmpty(oldResource.getGroups())
722 && CollectionUtils.isNotEmpty(preparedResource.getGroups())) {
723 Map<String, String> oldGroups = oldResource.getGroups()
725 .collect(toMap(GroupDataDefinition::getInvariantName, GroupDataDefinition::getName));
727 List<GroupDefinition> updatedGroups = preparedResource.getGroups()
729 .filter(group -> oldGroups.containsKey(group.getInvariantName()) && !group.getName()
730 .equals(oldGroups.get(group.getInvariantName())))
733 if (CollectionUtils.isNotEmpty(updatedGroups)) {
734 if (isTopologyChanged) {
735 updatedGroups.stream().filter(group -> !group.isVspOriginated())
736 .forEach(group -> group.setName(oldGroups.get(group.getInvariantName())));
738 updatedGroups.forEach(group -> group.setName(oldGroups.get(group.getInvariantName())));
740 groupBusinessLogic.updateGroups(preparedResource, updatedGroups, false);
745 private void updateResourceInstancesNames(Resource oldResource, CsarInfo csarInfo, Resource preparedResource,
746 boolean isTopologyChanged) {
747 if (oldResource == null || preparedResource == null) {
748 log.debug("Failed to update resource instances names : oldResource or preparedResource is null");
750 if (CollectionUtils.isNotEmpty(oldResource.getComponentInstances())) {
751 Map<String, String> oldInstances = oldResource.getComponentInstances()
753 .collect(toMap(ComponentInstance::getInvariantName, ComponentInstance::getName));
754 List<ComponentInstance> updatedInstances = preparedResource.getComponentInstances()
756 .filter(i -> oldInstances.containsKey(i.getInvariantName()) && !i.getName()
757 .equals(oldInstances.get(i.getInvariantName())))
759 if (CollectionUtils.isNotEmpty(updatedInstances)) {
760 if (isTopologyChanged) {
761 updatedInstances.stream().filter(i -> !i.isCreatedFromCsar())
762 .forEach(i -> i.setName(oldInstances.get(i.getInvariantName())));
764 updatedInstances.forEach(i -> i.setName(oldInstances.get(i.getInvariantName())));
769 componentInstanceBusinessLogic.updateComponentInstance(ComponentTypeEnum.RESOURCE_PARAM_NAME,
770 null, preparedResource.getUniqueId(), csarInfo.getModifier()
772 preparedResource.getComponentInstances(), false);
776 private Either<Resource, ResponseFormat> createOrUpdateArtifacts(ArtifactOperationEnum operation,
777 List<ArtifactDefinition> createdArtifacts, String yamlFileName, CsarInfo csarInfo,
778 Resource preparedResource, NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts,
779 boolean inTransaction, boolean shouldLock) {
781 String nodeName = nodeTypeInfoToUpdateArtifacts.getNodeName();
782 Resource resource = preparedResource;
784 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = nodeTypeInfoToUpdateArtifacts
785 .getNodeTypesArtifactsToHandle();
786 if (preparedResource.getResourceType() == ResourceTypeEnum.CVFC) {
787 if (nodeName != null && nodeTypesArtifactsToHandle.get(nodeName) != null
788 && !nodeTypesArtifactsToHandle.get(nodeName)
790 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = handleNodeTypeArtifacts(
791 preparedResource, nodeTypesArtifactsToHandle.get(nodeName), createdArtifacts,
792 csarInfo.getModifier(), inTransaction, true);
793 if (handleNodeTypeArtifactsRes.isRight()) {
794 return Either.right(handleNodeTypeArtifactsRes.right()
799 Either<Resource, ResponseFormat> createdCsarArtifactsEither = handleVfCsarArtifacts(preparedResource,
800 csarInfo, createdArtifacts,
801 new ArtifactOperationInfo(false, false, operation), shouldLock,
803 log.trace("************* Finished to add artifacts from yaml {}", yamlFileName);
804 if (createdCsarArtifactsEither.isRight()) {
805 return createdCsarArtifactsEither;
808 resource = createdCsarArtifactsEither.left()
811 return Either.left(resource);
814 private Resource handleResourceGenericType(Resource resource) {
815 Resource genericResource = fetchAndSetDerivedFromGenericType(resource);
816 if (resource.shouldGenerateInputs()) {
817 generateAndAddInputsFromGenericTypeProperties(resource, genericResource);
819 return genericResource;
822 private Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandle(
823 final Map<String, NodeTypeInfo> nodeTypesInfo, final CsarInfo csarInfo, final Resource oldResource) {
825 final Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = new HashMap<>();
826 Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat>
827 nodeTypesArtifactsToHandleRes = Either.left(nodeTypesArtifactsToHandle);
830 final Map<String, List<ArtifactDefinition>> extractedVfcsArtifacts = CsarUtils
831 .extractVfcsArtifactsFromCsar(csarInfo.getCsar());
832 final Map<String, ImmutablePair<String, String>> extractedVfcToscaNames = extractVfcToscaNames(
833 nodeTypesInfo, oldResource.getName(), csarInfo);
834 log.debug("Going to fetch node types for resource with name {} during import csar with UUID {}. ",
835 oldResource.getName(), csarInfo.getCsarUUID());
836 extractedVfcToscaNames.forEach((namespace, vfcToscaNames) -> findAddNodeTypeArtifactsToHandle(csarInfo,
837 nodeTypesArtifactsToHandle, oldResource, extractedVfcsArtifacts, namespace, vfcToscaNames));
838 } catch (Exception e) {
839 final ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
840 nodeTypesArtifactsToHandleRes = Either.right(responseFormat);
841 log.debug("Exception occurred when findNodeTypesUpdatedArtifacts, error is:{}", e.getMessage(), e);
843 return nodeTypesArtifactsToHandleRes;
846 private void findAddNodeTypeArtifactsToHandle(CsarInfo csarInfo,
847 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
848 Resource resource, Map<String, List<ArtifactDefinition>> extractedVfcsArtifacts, String namespace,
849 ImmutablePair<String, String> vfcToscaNames) {
851 EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>> curNodeTypeArtifactsToHandle = null;
852 log.debug("Going to fetch node type with tosca name {}. ", vfcToscaNames.getLeft());
853 Resource curNodeType = findVfcResource(csarInfo, resource, vfcToscaNames.getLeft(), vfcToscaNames.getRight(),
855 if (!isEmpty(extractedVfcsArtifacts)) {
856 List<ArtifactDefinition> currArtifacts = new ArrayList<>();
857 if (extractedVfcsArtifacts.containsKey(namespace)) {
858 handleAndAddExtractedVfcsArtifacts(currArtifacts, extractedVfcsArtifacts.get(namespace));
860 curNodeTypeArtifactsToHandle = findNodeTypeArtifactsToHandle(curNodeType, currArtifacts);
861 } else if (curNodeType != null) {
862 // delete all artifacts if have not received artifacts from
864 curNodeTypeArtifactsToHandle = new EnumMap<>(ArtifactOperationEnum.class);
865 List<ArtifactDefinition> artifactsToDelete = new ArrayList<>();
866 // delete all informational artifacts
867 artifactsToDelete.addAll(curNodeType.getArtifacts()
870 .filter(a -> a.getArtifactGroupType() == ArtifactGroupTypeEnum.INFORMATIONAL)
872 // delete all deployment artifacts
873 artifactsToDelete.addAll(curNodeType.getDeploymentArtifacts()
875 if (!artifactsToDelete.isEmpty()) {
876 curNodeTypeArtifactsToHandle.put(ArtifactOperationEnum.DELETE, artifactsToDelete);
879 if (isNotEmpty(curNodeTypeArtifactsToHandle)) {
880 nodeTypesArtifactsToHandle.put(namespace, curNodeTypeArtifactsToHandle);
884 private Resource findVfcResource(CsarInfo csarInfo, Resource resource, String currVfcToscaName,
885 String previousVfcToscaName, StorageOperationStatus status) {
886 if (status != null && status != StorageOperationStatus.NOT_FOUND) {
887 log.debug("Error occurred during fetching node type with tosca name {}, error: {}", currVfcToscaName,
889 ResponseFormat responseFormat = componentsUtils
890 .getResponseFormat(componentsUtils.convertFromStorageResponse(status), csarInfo.getCsarUUID());
891 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource,
892 AuditingActionEnum.CREATE_RESOURCE);
893 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(status), csarInfo.getCsarUUID());
894 } else if (StringUtils.isNotEmpty(currVfcToscaName)) {
895 return (Resource) toscaOperationFacade.getLatestByToscaResourceName(currVfcToscaName)
897 .on(st -> findVfcResource(csarInfo, resource, previousVfcToscaName, null, st));
902 private EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>> findNodeTypeArtifactsToHandle(Resource curNodeType,
903 List<ArtifactDefinition> extractedArtifacts) {
905 EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle = null;
907 List<ArtifactDefinition> artifactsToUpload = new ArrayList<>(extractedArtifacts);
908 List<ArtifactDefinition> artifactsToUpdate = new ArrayList<>();
909 List<ArtifactDefinition> artifactsToDelete = new ArrayList<>();
910 processExistingNodeTypeArtifacts(extractedArtifacts, artifactsToUpload, artifactsToUpdate,
911 artifactsToDelete, collectExistingArtifacts(curNodeType));
912 nodeTypeArtifactsToHandle = putFoundArtifacts(artifactsToUpload, artifactsToUpdate, artifactsToDelete);
913 } catch (Exception e) {
914 log.debug("Exception occurred when findNodeTypeArtifactsToHandle, error is:{}", e.getMessage(), e);
915 throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
917 return nodeTypeArtifactsToHandle;
920 private EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>> putFoundArtifacts(
921 List<ArtifactDefinition> artifactsToUpload, List<ArtifactDefinition> artifactsToUpdate,
922 List<ArtifactDefinition> artifactsToDelete) {
923 EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle = null;
924 if (!artifactsToUpload.isEmpty() || !artifactsToUpdate.isEmpty() || !artifactsToDelete.isEmpty()) {
925 nodeTypeArtifactsToHandle = new EnumMap<>(ArtifactOperationEnum.class);
926 if (!artifactsToUpload.isEmpty()) {
927 nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.CREATE, artifactsToUpload);
929 if (!artifactsToUpdate.isEmpty()) {
930 nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.UPDATE, artifactsToUpdate);
932 if (!artifactsToDelete.isEmpty()) {
933 nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.DELETE, artifactsToDelete);
936 return nodeTypeArtifactsToHandle;
939 private void processExistingNodeTypeArtifacts(List<ArtifactDefinition> extractedArtifacts,
940 List<ArtifactDefinition> artifactsToUpload, List<ArtifactDefinition> artifactsToUpdate,
941 List<ArtifactDefinition> artifactsToDelete, Map<String, ArtifactDefinition> existingArtifacts) {
942 if (!existingArtifacts.isEmpty()) {
943 extractedArtifacts.stream()
944 .forEach(a -> processNodeTypeArtifact(artifactsToUpload, artifactsToUpdate, existingArtifacts, a));
945 artifactsToDelete.addAll(existingArtifacts.values());
949 private void processNodeTypeArtifact(List<ArtifactDefinition> artifactsToUpload,
950 List<ArtifactDefinition> artifactsToUpdate, Map<String, ArtifactDefinition> existingArtifacts,
951 ArtifactDefinition currNewArtifact) {
952 Optional<ArtifactDefinition> foundArtifact = existingArtifacts.values()
954 .filter(a -> a.getArtifactName()
955 .equals(currNewArtifact.getArtifactName()))
957 if (foundArtifact.isPresent()) {
958 if (foundArtifact.get()
960 .equals(currNewArtifact.getArtifactType())) {
961 updateFoundArtifact(artifactsToUpdate, currNewArtifact, foundArtifact.get());
962 existingArtifacts.remove(foundArtifact.get()
963 .getArtifactLabel());
964 artifactsToUpload.remove(currNewArtifact);
966 log.debug("Can't upload two artifact with the same name {}.", currNewArtifact.getArtifactName());
967 throw new ByActionStatusComponentException(ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR,
968 currNewArtifact.getArtifactName(), currNewArtifact.getArtifactType(), foundArtifact.get()
974 private void updateFoundArtifact(List<ArtifactDefinition> artifactsToUpdate, ArtifactDefinition currNewArtifact,
975 ArtifactDefinition foundArtifact) {
976 if (!foundArtifact.getArtifactChecksum()
977 .equals(currNewArtifact.getArtifactChecksum())) {
978 foundArtifact.setPayload(currNewArtifact.getPayloadData());
979 foundArtifact.setPayloadData(Base64.encodeBase64String(currNewArtifact.getPayloadData()));
980 foundArtifact.setArtifactChecksum(
981 GeneralUtility.calculateMD5Base64EncodedByByteArray(currNewArtifact.getPayloadData()));
982 artifactsToUpdate.add(foundArtifact);
986 private Map<String, ArtifactDefinition> collectExistingArtifacts(Resource curNodeType) {
987 Map<String, ArtifactDefinition> existingArtifacts = new HashMap<>();
988 if (curNodeType == null) {
989 return existingArtifacts;
991 if (MapUtils.isNotEmpty(curNodeType.getDeploymentArtifacts())) {
992 existingArtifacts.putAll(curNodeType.getDeploymentArtifacts());
994 if (MapUtils.isNotEmpty(curNodeType.getArtifacts())) {
995 existingArtifacts.putAll(curNodeType.getArtifacts()
998 .filter(e -> e.getValue()
999 .getArtifactGroupType() == ArtifactGroupTypeEnum.INFORMATIONAL)
1000 .collect(toMap(Map.Entry::getKey, Map.Entry::getValue)));
1002 return existingArtifacts;
1006 * Changes resource life cycle state to checked out
1010 * @param inTransaction
1013 private Either<Resource, ResponseFormat> checkoutResource(Resource resource, User user, boolean inTransaction) {
1014 Either<Resource, ResponseFormat> checkoutResourceRes;
1016 if (!resource.getComponentMetadataDefinition()
1017 .getMetadataDataDefinition()
1019 .equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
1021 "************* Going to change life cycle state of resource {} to not certified checked out. ",
1022 resource.getName());
1023 Either<? extends Component, ResponseFormat> checkoutRes = lifecycleBusinessLogic.changeComponentState(
1024 resource.getComponentType(), resource.getUniqueId(), user, LifeCycleTransitionEnum.CHECKOUT,
1025 new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
1026 LifecycleChanceActionEnum.CREATE_FROM_CSAR),
1027 inTransaction, true);
1028 if (checkoutRes.isRight()) {
1029 log.debug("Could not change state of component {} with uid {} to checked out. Status is {}. ",
1030 resource.getComponentType()
1032 resource.getUniqueId(), checkoutRes.right()
1035 checkoutResourceRes = Either.right(checkoutRes.right()
1038 checkoutResourceRes = Either.left((Resource) checkoutRes.left()
1042 checkoutResourceRes = Either.left(resource);
1044 } catch (Exception e) {
1045 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1046 checkoutResourceRes = Either.right(responseFormat);
1047 log.debug("Exception occurred when checkoutResource {} , error is:{}", resource.getName(), e.getMessage(),
1050 return checkoutResourceRes;
1054 * Handles Artifacts of NodeType
1056 * @param nodeTypeResource
1057 * @param nodeTypeArtifactsToHandle
1059 * @param inTransaction
1062 public Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifacts(Resource nodeTypeResource,
1063 Map<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
1064 List<ArtifactDefinition> createdArtifacts, User user, boolean inTransaction, boolean ignoreLifecycleState) {
1065 List<ArtifactDefinition> handleNodeTypeArtifactsRequestRes;
1066 Either<List<ArtifactDefinition>, ResponseFormat> handleNodeTypeArtifactsRes = null;
1067 Either<Resource, ResponseFormat> changeStateResponse;
1069 changeStateResponse = checkoutResource(nodeTypeResource, user, inTransaction);
1070 if (changeStateResponse.isRight()) {
1071 return Either.right(changeStateResponse.right()
1074 nodeTypeResource = changeStateResponse.left()
1077 List<ArtifactDefinition> handledNodeTypeArtifacts = new ArrayList<>();
1078 log.debug("************* Going to handle artifacts of node type resource {}. ", nodeTypeResource.getName());
1079 for (Entry<ArtifactOperationEnum, List<ArtifactDefinition>> curOperationEntry : nodeTypeArtifactsToHandle
1081 ArtifactOperationEnum curOperation = curOperationEntry.getKey();
1082 List<ArtifactDefinition> curArtifactsToHandle = curOperationEntry.getValue();
1083 if (curArtifactsToHandle != null && !curArtifactsToHandle.isEmpty()) {
1084 log.debug("************* Going to {} artifact to vfc {}", curOperation.name(),
1085 nodeTypeResource.getName());
1086 handleNodeTypeArtifactsRequestRes = artifactsBusinessLogic
1087 .handleArtifactsRequestForInnerVfcComponent(curArtifactsToHandle, nodeTypeResource, user,
1088 createdArtifacts, new ArtifactOperationInfo(false,
1089 ignoreLifecycleState, curOperation),
1090 false, inTransaction);
1091 if (ArtifactOperationEnum.isCreateOrLink(curOperation)) {
1092 createdArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
1094 handledNodeTypeArtifacts.addAll(handleNodeTypeArtifactsRequestRes);
1097 if (handleNodeTypeArtifactsRes == null) {
1098 handleNodeTypeArtifactsRes = Either.left(handledNodeTypeArtifacts);
1100 } catch (Exception e) {
1101 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
1102 handleNodeTypeArtifactsRes = Either.right(responseFormat);
1103 log.debug("Exception occurred when handleVfcArtifacts, error is:{}", e.getMessage(), e);
1105 return handleNodeTypeArtifactsRes;
1108 private Map<String, ImmutablePair<String, String>> extractVfcToscaNames(final Map<String, NodeTypeInfo> nodeTypesInfo,
1109 final String vfResourceName,
1110 final CsarInfo csarInfo) {
1111 final Map<String, ImmutablePair<String, String>> vfcToscaNames = new HashMap<>();
1113 final Map<String, Object> nodes = extractAllNodes(nodeTypesInfo, csarInfo);
1114 if (!nodes.isEmpty()) {
1115 final Iterator<Entry<String, Object>> nodesNameEntry = nodes.entrySet().iterator();
1116 while (nodesNameEntry.hasNext()) {
1117 final Entry<String, Object> nodeType = nodesNameEntry.next();
1118 final ImmutablePair<String, String> toscaResourceName = buildNestedToscaResourceName(
1119 ResourceTypeEnum.VFC.name(), vfResourceName, nodeType.getKey());
1120 vfcToscaNames.put(nodeType.getKey(), toscaResourceName);
1123 for (final NodeTypeInfo cvfc : nodeTypesInfo.values()) {
1124 vfcToscaNames.put(cvfc.getType(), buildNestedToscaResourceName(ResourceTypeEnum.CVFC.name(),
1125 vfResourceName, cvfc.getType()));
1127 return vfcToscaNames;
1130 private Map<String, Object> extractAllNodes(Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo) {
1131 Map<String, Object> nodes = new HashMap<>();
1132 for (NodeTypeInfo nodeTypeInfo : nodeTypesInfo.values()) {
1133 extractNodeTypes(nodes, nodeTypeInfo.getMappedToscaTemplate());
1135 extractNodeTypes(nodes, csarInfo.getMappedToscaMainTemplate());
1139 private void extractNodeTypes(Map<String, Object> nodes, Map<String, Object> mappedToscaTemplate) {
1140 Either<Map<String, Object>, ResultStatusEnum> eitherNodeTypes = ImportUtils
1141 .findFirstToscaMapElement(mappedToscaTemplate, TypeUtils.ToscaTagNamesEnum.NODE_TYPES);
1142 if (eitherNodeTypes.isLeft()) {
1143 nodes.putAll(eitherNodeTypes.left()
1148 public Resource createResourceFromCsar(Resource resource, User user, Map<String, byte[]> csarUIPayload,
1150 log.trace("************* created successfully from YAML, resource TOSCA ");
1151 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML,StatusCode.STARTED,"Starting to create Resource From Csar by user {}", user.getUserId() );
1152 CsarInfo csarInfo = csarBusinessLogic.getCsarInfo(resource, null, user, csarUIPayload, csarUUID);
1153 Map<String, NodeTypeInfo> nodeTypesInfo = csarInfo.extractNodeTypesInfo();
1154 Either<Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>, ResponseFormat> findNodeTypesArtifactsToHandleRes = findNodeTypesArtifactsToHandle(
1155 nodeTypesInfo, csarInfo, resource);
1156 if (findNodeTypesArtifactsToHandleRes.isRight()) {
1157 log.debug("failed to find node types for update with artifacts during import csar {}. ",
1158 csarInfo.getCsarUUID());
1159 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML,resource.getComponentMetadataForSupportLog(),
1160 StatusCode.ERROR,"error: {}",findNodeTypesArtifactsToHandleRes.right().value());
1161 throw new ByResponseFormatComponentException(findNodeTypesArtifactsToHandleRes.right().value());
1163 Resource vfResource = createResourceFromYaml(resource, csarInfo.getMainTemplateContent(),
1164 csarInfo.getMainTemplateName(), nodeTypesInfo, csarInfo, findNodeTypesArtifactsToHandleRes.left()
1167 log.trace("*************VF Resource created successfully from YAML, resource TOSCA name: {}",
1168 vfResource.getToscaResourceName());
1169 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML,StatusCode.COMPLETE,"Ended create Resource From Csar by user {}", user.getUserId() );
1173 private Resource validateResourceBeforeCreate(Resource resource, User user, boolean inTransaction) {
1174 log.trace("validating resource before create");
1175 user.copyData(validateUser(user, CREATE_RESOURCE, resource, AuditingActionEnum.CREATE_RESOURCE, false));
1176 // validate user role
1177 validateUserRole(user, resource, new ArrayList<>(), AuditingActionEnum.CREATE_RESOURCE, null);
1178 // VF / PNF "derivedFrom" should be null (or ignored)
1179 if (ModelConverter.isAtomicComponent(resource)) {
1180 validateDerivedFromNotEmpty(user, resource, AuditingActionEnum.CREATE_RESOURCE);
1182 return validateResourceBeforeCreate(resource, user, AuditingActionEnum.CREATE_RESOURCE, inTransaction, null);
1186 // resource, yamlFileContents, yamlFileName, nodeTypesInfo,csarInfo,
1187 // nodeTypesArtifactsToCreate, true, false, null
1188 private Resource createResourceFromYaml(Resource resource, String topologyTemplateYaml, String yamlName,
1189 Map<String, NodeTypeInfo> nodeTypesInfo, CsarInfo csarInfo,
1190 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
1191 boolean shouldLock, boolean inTransaction, String nodeName) {
1193 List<ArtifactDefinition> createdArtifacts = new ArrayList<>();
1194 Resource createdResource;
1196 ParsedToscaYamlInfo parsedToscaYamlInfo = csarBusinessLogic.getParsedToscaYamlInfo(topologyTemplateYaml, yamlName, nodeTypesInfo, csarInfo, nodeName);
1197 if (MapUtils.isEmpty(parsedToscaYamlInfo.getInstances()) && resource.getResourceType() != ResourceTypeEnum.PNF) {
1198 throw new ByActionStatusComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
1200 log.debug("#createResourceFromYaml - Going to create resource {} and RIs ", resource.getName());
1201 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML,resource.getComponentMetadataForSupportLog(),
1202 StatusCode.STARTED,"");
1203 createdResource = createResourceAndRIsFromYaml(yamlName, resource, parsedToscaYamlInfo,
1204 AuditingActionEnum.IMPORT_RESOURCE, false, createdArtifacts, topologyTemplateYaml, nodeTypesInfo,
1205 csarInfo, nodeTypesArtifactsToCreate, shouldLock, inTransaction, nodeName);
1206 log.debug("#createResourceFromYaml - The resource {} has been created ", resource.getName());
1207 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML,resource.getComponentMetadataForSupportLog(),
1208 StatusCode.COMPLETE,"The resource has been created: {}",resource.getName());
1209 } catch (ComponentException e) {
1210 ResponseFormat responseFormat = e.getResponseFormat() == null
1211 ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
1212 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource,
1213 AuditingActionEnum.IMPORT_RESOURCE);
1215 } catch (StorageException e) {
1216 ResponseFormat responseFormat = componentsUtils
1217 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
1218 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource,
1219 AuditingActionEnum.IMPORT_RESOURCE);
1222 return createdResource;
1226 public Map<String, Resource> createResourcesFromYamlNodeTypesList(String yamlName, Resource resource,
1227 Map<String, Object> mappedToscaTemplate, boolean needLock,
1228 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1229 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo,
1230 CsarInfo csarInfo) {
1232 Either<String, ResultStatusEnum> toscaVersion = findFirstToscaStringElement(mappedToscaTemplate,
1233 TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION);
1234 if (toscaVersion.isRight()) {
1235 throw new ByActionStatusComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE);
1237 Map<String, Object> mapToConvert = new HashMap<>();
1238 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.TOSCA_VERSION.getElementName(), toscaVersion.left()
1240 Map<String, Object> nodeTypes = getNodeTypesFromTemplate(mappedToscaTemplate);
1241 createNodeTypes(yamlName, resource, needLock, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
1242 nodeTypesInfo, csarInfo, mapToConvert, nodeTypes);
1243 return csarInfo.getCreatedNodes();
1246 private Map<String, Object> getNodeTypesFromTemplate(Map<String, Object> mappedToscaTemplate) {
1247 return ImportUtils.findFirstToscaMapElement(mappedToscaTemplate, TypeUtils.ToscaTagNamesEnum.NODE_TYPES)
1249 .orValue(HashMap::new);
1252 private void createNodeTypes(String yamlName, Resource resource, boolean needLock,
1253 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
1254 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo,
1255 CsarInfo csarInfo, Map<String, Object> mapToConvert, Map<String, Object> nodeTypes) {
1256 Iterator<Entry<String, Object>> nodesNameValueIter = nodeTypes.entrySet()
1258 Resource vfcCreated = null;
1259 while (nodesNameValueIter.hasNext()) {
1260 Entry<String, Object> nodeType = nodesNameValueIter.next();
1261 Map<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle = nodeTypesArtifactsToHandle == null
1262 || nodeTypesArtifactsToHandle.isEmpty() ? null : nodeTypesArtifactsToHandle.get(nodeType.getKey());
1264 if (nodeTypesInfo.containsKey(nodeType.getKey())) {
1265 log.trace("************* Going to handle nested vfc {}", nodeType.getKey());
1266 vfcCreated = handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts,
1267 nodeTypesInfo, csarInfo, nodeType.getKey());
1268 log.trace("************* Finished to handle nested vfc {}", nodeType.getKey());
1269 } else if (csarInfo.getCreatedNodesToscaResourceNames() != null
1270 && !csarInfo.getCreatedNodesToscaResourceNames()
1271 .containsKey(nodeType.getKey())) {
1272 log.trace("************* Going to create node {}", nodeType.getKey());
1273 ImmutablePair<Resource, ActionStatus> resourceCreated = createNodeTypeResourceFromYaml(yamlName,
1274 nodeType, csarInfo.getModifier(), mapToConvert, resource, needLock, nodeTypeArtifactsToHandle,
1275 nodeTypesNewCreatedArtifacts, true, csarInfo, true);
1276 log.debug("************* Finished to create node {}", nodeType.getKey());
1278 vfcCreated = resourceCreated.getLeft();
1279 csarInfo.getCreatedNodesToscaResourceNames()
1280 .put(nodeType.getKey(), vfcCreated.getToscaResourceName());
1282 if (vfcCreated != null) {
1283 csarInfo.getCreatedNodes()
1284 .put(nodeType.getKey(), vfcCreated);
1286 mapToConvert.remove(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName());
1290 private Resource handleNestedVfc(Resource resource,
1291 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1292 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1295 String yamlName = nodesInfo.get(nodeName)
1296 .getTemplateFileName();
1297 Map<String, Object> nestedVfcJsonMap = nodesInfo.get(nodeName)
1298 .getMappedToscaTemplate();
1300 log.debug("************* Going to create node types from yaml {}", yamlName);
1301 createResourcesFromYamlNodeTypesList(yamlName, resource, nestedVfcJsonMap, false, nodesArtifactsToHandle,
1302 createdArtifacts, Collections.emptyMap(), csarInfo);
1303 log.debug("************* Finished to create node types from yaml {}", yamlName);
1305 if (nestedVfcJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE.getElementName())) {
1306 log.debug("************* Going to handle complex VFC from yaml {}", yamlName);
1307 resource = handleComplexVfc(resource, nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo,
1308 nodeName, yamlName);
1313 private Resource handleComplexVfc(final Resource resource,
1314 final Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>>
1315 nodesArtifactsToHandle,
1316 final List<ArtifactDefinition>
1317 createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1318 final String nodeName, final String yamlName) {
1320 Resource oldComplexVfc = null;
1321 Resource newComplexVfc = buildValidComplexVfc(resource, csarInfo, nodeName, nodesInfo);
1322 Either<Resource, StorageOperationStatus> oldComplexVfcRes = toscaOperationFacade
1323 .getFullLatestComponentByToscaResourceName(newComplexVfc.getToscaResourceName());
1324 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() == StorageOperationStatus.NOT_FOUND) {
1325 oldComplexVfcRes = toscaOperationFacade.getFullLatestComponentByToscaResourceName(
1326 buildNestedToscaResourceName(ResourceTypeEnum.CVFC.name(), csarInfo.getVfResourceName(), nodeName).getRight());
1328 if (oldComplexVfcRes.isRight() && oldComplexVfcRes.right().value() != StorageOperationStatus.NOT_FOUND) {
1329 log.debug("Failed to fetch previous complex VFC by tosca resource name {}. Status is {}. ",
1330 newComplexVfc.getToscaResourceName(), oldComplexVfcRes.right().value());
1331 throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
1332 } else if (oldComplexVfcRes.isLeft()) {
1333 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
1334 final Either<Boolean, ResponseFormat> eitherValidation = validateNestedDerivedFromDuringUpdate(
1335 oldComplexVfcRes.left().value(),
1336 newComplexVfc, ValidationUtils.hasBeenCertified(oldComplexVfcRes.left().value().getVersion()));
1337 if (eitherValidation.isLeft()) {
1338 oldComplexVfc = oldComplexVfcRes.left().value();
1341 newComplexVfc = handleComplexVfc(nodesArtifactsToHandle, createdArtifacts, nodesInfo, csarInfo, nodeName,
1342 yamlName, oldComplexVfc, newComplexVfc);
1343 csarInfo.getCreatedNodesToscaResourceNames().put(nodeName, newComplexVfc.getToscaResourceName());
1344 final LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
1345 LifecycleChanceActionEnum.CREATE_FROM_CSAR);
1346 log.debug("Going to certify cvfc {}. ", newComplexVfc.getName());
1347 final Resource result = propagateStateToCertified(csarInfo.getModifier(), newComplexVfc,
1348 lifecycleChangeInfo, true, false, true);
1349 csarInfo.getCreatedNodes().put(nodeName, result);
1350 csarInfo.removeNodeFromQueue();
1354 private Resource handleComplexVfc(
1355 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodesArtifactsToHandle,
1356 List<ArtifactDefinition> createdArtifacts, Map<String, NodeTypeInfo> nodesInfo, CsarInfo csarInfo,
1357 String nodeName, String yamlName, Resource oldComplexVfc, Resource newComplexVfc) {
1359 Resource handleComplexVfcRes;
1360 Map<String, Object> mappedToscaTemplate = nodesInfo.get(nodeName)
1361 .getMappedToscaTemplate();
1362 String yamlContent = new String(csarInfo.getCsar()
1364 Map<String, NodeTypeInfo> newNodeTypesInfo = nodesInfo.entrySet()
1366 .collect(toMap(Entry::getKey, e -> e.getValue()
1367 .getUnmarkedCopy()));
1368 CsarInfo.markNestedVfc(mappedToscaTemplate, newNodeTypesInfo);
1369 if (oldComplexVfc == null) {
1370 handleComplexVfcRes = createResourceFromYaml(newComplexVfc, yamlContent, yamlName, newNodeTypesInfo,
1371 csarInfo, nodesArtifactsToHandle, false, true, nodeName);
1373 handleComplexVfcRes = updateResourceFromYaml(oldComplexVfc, newComplexVfc,
1374 AuditingActionEnum.UPDATE_RESOURCE_METADATA, createdArtifacts, yamlContent, yamlName, csarInfo,
1375 newNodeTypesInfo, nodesArtifactsToHandle, nodeName, true);
1377 return handleComplexVfcRes;
1380 private Resource buildValidComplexVfc(Resource resource, CsarInfo csarInfo, String nodeName,
1381 Map<String, NodeTypeInfo> nodesInfo) {
1383 Resource complexVfc = buildComplexVfcMetadata(resource, csarInfo, nodeName, nodesInfo);
1384 log.debug("************* Going to validate complex VFC from yaml {}", complexVfc.getName());
1385 csarInfo.addNodeToQueue(nodeName);
1386 return validateResourceBeforeCreate(complexVfc, csarInfo.getModifier(), AuditingActionEnum.IMPORT_RESOURCE,
1390 private String getNodeTypeActualName(final String nodeTypefullName, final String nodeTypeNamePrefix) {
1392 final String nameWithouNamespacePrefix = nodeTypefullName.substring(nodeTypeNamePrefix.length());
1393 final String[] findTypes = nameWithouNamespacePrefix.split("\\.");
1395 if(findTypes.length > 1){
1396 final String resourceType = findTypes[0];
1397 return nameWithouNamespacePrefix.substring(resourceType.length());
1399 return nameWithouNamespacePrefix;
1402 private ImmutablePair<Resource, ActionStatus> createNodeTypeResourceFromYaml(final String yamlName,
1403 final Entry<String, Object> nodeNameValue,
1405 final Map<String, Object> mapToConvert,
1406 final Resource resourceVf,
1407 final boolean needLock,
1408 final Map<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
1409 final List<ArtifactDefinition> nodeTypesNewCreatedArtifacts,
1410 final boolean forceCertificationAllowed,
1411 final CsarInfo csarInfo,
1412 final boolean isNested) {
1414 final UploadResourceInfo resourceMetaData = fillResourceMetadata(
1415 yamlName, resourceVf, nodeNameValue.getKey(), user);
1417 final String singleVfcYaml = buildNodeTypeYaml(nodeNameValue, mapToConvert, resourceMetaData.getResourceType(), csarInfo);
1418 user = validateUser(user, "CheckIn Resource", resourceVf, AuditingActionEnum.CHECKIN_RESOURCE, true);
1419 return createResourceFromNodeType(singleVfcYaml, resourceMetaData, user, true, needLock,
1420 nodeTypeArtifactsToHandle, nodeTypesNewCreatedArtifacts, forceCertificationAllowed, csarInfo,
1421 nodeNameValue.getKey(), isNested);
1424 private String buildNodeTypeYaml(final Entry<String, Object> nodeNameValue,
1425 final Map<String, Object> mapToConvert,
1426 final String nodeResourceType,
1427 final CsarInfo csarInfo) {
1428 // We need to create a Yaml from each node_types in order to create
1429 // resource from each node type using import normative flow.
1430 final DumperOptions options = new DumperOptions();
1431 options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
1432 final Yaml yaml = new Yaml(options);
1434 final Map<String, Object> node = new HashMap<>();
1435 node.put(buildNestedToscaResourceName(nodeResourceType, csarInfo.getVfResourceName(), nodeNameValue.getKey())
1436 .getLeft(), nodeNameValue.getValue());
1437 mapToConvert.put(TypeUtils.ToscaTagNamesEnum.NODE_TYPES.getElementName(), node);
1439 return yaml.dumpAsMap(mapToConvert);
1442 public Boolean validateResourceCreationFromNodeType(Resource resource, User creator) {
1443 validateDerivedFromNotEmpty(creator, resource, AuditingActionEnum.CREATE_RESOURCE);
1447 public ImmutablePair<Resource, ActionStatus> createResourceFromNodeType(String nodeTypeYaml,
1448 UploadResourceInfo resourceMetaData, User creator, boolean isInTransaction, boolean needLock,
1449 Map<ArtifactOperationEnum, List<ArtifactDefinition>> nodeTypeArtifactsToHandle,
1450 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, boolean forceCertificationAllowed, CsarInfo csarInfo,
1451 String nodeName, boolean isNested) {
1453 LifecycleChangeInfoWithAction lifecycleChangeInfo = new LifecycleChangeInfoWithAction(CERTIFICATION_ON_IMPORT,
1454 LifecycleChanceActionEnum.CREATE_FROM_CSAR);
1455 Function<Resource, Boolean> validator = resource -> validateResourceCreationFromNodeType(
1457 return resourceImportManager.importCertifiedResource(nodeTypeYaml, resourceMetaData, creator, validator,
1458 lifecycleChangeInfo, isInTransaction, true, needLock, nodeTypeArtifactsToHandle,
1459 nodeTypesNewCreatedArtifacts, forceCertificationAllowed, csarInfo, nodeName, isNested);
1463 * Validates if a given node type name has a valid prefix.
1465 * @param nodeName node name from definition file
1466 * @param definedResourceNamespaceList is a list of all node type name prefix allowed
1467 * @return a valid node type name prefix if it`s found
1469 public Optional<String> validateNodeTypeNamePrefix(final String nodeName,
1470 final List<String> definedResourceNamespaceList) {
1471 for (final String validNamespace : definedResourceNamespaceList) {
1472 if (nodeName.startsWith(validNamespace)) {
1473 return Optional.of(validNamespace);
1476 return Optional.empty();
1479 private List<String> getDefinedNodeTypeNamespaceList() {
1480 return ConfigurationManager.getConfigurationManager().getConfiguration().getDefinedResourceNamespace();
1483 private UploadResourceInfo fillResourceMetadata(final String yamlName, final Resource resourceVf,
1484 final String nodeName, final User user) {
1486 final UploadResourceInfo resourceMetaData = new UploadResourceInfo();
1488 final String nodeTypeNamePrefix = getNodeTypeNamePrefix(nodeName);
1489 log.debug("Node type Name prefix {}", nodeTypeNamePrefix);
1491 if (!nodeName.startsWith(nodeTypeNamePrefix)) {
1492 log.debug("invalid nodeName:{} does not start with {}.", nodeName, getDefinedNodeTypeNamespaceList());
1493 throw new ByActionStatusComponentException(ActionStatus.INVALID_NODE_TEMPLATE, yamlName,
1494 resourceMetaData.getName(), nodeName);
1497 final String actualName = this.getNodeTypeActualName(nodeName, nodeTypeNamePrefix);
1498 final String namePrefix = nodeName.replace(actualName, "");
1499 String resourceType = namePrefix.substring(nodeTypeNamePrefix.length());
1500 log.debug("initial namePrefix:{} resourceType {}. nodeName {} , actualName {} prefix {}", namePrefix,
1501 resourceType, nodeName, actualName, nodeTypeNamePrefix);
1503 // if we import from csar, the node_type name can be
1504 // org.openecomp.resource.abstract.node_name - in this case we always
1506 if (resourceType.equals(Constants.ABSTRACT)) {
1507 resourceType = ResourceTypeEnum.VFC.name().toLowerCase();
1510 if (!ResourceTypeEnum.containsIgnoreCase(resourceType)) {
1511 resourceType = ResourceTypeEnum.VFC.name().toLowerCase();
1515 if (!ResourceTypeEnum.containsName(resourceType.toUpperCase())) {
1516 log.debug("invalid resourceType:{} the type is not one of the valide types:{}.",
1517 resourceType.toUpperCase(), ResourceTypeEnum.values());
1518 throw new ByActionStatusComponentException(ActionStatus.INVALID_NODE_TEMPLATE, yamlName,
1519 resourceMetaData.getName(), nodeName);
1523 resourceMetaData.setName(new StringBuilder(resourceVf.getSystemName()).append(actualName).toString());
1525 // Setting type from name
1526 final String type = resourceType.toUpperCase();
1527 resourceMetaData.setResourceType(type);
1529 resourceMetaData.setDescription(ImportUtils.Constants.INNER_VFC_DESCRIPTION);
1530 resourceMetaData.setIcon(ImportUtils.Constants.DEFAULT_ICON);
1531 resourceMetaData.setContactId(user.getUserId());
1532 resourceMetaData.setVendorName(resourceVf.getVendorName());
1533 resourceMetaData.setVendorRelease(resourceVf.getVendorRelease());
1536 final List<String> tags = new ArrayList<>();
1537 tags.add(resourceMetaData.getName());
1538 resourceMetaData.setTags(tags);
1541 final CategoryDefinition category = new CategoryDefinition();
1542 category.setName(ImportUtils.Constants.ABSTRACT_CATEGORY_NAME);
1543 final SubCategoryDefinition subCategory = new SubCategoryDefinition();
1544 subCategory.setName(ImportUtils.Constants.ABSTRACT_SUBCATEGORY);
1545 category.addSubCategory(subCategory);
1546 final List<CategoryDefinition> categories = new ArrayList<>();
1547 categories.add(category);
1548 resourceMetaData.setCategories(categories);
1550 return resourceMetaData;
1553 private Resource buildComplexVfcMetadata(final Resource resourceVf,
1554 final CsarInfo csarInfo,
1555 final String nodeName,
1556 final Map<String, NodeTypeInfo> nodesInfo) {
1557 final Resource cvfc = new Resource();
1558 final NodeTypeInfo nodeTypeInfo = nodesInfo.get(nodeName);
1559 cvfc.setName(buildCvfcName(csarInfo.getVfResourceName(), nodeName));
1560 cvfc.setNormalizedName(ValidationUtils.normaliseComponentName(cvfc.getName()));
1561 cvfc.setSystemName(ValidationUtils.convertToSystemName(cvfc.getName()));
1562 cvfc.setResourceType(ResourceTypeEnum.CVFC);
1563 cvfc.setAbstract(true);
1564 cvfc.setDerivedFrom(nodeTypeInfo.getDerivedFrom());
1565 cvfc.setDescription(ImportUtils.Constants.CVFC_DESCRIPTION);
1566 cvfc.setIcon(ImportUtils.Constants.DEFAULT_ICON);
1567 cvfc.setContactId(csarInfo.getModifier()
1569 cvfc.setCreatorUserId(csarInfo.getModifier()
1571 cvfc.setVendorName(resourceVf.getVendorName());
1572 cvfc.setVendorRelease(resourceVf.getVendorRelease());
1573 cvfc.setResourceVendorModelNumber(resourceVf.getResourceVendorModelNumber());
1574 cvfc.setToscaResourceName(buildNestedToscaResourceName(
1575 ResourceTypeEnum.CVFC.name(), csarInfo.getVfResourceName(), nodeName).getLeft());
1576 cvfc.setInvariantUUID(UniqueIdBuilder.buildInvariantUUID());
1578 final List<String> tags = new ArrayList<>();
1579 tags.add(cvfc.getName());
1582 final CategoryDefinition category = new CategoryDefinition();
1583 category.setName(ImportUtils.Constants.ABSTRACT_CATEGORY_NAME);
1584 SubCategoryDefinition subCategory = new SubCategoryDefinition();
1585 subCategory.setName(ImportUtils.Constants.ABSTRACT_SUBCATEGORY);
1586 category.addSubCategory(subCategory);
1587 final List<CategoryDefinition> categories = new ArrayList<>();
1588 categories.add(category);
1589 cvfc.setCategories(categories);
1591 cvfc.setVersion(ImportUtils.Constants.FIRST_NON_CERTIFIED_VERSION);
1592 cvfc.setLifecycleState(ImportUtils.Constants.NORMATIVE_TYPE_LIFE_CYCLE_NOT_CERTIFIED_CHECKOUT);
1593 cvfc.setHighestVersion(ImportUtils.Constants.NORMATIVE_TYPE_HIGHEST_VERSION);
1598 private String buildCvfcName(final String resourceVfName, final String nodeName) {
1600 String nameWithouNamespacePrefix =
1601 nodeName.substring(Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX.length());
1602 String[] findTypes = nameWithouNamespacePrefix.split("\\.");
1603 String resourceType = findTypes[0];
1604 String resourceName = resourceVfName + "-" + nameWithouNamespacePrefix.substring(resourceType.length() + 1);
1605 return addCvfcSuffixToResourceName(resourceName);
1608 private Resource createResourceAndRIsFromYaml(final String yamlName,
1610 final ParsedToscaYamlInfo parsedToscaYamlInfo,
1611 final AuditingActionEnum actionEnum,
1612 final boolean isNormative,
1613 final List<ArtifactDefinition> createdArtifacts,
1614 final String topologyTemplateYaml,
1615 final Map<String, NodeTypeInfo> nodeTypesInfo,
1616 final CsarInfo csarInfo,
1617 final Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
1618 final boolean shouldLock,
1619 final boolean inTransaction,
1620 final String nodeName) {
1622 final List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = new ArrayList<>();
1625 final Either<Boolean, ResponseFormat> lockResult = lockComponentByName(resource.getSystemName(), resource,
1627 if (lockResult.isRight()) {
1628 rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1629 throw new ByResponseFormatComponentException(lockResult.right().value());
1631 log.debug("name is locked {} status = {}", resource.getSystemName(), lockResult);
1634 log.trace("************* createResourceFromYaml before full create resource {}", yamlName);
1635 loggerSupportability.log(LoggerSupportabilityActions.CREATE_INPUTS,resource.getComponentMetadataForSupportLog(), StatusCode.STARTED,"Starting to add inputs from yaml: {}",yamlName);
1636 final Resource genericResource = fetchAndSetDerivedFromGenericType(resource);
1637 resource = createResourceTransaction(resource, csarInfo.getModifier(), isNormative);
1638 log.trace("************* createResourceFromYaml after full create resource {}", yamlName);
1639 log.trace("************* Going to add inputs from yaml {}", yamlName);
1640 if (resource.shouldGenerateInputs())
1641 generateAndAddInputsFromGenericTypeProperties(resource, genericResource);
1643 final Map<String, InputDefinition> inputs = parsedToscaYamlInfo.getInputs();
1644 resource = createInputsOnResource(resource, inputs);
1645 log.trace("************* Finish to add inputs from yaml {}", yamlName);
1646 loggerSupportability.log(LoggerSupportabilityActions.CREATE_INPUTS,
1647 resource.getComponentMetadataForSupportLog(),
1648 StatusCode.COMPLETE,"Finish to add inputs from yaml: {}",yamlName);
1649 if (resource.getResourceType() == ResourceTypeEnum.PNF) {
1650 log.trace("************* Adding generic properties to PNF");
1651 resource = (Resource) propertyBusinessLogic.copyPropertyToComponent(resource,
1652 genericResource.getProperties());
1653 log.trace("************* Adding software information to PNF");
1654 softwareInformationBusinessLogic.setSoftwareInformation(resource, csarInfo);
1655 log.trace("************* Removing non-mano software information file from PNF");
1656 if (csarInfo.getSoftwareInformationPath().isPresent() &&
1657 !softwareInformationBusinessLogic.removeSoftwareInformationFile(csarInfo)) {
1658 log.warn(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR , ResourceBusinessLogic.class.getName(),
1659 "catalog-be", "Could not remove the software information file.");
1663 final Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap = parsedToscaYamlInfo
1665 log.trace("************* Going to create nodes, RI's and Relations from yaml {}", yamlName);
1666 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML,resource.getComponentMetadataForSupportLog(), StatusCode.STARTED,"Start create nodes, RI and Relations from yaml: {}",yamlName);
1667 resource = createRIAndRelationsFromYaml(yamlName, resource, uploadComponentInstanceInfoMap,
1668 topologyTemplateYaml, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeTypesArtifactsToCreate,
1670 log.trace("************* Finished to create nodes, RI and Relation from yaml {}", yamlName);
1671 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,
1672 resource.getComponentMetadataForSupportLog(),
1673 StatusCode.COMPLETE,"Finished to create nodes, RI and Relation from yaml: {}",yamlName);
1674 // validate update vf module group names
1675 final Either<Map<String, GroupDefinition>, ResponseFormat> validateUpdateVfGroupNamesRes = groupBusinessLogic
1676 .validateUpdateVfGroupNames(parsedToscaYamlInfo.getGroups(), resource.getSystemName());
1677 if (validateUpdateVfGroupNamesRes.isRight()) {
1678 rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1679 throw new ByResponseFormatComponentException(validateUpdateVfGroupNamesRes.right().value());
1681 // add groups to resource
1682 final Map<String, GroupDefinition> groups;
1683 log.trace("************* Going to add groups from yaml {}", yamlName);
1684 loggerSupportability.log(LoggerSupportabilityActions.CREATE_GROUPS,resource.getComponentMetadataForSupportLog(),
1685 StatusCode.STARTED,"Start to add groups from yaml: {}",yamlName);
1686 if (!validateUpdateVfGroupNamesRes.left().value().isEmpty()) {
1687 groups = validateUpdateVfGroupNamesRes.left().value();
1689 groups = parsedToscaYamlInfo.getGroups();
1692 final Either<Resource, ResponseFormat> createGroupsOnResource = createGroupsOnResource(resource, groups);
1693 if (createGroupsOnResource.isRight()) {
1694 rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1695 loggerSupportability.log(LoggerSupportabilityActions.CREATE_GROUPS,
1696 resource.getComponentMetadataForSupportLog(),
1697 StatusCode.ERROR,"ERROR while adding groups from yaml: {}",yamlName);
1698 throw new ByResponseFormatComponentException(createGroupsOnResource.right().value());
1700 resource = createGroupsOnResource.left().value();
1701 log.trace("************* Finished to add groups from yaml {}", yamlName);
1702 loggerSupportability.log(LoggerSupportabilityActions.CREATE_GROUPS,
1703 resource.getComponentMetadataForSupportLog(),
1704 StatusCode.COMPLETE,"Finished to add groups from yaml: {}", yamlName);
1705 log.trace("************* Going to add artifacts from yaml {}", yamlName);
1706 loggerSupportability.log(LoggerSupportabilityActions.CREATE_ARTIFACTS,
1707 resource.getComponentMetadataForSupportLog(),
1708 StatusCode.STARTED,"Started to add artifacts from yaml: {}",yamlName);
1710 log.trace("************* Starting to add policies from yaml {}", yamlName);
1711 Map<String, PolicyDefinition> policies = parsedToscaYamlInfo.getPolicies();
1712 if (MapUtils.isNotEmpty(policies)) {
1713 resource = createPoliciesOnResource(resource, policies);
1715 log.trace("************* Finished to add policies from yaml {}", yamlName);
1717 final NodeTypeInfoToUpdateArtifacts nodeTypeInfoToUpdateArtifacts =
1718 new NodeTypeInfoToUpdateArtifacts(nodeName, nodeTypesArtifactsToCreate);
1720 final Either<Resource, ResponseFormat> createArtifactsEither = createOrUpdateArtifacts(
1721 ArtifactOperationEnum.CREATE, createdArtifacts, yamlName, csarInfo, resource,
1722 nodeTypeInfoToUpdateArtifacts, inTransaction, shouldLock);
1723 if (createArtifactsEither.isRight()) {
1724 rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1725 loggerSupportability.log(LoggerSupportabilityActions.CREATE_ARTIFACTS,
1726 resource.getComponentMetadataForSupportLog(), StatusCode.ERROR,"error happened {}",
1727 createArtifactsEither.right().value());
1728 throw new ByResponseFormatComponentException(createArtifactsEither.right().value());
1730 loggerSupportability.log(LoggerSupportabilityActions.CREATE_ARTIFACTS,
1731 resource.getComponentMetadataForSupportLog(),
1732 StatusCode.COMPLETE,"Finished to add artifacts from yaml: "+resource.getToscaResourceName());
1733 final ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.CREATED);
1734 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource, actionEnum);
1735 ASDCKpiApi.countCreatedResourcesKPI();
1738 } catch (final ComponentException | StorageException e) {
1739 rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1741 } catch (final ToscaOperationException e) {
1742 log.error("An error has occurred during resource and resource instance creation", e);
1743 rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1744 log.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, ResourceBusinessLogic.class.getName(),
1745 "catalog-be", e.getMessage());
1746 throw new ByActionStatusComponentException(ActionStatus.GENERAL_ERROR);
1747 } catch (final BusinessLogicException e) {
1748 log.error("An error has occurred during resource and resource instance creation", e);
1749 rollback(inTransaction, resource, createdArtifacts, nodeTypesNewCreatedArtifacts);
1750 throw new ByResponseFormatComponentException(e.getResponseFormat());
1752 if (!inTransaction) {
1753 janusGraphDao.commit();
1756 graphLockOperation.unlockComponentByName(resource.getSystemName(), resource.getUniqueId(),
1757 NodeTypeEnum.Resource);
1762 private void rollback(boolean inTransaction, Resource resource, List<ArtifactDefinition> createdArtifacts,
1763 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts) {
1764 if (!inTransaction) {
1765 janusGraphDao.rollback();
1767 if (isNotEmpty(createdArtifacts) && isNotEmpty(nodeTypesNewCreatedArtifacts)) {
1768 createdArtifacts.addAll(nodeTypesNewCreatedArtifacts);
1769 log.debug("Found {} newly created artifacts to deleted, the component name: {}", createdArtifacts.size(),
1770 resource.getName());
1774 private Resource getResourceWithGroups(String resourceId) {
1776 ComponentParametersView filter = new ComponentParametersView();
1777 filter.setIgnoreGroups(false);
1778 Either<Resource, StorageOperationStatus> updatedResource = toscaOperationFacade.getToscaElement(resourceId,
1780 if (updatedResource.isRight()) {
1781 rollbackWithException(componentsUtils.convertFromStorageResponse(updatedResource.right()
1782 .value()), resourceId);
1784 return updatedResource.left()
1788 private Either<Resource, ResponseFormat> createGroupsOnResource(Resource resource,
1789 Map<String, GroupDefinition> groups) {
1790 if (groups != null && !groups.isEmpty()) {
1791 List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, resource);
1792 handleGroupsProperties(resource, groups);
1793 fillGroupsFinalFields(groupsAsList);
1794 Either<List<GroupDefinition>, ResponseFormat> createGroups = groupBusinessLogic.createGroups(resource,
1795 groupsAsList, true);
1796 if (createGroups.isRight()) {
1797 return Either.right(createGroups.right()
1801 return Either.left(resource);
1804 private void handleGroupsProperties(Resource resource, Map<String, GroupDefinition> groups) {
1805 List<InputDefinition> inputs = resource.getInputs();
1806 if (MapUtils.isNotEmpty(groups)) {
1809 .filter(g -> isNotEmpty(g.getProperties()))
1810 .flatMap(g -> g.getProperties()
1812 .forEach(p -> handleGetInputs(p, inputs));
1816 private Resource createPoliciesOnResource(Resource resource, Map<String, PolicyDefinition> policies) {
1817 policyBusinessLogic.createPoliciesFromParsedCsar(resource, policies);
1821 private void handleGetInputs(PropertyDataDefinition property, List<InputDefinition> inputs) {
1822 if (isNotEmpty(property.getGetInputValues())) {
1823 if (inputs == null || inputs.isEmpty()) {
1824 log.debug("Failed to add property {} to group. Inputs list is empty ", property);
1825 rollbackWithException(ActionStatus.INPUTS_NOT_FOUND, property.getGetInputValues()
1827 .map(GetInputValueDataDefinition::getInputName)
1831 ListIterator<GetInputValueDataDefinition> getInputValuesIter = property.getGetInputValues()
1833 while (getInputValuesIter.hasNext()) {
1834 GetInputValueDataDefinition getInput = getInputValuesIter.next();
1835 Either<InputDefinition, RuntimeException> inputEither = findInputByName(inputs, getInput);
1836 if (inputEither.isRight()) {
1837 throw inputEither.right().value();
1839 InputDefinition input = inputEither.left().value();
1840 getInput.setInputId(input.getUniqueId());
1841 if (getInput.getGetInputIndex() != null) {
1842 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
1843 Either<InputDefinition, RuntimeException> newInputEither = findInputByName(inputs,
1845 if (newInputEither.isRight()) {
1846 throw newInputEither.right().value();
1848 InputDefinition newInput = newInputEither.left().value();
1849 getInputIndex.setInputId(newInput.getUniqueId());
1851 getInputValuesIter.add(getInputIndex);
1858 static <T> Either<T, RuntimeException> rollbackWithEither(
1859 final JanusGraphDao janusGraphDao,
1860 final ActionStatus actionStatus,
1861 final String... params) {
1862 if (janusGraphDao != null)
1863 janusGraphDao.rollback();
1864 return Either.right(new ByActionStatusComponentException(actionStatus, params));
1867 <T> Either<T, RuntimeException> rollbackWithEither(
1868 final ActionStatus actionStatus,
1869 final String... params) {
1870 return rollbackWithEither(janusGraphDao, actionStatus, params);
1873 private Either<InputDefinition, RuntimeException> findInputByName(List<InputDefinition> inputs, GetInputValueDataDefinition getInput) {
1875 final String inputName = getInput != null ? getInput.getInputName() : "";
1877 if(inputs == null || inputs.isEmpty()) {
1878 log.debug("#findInputByName - Inputs list is empty");
1879 return rollbackWithEither(ActionStatus.INPUTS_NOT_FOUND, inputName);
1881 Optional<InputDefinition> inputOpt = inputs.stream()
1882 .filter(p -> p.getName().equals(inputName))
1884 if (!inputOpt.isPresent()) {
1885 log.debug("#findInputByName - Failed to find the input {} ", inputName);
1886 return rollbackWithEither(ActionStatus.INPUTS_NOT_FOUND, inputName);
1888 return Either.left(inputOpt.get());
1893 private void fillGroupsFinalFields(List<GroupDefinition> groupsAsList) {
1894 groupsAsList.forEach(groupDefinition -> {
1895 groupDefinition.setInvariantName(groupDefinition.getName());
1896 groupDefinition.setCreatedFrom(CreatedFrom.CSAR);
1900 private Resource updateGroupsOnResource(Resource resource, Map<String, GroupDefinition> groups) {
1901 if (isEmpty(groups)) {
1904 return updateOrCreateGroups(resource, groups);
1907 private Resource updateOrCreateGroups(Resource resource, Map<String, GroupDefinition> groups) {
1908 List<GroupDefinition> groupsFromResource = resource.getGroups();
1909 List<GroupDefinition> groupsAsList = updateGroupsMembersUsingResource(groups, resource);
1910 List<GroupDefinition> groupsToUpdate = new ArrayList<>();
1911 List<GroupDefinition> groupsToDelete = new ArrayList<>();
1912 List<GroupDefinition> groupsToCreate = new ArrayList<>();
1913 if (isNotEmpty(groupsFromResource)) {
1914 addGroupsToCreateOrUpdate(groupsFromResource, groupsAsList, groupsToUpdate, groupsToCreate);
1915 addGroupsToDelete(groupsFromResource, groupsAsList, groupsToDelete);
1917 groupsToCreate.addAll(groupsAsList);
1919 if (isNotEmpty(groupsToCreate)) {
1920 fillGroupsFinalFields(groupsToCreate);
1921 if (isNotEmpty(groupsFromResource)) {
1922 groupBusinessLogic.addGroups(resource, groupsToCreate, true)
1924 .on(this::throwComponentException);
1926 groupBusinessLogic.createGroups(resource, groupsToCreate, true)
1928 .on(this::throwComponentException);
1931 if (isNotEmpty(groupsToDelete)) {
1932 groupBusinessLogic.deleteGroups(resource, groupsToDelete)
1934 .on(this::throwComponentException);
1936 if (isNotEmpty(groupsToUpdate)) {
1937 groupBusinessLogic.updateGroups(resource, groupsToUpdate, true)
1939 .on(this::throwComponentException);
1945 private void addGroupsToDelete(List<GroupDefinition> groupsFromResource, List<GroupDefinition> groupsAsList,
1946 List<GroupDefinition> groupsToDelete) {
1947 for (GroupDefinition group : groupsFromResource) {
1948 Optional<GroupDefinition> op = groupsAsList.stream()
1949 .filter(p -> p.getInvariantName()
1950 .equalsIgnoreCase(group.getInvariantName()))
1952 if (!op.isPresent() && (group.getArtifacts() == null || group.getArtifacts()
1954 groupsToDelete.add(group);
1959 private void addGroupsToCreateOrUpdate(List<GroupDefinition> groupsFromResource, List<GroupDefinition> groupsAsList,
1960 List<GroupDefinition> groupsToUpdate, List<GroupDefinition> groupsToCreate) {
1961 for (GroupDefinition group : groupsAsList) {
1962 Optional<GroupDefinition> op = groupsFromResource.stream()
1963 .filter(p -> p.getInvariantName()
1964 .equalsIgnoreCase(group.getInvariantName()))
1966 if (op.isPresent()) {
1967 GroupDefinition groupToUpdate = op.get();
1968 groupToUpdate.setMembers(group.getMembers());
1969 groupToUpdate.setCapabilities(group.getCapabilities());
1970 groupToUpdate.setProperties(group.getProperties());
1971 groupsToUpdate.add(groupToUpdate);
1973 groupsToCreate.add(group);
1978 private Resource createInputsOnResource(Resource resource, Map<String, InputDefinition> inputs) {
1979 List<InputDefinition> resourceProperties = resource.getInputs();
1980 if (MapUtils.isNotEmpty(inputs) || isNotEmpty(resourceProperties)) {
1982 Either<List<InputDefinition>, ResponseFormat> createInputs = inputsBusinessLogic.createInputsInGraph(inputs,
1984 if (createInputs.isRight()) {
1985 loggerSupportability.log(LoggerSupportabilityActions.CREATE_INPUTS,resource.getComponentMetadataForSupportLog(),
1986 StatusCode.ERROR,"failed to add inputs from yaml: {}",createInputs.right()
1988 throw new ByResponseFormatComponentException(createInputs.right()
1991 resource.setInputs(createInputs.left().value());
1996 private List<GroupDefinition> updateGroupsMembersUsingResource(Map<String, GroupDefinition> groups,
1997 Resource component) {
1999 List<GroupDefinition> result = new ArrayList<>();
2000 List<ComponentInstance> componentInstances = component.getComponentInstances();
2002 if (groups != null) {
2003 Either<Boolean, ResponseFormat> validateCyclicGroupsDependencies = validateCyclicGroupsDependencies(groups);
2004 if (validateCyclicGroupsDependencies.isRight()) {
2005 throw new ByResponseFormatComponentException(validateCyclicGroupsDependencies.right().value());
2007 for (Entry<String, GroupDefinition> entry : groups.entrySet()) {
2008 String groupName = entry.getKey();
2009 GroupDefinition groupDefinition = entry.getValue();
2010 GroupDefinition updatedGroupDefinition = new GroupDefinition(groupDefinition);
2011 updatedGroupDefinition.setMembers(null);
2012 Map<String, String> members = groupDefinition.getMembers();
2013 if (members != null) {
2014 updateGroupMembers(groups, updatedGroupDefinition, component, componentInstances, groupName,
2017 result.add(updatedGroupDefinition);
2023 private void updateGroupMembers(Map<String, GroupDefinition> groups, GroupDefinition updatedGroupDefinition,
2024 Resource component, List<ComponentInstance> componentInstances, String groupName,
2025 Map<String, String> members) {
2026 Set<String> compInstancesNames = members.keySet();
2028 if (CollectionUtils.isEmpty(componentInstances)) {
2029 String membersAstString = compInstancesNames.stream()
2030 .collect(joining(","));
2032 "The members: {}, in group: {}, cannot be found in component {}. There are no component instances.",
2033 membersAstString, groupName, component.getNormalizedName());
2034 throw new ByActionStatusComponentException(
2035 ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString,
2036 groupName, component.getNormalizedName(), getComponentTypeForResponse(component));
2038 // Find all component instances with the member names
2039 Map<String, String> memberNames = componentInstances.stream()
2040 .collect(toMap(ComponentInstance::getName, ComponentInstance::getUniqueId));
2041 memberNames.putAll(groups.keySet()
2043 .collect(toMap(g -> g, g -> "")));
2044 Map<String, String> relevantInstances = memberNames.entrySet()
2046 .filter(n -> compInstancesNames.contains(n.getKey()))
2047 .collect(toMap(Entry::getKey, Entry::getValue));
2049 if (relevantInstances == null || relevantInstances.size() != compInstancesNames.size()) {
2051 List<String> foundMembers = new ArrayList<>();
2052 if (relevantInstances != null) {
2053 foundMembers = relevantInstances.keySet()
2057 compInstancesNames.removeAll(foundMembers);
2058 String membersAstString = compInstancesNames.stream()
2059 .collect(joining(","));
2060 log.debug("The members: {}, in group: {}, cannot be found in component: {}", membersAstString, groupName,
2061 component.getNormalizedName());
2062 throw new ByActionStatusComponentException(
2063 ActionStatus.GROUP_INVALID_COMPONENT_INSTANCE, membersAstString,
2064 groupName, component.getNormalizedName(), getComponentTypeForResponse(component));
2066 updatedGroupDefinition.setMembers(relevantInstances);
2070 * This Method validates that there is no cyclic group dependencies. meaning
2071 * group A as member in group B which is member in group A
2076 private Either<Boolean, ResponseFormat> validateCyclicGroupsDependencies(Map<String, GroupDefinition> allGroups) {
2078 Either<Boolean, ResponseFormat> result = Either.left(true);
2080 Iterator<Entry<String, GroupDefinition>> allGroupsItr = allGroups.entrySet()
2082 while (allGroupsItr.hasNext() && result.isLeft()) {
2083 Entry<String, GroupDefinition> groupAEntry = allGroupsItr.next();
2084 // Fetches a group member A
2085 String groupAName = groupAEntry.getKey();
2086 // Finds all group members in group A
2087 Set<String> allGroupAMembersNames = new HashSet<>();
2088 fillAllGroupMemebersRecursivly(groupAEntry.getKey(), allGroups, allGroupAMembersNames);
2089 // If A is a group member of itself found cyclic dependency
2090 if (allGroupAMembersNames.contains(groupAName)) {
2091 ResponseFormat responseFormat = componentsUtils
2092 .getResponseFormat(ActionStatus.GROUP_HAS_CYCLIC_DEPENDENCY, groupAName);
2093 result = Either.right(responseFormat);
2096 } catch (Exception e) {
2097 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
2098 result = Either.right(responseFormat);
2099 log.debug("Exception occurred when validateCyclicGroupsDependencies, error is:{}", e.getMessage(), e);
2105 * This Method fills recursively the set groupMembers with all the members
2106 * of the given group which are also of type group.
2110 * @param allGroupMembers
2113 private void fillAllGroupMemebersRecursivly(String groupName, Map<String, GroupDefinition> allGroups,
2114 Set<String> allGroupMembers) {
2116 // Found Cyclic dependency
2117 if (isfillGroupMemebersRecursivlyStopCondition(groupName, allGroups, allGroupMembers)) {
2120 GroupDefinition groupDefinition = allGroups.get(groupName);
2121 // All Members Of Current Group Resource Instances & Other Groups
2122 Set<String> currGroupMembers = groupDefinition.getMembers()
2124 // Filtered Members Of Current Group containing only members which
2126 List<String> currGroupFilteredMembers = currGroupMembers.stream()
2128 // Keep Only Elements of type group and not Resource Instances
2129 filter(allGroups::containsKey)
2131 // Add Filtered Elements to main Set
2132 peek(allGroupMembers::add)
2137 // Recursively call the method for all the filtered group members
2138 for (String innerGroupName : currGroupFilteredMembers) {
2139 fillAllGroupMemebersRecursivly(innerGroupName, allGroups, allGroupMembers);
2144 private boolean isfillGroupMemebersRecursivlyStopCondition(String groupName, Map<String, GroupDefinition> allGroups,
2145 Set<String> allGroupMembers) {
2147 boolean stop = false;
2148 // In Case Not Group Stop
2149 if (!allGroups.containsKey(groupName)) {
2152 // In Case Group Has no members stop
2154 GroupDefinition groupDefinition = allGroups.get(groupName);
2155 stop = isEmpty(groupDefinition.getMembers());
2158 // In Case all group members already contained stop
2160 final Set<String> allMembers = allGroups.get(groupName)
2163 Set<String> membersOfTypeGroup = allMembers.stream()
2165 // Filter In Only Group members
2166 filter(allGroups::containsKey)
2170 stop = allGroupMembers.containsAll(membersOfTypeGroup);
2175 private Resource createRIAndRelationsFromYaml(String yamlName, Resource resource,
2176 Map<String, UploadComponentInstanceInfo> uploadComponentInstanceInfoMap, String topologyTemplateYaml,
2177 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo,
2179 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToCreate,
2182 log.debug("************* Going to create all nodes {}", yamlName);
2183 handleNodeTypes(yamlName, resource, topologyTemplateYaml, false, nodeTypesArtifactsToCreate,
2184 nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo, nodeName);
2185 log.debug("************* Finished to create all nodes {}", yamlName);
2186 log.debug("************* Going to create all resource instances {}", yamlName);
2187 Map<String, Resource> existingNodeTypesByResourceNames = new HashMap<>();
2188 resource = createResourceInstances(yamlName, resource, null, uploadComponentInstanceInfoMap,
2189 csarInfo.getCreatedNodes(), existingNodeTypesByResourceNames);
2190 log.debug("************* Finished to create all resource instances {}", yamlName);
2191 log.debug("************* Going to create all relations {}", yamlName);
2192 resource = createResourceInstancesRelations(csarInfo.getModifier(), yamlName, resource, null, uploadComponentInstanceInfoMap, existingNodeTypesByResourceNames);
2193 log.debug("************* Finished to create all relations {}", yamlName);
2194 log.debug("************* Going to create positions {}", yamlName);
2195 compositionBusinessLogic.setPositionsForComponentInstances(resource, csarInfo.getModifier()
2197 log.debug("************* Finished to set positions {}", yamlName);
2201 private void handleAndAddExtractedVfcsArtifacts(List<ArtifactDefinition> vfcArtifacts,
2202 List<ArtifactDefinition> artifactsToAdd) {
2203 List<String> vfcArtifactNames = vfcArtifacts.stream()
2204 .map(ArtifactDataDefinition::getArtifactName)
2206 artifactsToAdd.stream()
2208 if (!vfcArtifactNames.contains(a.getArtifactName())) {
2209 vfcArtifacts.add(a);
2211 log.debug("Can't upload two artifact with the same name {}. ", a.getArtifactName());
2217 @SuppressWarnings("unchecked")
2218 private void handleNodeTypes(String yamlName, Resource resource, String topologyTemplateYaml, boolean needLock,
2219 Map<String, EnumMap<ArtifactOperationEnum, List<ArtifactDefinition>>> nodeTypesArtifactsToHandle,
2220 List<ArtifactDefinition> nodeTypesNewCreatedArtifacts, Map<String, NodeTypeInfo> nodeTypesInfo,
2221 CsarInfo csarInfo, String nodeName) {
2223 for (Entry<String, NodeTypeInfo> nodeTypeEntry : nodeTypesInfo.entrySet()) {
2224 if (nodeTypeEntry.getValue()
2227 handleNestedVfc(resource, nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo,
2228 csarInfo, nodeTypeEntry.getKey());
2229 log.trace("************* finished to create node {}", nodeTypeEntry.getKey());
2232 Map<String, Object> mappedToscaTemplate = null;
2233 if (StringUtils.isNotEmpty(nodeName) && isNotEmpty(nodeTypesInfo) && nodeTypesInfo.containsKey(nodeName)) {
2234 mappedToscaTemplate = nodeTypesInfo.get(nodeName)
2235 .getMappedToscaTemplate();
2237 if (isEmpty(mappedToscaTemplate)) {
2238 mappedToscaTemplate = (Map<String, Object>) new Yaml().load(topologyTemplateYaml);
2240 createResourcesFromYamlNodeTypesList(yamlName, resource, mappedToscaTemplate, needLock,
2241 nodeTypesArtifactsToHandle, nodeTypesNewCreatedArtifacts, nodeTypesInfo, csarInfo);
2242 } catch (ComponentException e) {
2243 ResponseFormat responseFormat = e.getResponseFormat() != null ? e.getResponseFormat()
2244 : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams());
2245 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource,
2246 AuditingActionEnum.IMPORT_RESOURCE);
2248 } catch (StorageException e) {
2249 ResponseFormat responseFormat = componentsUtils
2250 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
2251 componentsUtils.auditResource(responseFormat, csarInfo.getModifier(), resource,
2252 AuditingActionEnum.IMPORT_RESOURCE);
2257 private Either<Resource, ResponseFormat> handleVfCsarArtifacts(Resource resource, CsarInfo csarInfo,
2258 List<ArtifactDefinition> createdArtifacts, ArtifactOperationInfo artifactOperation, boolean shouldLock,
2259 boolean inTransaction) {
2261 if (csarInfo.getCsar() != null) {
2262 String vendorLicenseModelId = null;
2263 String vfLicenseModelId = null;
2265 if (artifactOperation.isUpdate()) {
2266 Map<String, ArtifactDefinition> deploymentArtifactsMap = resource.getDeploymentArtifacts();
2267 if (deploymentArtifactsMap != null && !deploymentArtifactsMap.isEmpty()) {
2268 for (Entry<String, ArtifactDefinition> artifactEntry : deploymentArtifactsMap.entrySet()) {
2269 if (artifactEntry.getValue()
2271 .equalsIgnoreCase(Constants.VENDOR_LICENSE_MODEL)) {
2272 vendorLicenseModelId = artifactEntry.getValue()
2275 if (artifactEntry.getValue()
2277 .equalsIgnoreCase(Constants.VF_LICENSE_MODEL)) {
2278 vfLicenseModelId = artifactEntry.getValue()
2285 // Specific Behavior for license artifacts
2286 createOrUpdateSingleNonMetaArtifact(resource, csarInfo,
2287 CsarUtils.ARTIFACTS_PATH + Constants.VENDOR_LICENSE_MODEL, Constants.VENDOR_LICENSE_MODEL,
2288 ArtifactTypeEnum.VENDOR_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT,
2289 Constants.VENDOR_LICENSE_LABEL, Constants.VENDOR_LICENSE_DISPLAY_NAME,
2290 Constants.VENDOR_LICENSE_DESCRIPTION, vendorLicenseModelId, artifactOperation, null, true,
2291 shouldLock, inTransaction);
2292 createOrUpdateSingleNonMetaArtifact(resource, csarInfo,
2293 CsarUtils.ARTIFACTS_PATH + Constants.VF_LICENSE_MODEL, Constants.VF_LICENSE_MODEL,
2294 ArtifactTypeEnum.VF_LICENSE.getType(), ArtifactGroupTypeEnum.DEPLOYMENT, Constants.VF_LICENSE_LABEL,
2295 Constants.VF_LICENSE_DISPLAY_NAME, Constants.VF_LICENSE_DESCRIPTION, vfLicenseModelId,
2296 artifactOperation, null, true, shouldLock, inTransaction);
2298 Either<Resource, ResponseFormat> eitherCreateResult = createOrUpdateNonMetaArtifacts(csarInfo, resource,
2299 createdArtifacts, shouldLock, inTransaction, artifactOperation);
2300 if (eitherCreateResult.isRight()) {
2301 return Either.right(eitherCreateResult.right()
2305 Either<ImmutablePair<String, String>, ResponseFormat> artifacsMetaCsarStatus = CsarValidationUtils
2306 .getArtifactsMeta(csarInfo.getCsar(), csarInfo.getCsarUUID(), componentsUtils);
2308 if (artifacsMetaCsarStatus.isLeft()) {
2309 String artifactsFileName = artifacsMetaCsarStatus.left()
2312 String artifactsContents = artifacsMetaCsarStatus.left()
2315 Either<Resource, ResponseFormat> createArtifactsFromCsar;
2316 if (artifactOperation.isCreateOrLink()) {
2317 createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic.createResourceArtifactsFromCsar(
2318 csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts);
2320 createArtifactsFromCsar = csarArtifactsAndGroupsBusinessLogic.updateResourceArtifactsFromCsar(
2321 csarInfo, resource, artifactsContents, artifactsFileName, createdArtifacts, shouldLock,
2325 if (createArtifactsFromCsar.isRight()) {
2326 log.debug("Couldn't create artifacts from artifacts.meta");
2327 return Either.right(createArtifactsFromCsar.right()
2331 return Either.left(createArtifactsFromCsar.left()
2335 return csarArtifactsAndGroupsBusinessLogic.deleteVFModules(resource, csarInfo, shouldLock,
2340 return Either.left(resource);
2343 private Either<Boolean, ResponseFormat> createOrUpdateSingleNonMetaArtifact(Resource resource, CsarInfo csarInfo,
2344 String artifactPath, String artifactFileName, String artifactType, ArtifactGroupTypeEnum artifactGroupType,
2345 String artifactLabel, String artifactDisplayName, String artifactDescription, String artifactId,
2346 ArtifactOperationInfo operation, List<ArtifactDefinition> createdArtifacts, boolean isFromCsar,
2347 boolean shouldLock, boolean inTransaction) {
2348 byte[] artifactFileBytes = null;
2350 if (csarInfo.getCsar()
2351 .containsKey(artifactPath)) {
2352 artifactFileBytes = csarInfo.getCsar()
2355 Either<Boolean, ResponseFormat> result = Either.left(true);
2356 if (operation.isUpdate() || operation.isDelete()) {
2357 if (isArtifactDeletionRequired(artifactId, artifactFileBytes, isFromCsar)) {
2358 Either<ArtifactDefinition, ResponseFormat> handleDelete = artifactsBusinessLogic
2359 .handleDelete(resource.getUniqueId(), artifactId, csarInfo.getModifier(),
2360 resource, shouldLock,
2362 if (handleDelete.isRight()) {
2363 result = Either.right(handleDelete.right()
2366 ArtifactDefinition value = handleDelete.left().value();
2367 String updatedArtifactId = value.getUniqueId();
2368 if (artifactGroupType == ArtifactGroupTypeEnum.DEPLOYMENT) {
2369 resource.getDeploymentArtifacts().remove(updatedArtifactId);
2371 resource.getArtifacts().remove(updatedArtifactId);
2377 if (StringUtils.isEmpty(artifactId) && artifactFileBytes != null) {
2378 operation = new ArtifactOperationInfo(false, false,
2379 ArtifactOperationEnum.CREATE);
2383 if (artifactFileBytes != null) {
2384 Map<String, Object> vendorLicenseModelJson = ArtifactUtils.buildJsonForUpdateArtifact(artifactId,
2385 artifactFileName, artifactType, artifactGroupType, artifactLabel, artifactDisplayName,
2386 artifactDescription, artifactFileBytes, null, isFromCsar);
2387 Either<Either<ArtifactDefinition, Operation>, ResponseFormat> eitherNonMetaArtifacts = csarArtifactsAndGroupsBusinessLogic
2388 .createOrUpdateCsarArtifactFromJson(resource, csarInfo.getModifier(), vendorLicenseModelJson,
2390 addNonMetaCreatedArtifactsToSupportRollback(operation, createdArtifacts, eitherNonMetaArtifacts);
2391 if (eitherNonMetaArtifacts.isRight()) {
2392 BeEcompErrorManager.getInstance()
2393 .logInternalFlowError("UploadLicenseArtifact", "Failed to upload license artifact: "
2394 + artifactFileName + "With csar uuid: " + csarInfo.getCsarUUID(),
2395 ErrorSeverity.WARNING);
2396 return Either.right(eitherNonMetaArtifacts.right()
2399 ArtifactDefinition artifactDefinition = eitherNonMetaArtifacts.left().value().left().value();
2400 createOrUpdateResourceWithUpdatedArtifact(artifactDefinition,resource, artifactGroupType);
2406 private void createOrUpdateResourceWithUpdatedArtifact(ArtifactDefinition artifact, Resource resource, ArtifactGroupTypeEnum groupTypeEnum) {
2407 if (groupTypeEnum == ArtifactGroupTypeEnum.DEPLOYMENT) {
2408 resource.getDeploymentArtifacts().put(artifact.getArtifactLabel(), artifact);
2410 resource.getArtifacts().put(artifact.getArtifactLabel(), artifact);
2414 private boolean isArtifactDeletionRequired(String artifactId, byte[] artifactFileBytes, boolean isFromCsar) {
2415 return !StringUtils.isEmpty(artifactId) && artifactFileBytes == null && isFromCsar;
2418 private void addNonMetaCreatedArtifactsToSupportRollback(ArtifactOperationInfo operation,
2419 List<ArtifactDefinition> createdArtifacts,
2420 Either<Either<ArtifactDefinition, Operation>, ResponseFormat> eitherNonMetaArtifacts) {
2421 if (operation.isCreateOrLink() && createdArtifacts != null
2422 && eitherNonMetaArtifacts.isLeft()) {
2423 Either<ArtifactDefinition, Operation> eitherResult = eitherNonMetaArtifacts.left()
2425 if (eitherResult.isLeft()) {
2426 createdArtifacts.add(eitherResult.left()
2432 private Either<Resource, ResponseFormat> createOrUpdateNonMetaArtifacts(CsarInfo csarInfo, Resource resource,
2433 List<ArtifactDefinition> createdArtifacts, boolean shouldLock, boolean inTransaction,
2434 ArtifactOperationInfo artifactOperation) {
2436 Either<Resource, ResponseFormat> resStatus = null;
2437 Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
2440 Either<List<NonMetaArtifactInfo>, String> artifactPathAndNameList = getValidArtifactNames(csarInfo,
2441 collectedWarningMessages);
2442 if (artifactPathAndNameList.isRight()) {
2443 return Either.right(getComponentsUtils().getResponseFormatByArtifactId(
2444 ActionStatus.ARTIFACT_NAME_INVALID, artifactPathAndNameList.right()
2447 EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>> vfCsarArtifactsToHandle = null;
2449 if (artifactOperation.isCreateOrLink()) {
2450 vfCsarArtifactsToHandle = new EnumMap<>(ArtifactOperationEnum.class);
2451 vfCsarArtifactsToHandle.put(artifactOperation.getArtifactOperationEnum(), artifactPathAndNameList.left()
2454 Either<EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandleRes = findVfCsarArtifactsToHandle(
2455 resource, artifactPathAndNameList.left()
2457 csarInfo.getModifier());
2459 if (findVfCsarArtifactsToHandleRes.isRight()) {
2460 resStatus = Either.right(findVfCsarArtifactsToHandleRes.right()
2463 if (resStatus == null) {
2464 vfCsarArtifactsToHandle = findVfCsarArtifactsToHandleRes.left()
2468 if (resStatus == null && vfCsarArtifactsToHandle != null) {
2469 resStatus = processCsarArtifacts(csarInfo, resource, createdArtifacts, shouldLock, inTransaction,
2470 resStatus, vfCsarArtifactsToHandle);
2472 if (resStatus == null) {
2473 resStatus = Either.left(resource);
2475 } catch (Exception e) {
2476 resStatus = Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
2477 log.debug("Exception occurred in createNonMetaArtifacts, message:{}", e.getMessage(), e);
2479 CsarUtils.handleWarningMessages(collectedWarningMessages);
2484 private Either<Resource, ResponseFormat> processCsarArtifacts(CsarInfo csarInfo, Resource resource,
2485 List<ArtifactDefinition> createdArtifacts, boolean shouldLock, boolean inTransaction,
2486 Either<Resource, ResponseFormat> resStatus,
2487 EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>> vfCsarArtifactsToHandle) {
2488 for (Entry<ArtifactOperationEnum, List<NonMetaArtifactInfo>> currArtifactOperationPair : vfCsarArtifactsToHandle
2491 Optional<ResponseFormat> optionalCreateInDBError =
2492 // Stream of artifacts to be created
2493 currArtifactOperationPair.getValue()
2495 // create each artifact
2496 .map(e -> createOrUpdateSingleNonMetaArtifact(resource, csarInfo, e.getPath(),
2497 e.getArtifactName(), e.getArtifactType(),
2498 e.getArtifactGroupType(), e.getArtifactLabel(), e.getDisplayName(),
2499 CsarUtils.ARTIFACT_CREATED_FROM_CSAR, e.getArtifactUniqueId(),
2500 new ArtifactOperationInfo(false, false,
2501 currArtifactOperationPair.getKey()),
2502 createdArtifacts, e.isFromCsar(), shouldLock, inTransaction))
2503 // filter in only error
2504 .filter(Either::isRight)
2506 // Convert the error from either to
2511 // Check if an error occurred
2513 // Error found on artifact Creation
2514 if (optionalCreateInDBError.isPresent()) {
2515 resStatus = Either.right(optionalCreateInDBError.get());
2522 private Either<List<NonMetaArtifactInfo>, String> getValidArtifactNames(CsarInfo csarInfo,
2523 Map<String, Set<List<String>>> collectedWarningMessages) {
2524 List<NonMetaArtifactInfo> artifactPathAndNameList =
2525 // Stream of file paths contained in csar
2529 // Filter in only VF artifact path location
2530 .filter(e -> Pattern.compile(VF_NODE_TYPE_ARTIFACTS_PATH_PATTERN)
2531 .matcher(e.getKey())
2533 // Validate and add warnings
2534 .map(e -> CsarUtils.validateNonMetaArtifact(e.getKey(), e.getValue(), collectedWarningMessages))
2535 // Filter in Non Warnings
2536 .filter(Either::isLeft)
2537 // Convert from Either to NonMetaArtifactInfo
2542 Pattern englishNumbersAndUnderScoresOnly = Pattern.compile(CsarUtils.VALID_ENGLISH_ARTIFACT_NAME);
2543 for (NonMetaArtifactInfo nonMetaArtifactInfo : artifactPathAndNameList) {
2544 if (!englishNumbersAndUnderScoresOnly.matcher(nonMetaArtifactInfo.getDisplayName())
2546 return Either.right(nonMetaArtifactInfo.getArtifactName());
2549 return Either.left(artifactPathAndNameList);
2552 private Either<EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>>, ResponseFormat> findVfCsarArtifactsToHandle(
2553 Resource resource, List<NonMetaArtifactInfo> artifactPathAndNameList, User user) {
2555 List<ArtifactDefinition> existingArtifacts = new ArrayList<>();
2556 // collect all Deployment and Informational artifacts of VF
2557 if (resource.getDeploymentArtifacts() != null && !resource.getDeploymentArtifacts()
2559 existingArtifacts.addAll(resource.getDeploymentArtifacts()
2562 if (resource.getArtifacts() != null && !resource.getArtifacts()
2564 existingArtifacts.addAll(resource.getArtifacts()
2567 existingArtifacts = existingArtifacts.stream()
2568 // filter MANDATORY artifacts, LICENSE artifacts and artifacts
2569 // was created from HEAT.meta
2570 .filter(this::isNonMetaArtifact)
2573 List<String> artifactsToIgnore = new ArrayList<>();
2574 // collect IDs of Artifacts of VF which belongs to any group
2575 if (resource.getGroups() != null) {
2576 resource.getGroups()
2579 if (g.getArtifacts() != null && !g.getArtifacts()
2581 artifactsToIgnore.addAll(g.getArtifacts());
2585 existingArtifacts = existingArtifacts.stream()
2586 // filter artifacts which belongs to any group
2587 .filter(a -> !artifactsToIgnore.contains(a.getUniqueId()))
2589 return organizeVfCsarArtifactsByArtifactOperation(artifactPathAndNameList, existingArtifacts, resource, user);
2592 private boolean isNonMetaArtifact(ArtifactDefinition artifact) {
2593 boolean result = true;
2594 if (artifact.getMandatory() || artifact.getArtifactName() == null || !isValidArtifactType(artifact)) {
2600 private boolean isValidArtifactType(ArtifactDefinition artifact) {
2601 boolean result = true;
2602 if (artifact.getArtifactType() == null
2603 || ArtifactTypeEnum.parse(artifact.getArtifactType()) == ArtifactTypeEnum.VENDOR_LICENSE
2604 || ArtifactTypeEnum.parse(artifact.getArtifactType()) == ArtifactTypeEnum.VF_LICENSE) {
2610 private Resource createResourceInstancesRelations(User user, String yamlName, Resource resource, Resource oldResource,
2611 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap, Map<String, Resource> existingNodeTypesByResourceNames) {
2612 log.debug("#createResourceInstancesRelations - Going to create relations ");
2613 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(), StatusCode.STARTED,"Start to create relations");
2614 List<ComponentInstance> componentInstancesList = resource.getComponentInstances();
2615 if (isEmpty(uploadResInstancesMap) || CollectionUtils.isEmpty(componentInstancesList) &&
2616 resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances {
2618 "#createResourceInstancesRelations - No instances found in the resource {} is empty, yaml template file name {}, ",
2619 resource.getUniqueId(), yamlName);
2620 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(), StatusCode.ERROR,"No instances found in the resource: {}, is empty, yaml template file name: {}",resource.getName(),yamlName);
2621 BeEcompErrorManager.getInstance()
2622 .logInternalDataError("createResourceInstancesRelations",
2623 "No instances found in a resource or nn yaml template. ", ErrorSeverity.ERROR);
2624 throw new ByActionStatusComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2626 Map<String, List<ComponentInstanceProperty>> instProperties = new HashMap<>();
2627 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities = new HashMap<>();
2628 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements = new HashMap<>();
2629 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts = new HashMap<>();
2630 Map<String, Map<String, ArtifactDefinition>> instArtifacts = new HashMap<>();
2631 Map<String, List<AttributeDataDefinition>> instAttributes = new HashMap<>();
2632 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
2633 Map<String, List<ComponentInstanceInput>> instInputs = new HashMap<>();
2635 log.debug("#createResourceInstancesRelations - Before get all datatypes. ");
2636 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes = dataTypeCache.getAll();
2637 if (allDataTypes.isRight()) {
2638 JanusGraphOperationStatus status = allDataTypes.right()
2640 BeEcompErrorManager.getInstance()
2641 .logInternalFlowError("UpdatePropertyValueOnComponentInstance",
2642 "Failed to update property value on instance. Status is " + status, ErrorSeverity.ERROR);
2643 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(),
2644 StatusCode.ERROR,"ERROR while update property value on instance. Status is: "+status);
2645 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(
2646 DaoStatusConverter.convertJanusGraphStatusToStorageStatus(status)), yamlName);
2649 Resource finalResource = resource;
2650 uploadResInstancesMap.values()
2651 .forEach(i -> processComponentInstance(yamlName, finalResource, componentInstancesList, allDataTypes,
2652 instProperties, instCapabilities, instRequirements, instDeploymentArtifacts, instArtifacts,
2653 instAttributes, existingNodeTypesByResourceNames, instInputs, i));
2654 resource.getComponentInstances()
2656 .filter(i -> !i.isCreatedFromCsar())
2657 .forEach(i->processUiComponentInstance(oldResource, i, instCapabilities, instRequirements, instDeploymentArtifacts, instArtifacts, instProperties, instInputs, instAttributes));
2659 associateComponentInstancePropertiesToComponent(yamlName, resource, instProperties);
2660 associateComponentInstanceInputsToComponent(yamlName, resource, instInputs);
2661 associateDeploymentArtifactsToInstances(user, yamlName, resource, instDeploymentArtifacts);
2662 associateArtifactsToInstances(yamlName, resource, instArtifacts);
2663 associateOrAddCalculatedCapReq(yamlName, resource, instCapabilities, instRequirements);
2664 associateInstAttributeToComponentToInstances(yamlName, resource, instAttributes);
2665 addRelationsToRI(yamlName, resource, uploadResInstancesMap, componentInstancesList, relations);
2666 associateResourceInstances(yamlName, resource, relations);
2667 handleSubstitutionMappings(resource, uploadResInstancesMap);
2668 log.debug("************* in create relations, getResource start");
2669 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(), StatusCode.COMPLETE,"create relations");
2670 Either<Resource, StorageOperationStatus> eitherGetResource = toscaOperationFacade
2671 .getToscaFullElement(resource.getUniqueId());
2672 log.debug("************* in create relations, getResource end");
2673 if (eitherGetResource.isRight()) {
2674 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(),
2675 StatusCode.ERROR,"ERROR while create relations");
2676 throw new ByResponseFormatComponentException(componentsUtils
2677 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(eitherGetResource.right()
2678 .value()), resource));
2680 return eitherGetResource.left()
2684 private void processUiComponentInstance(Resource oldResource, ComponentInstance instance,
2685 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities,
2686 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements,
2687 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts,
2688 Map<String, Map<String, ArtifactDefinition>> instArtifacts, Map<String,
2689 List<ComponentInstanceProperty>> instProperties, Map<String,
2690 List<ComponentInstanceInput>> instInputs,
2691 Map<String, List<AttributeDataDefinition>> instAttributes) {
2692 Optional<ComponentInstance> foundInstance = findInstance(oldResource, instance);
2693 if (foundInstance.isPresent()) {
2694 if (MapUtils.isNotEmpty(foundInstance.get().getCapabilities())) {
2695 instCapabilities.put(instance, foundInstance.get().getCapabilities());
2697 if (MapUtils.isNotEmpty(foundInstance.get().getRequirements())) {
2698 instRequirements.put(instance, foundInstance.get().getRequirements());
2700 if (MapUtils.isNotEmpty(foundInstance.get().getDeploymentArtifacts())) {
2701 instDeploymentArtifacts.put(instance.getUniqueId(), foundInstance.get().getDeploymentArtifacts());
2703 if(MapUtils.isNotEmpty(foundInstance.get().getArtifacts())){
2704 instArtifacts.put(instance.getUniqueId(), foundInstance.get().getArtifacts());
2706 if (MapUtils.isNotEmpty(oldResource.getComponentInstancesProperties()) &&
2708 .isNotEmpty(oldResource.getComponentInstancesProperties().get(foundInstance.get().getUniqueId()))) {
2709 instProperties.put(instance.getUniqueId(),
2710 oldResource.getComponentInstancesProperties().get(foundInstance.get().getUniqueId()));
2712 if (MapUtils.isNotEmpty(oldResource.getComponentInstancesInputs()) &&
2714 .isNotEmpty(oldResource.getComponentInstancesInputs().get(foundInstance.get().getUniqueId()))) {
2715 instInputs.put(instance.getUniqueId(),
2716 oldResource.getComponentInstancesInputs().get(foundInstance.get().getUniqueId()));
2718 if(MapUtils.isNotEmpty(oldResource.getComponentInstancesAttributes()) &&
2719 CollectionUtils.isNotEmpty(oldResource.getComponentInstancesAttributes().get(foundInstance.get().getUniqueId()))){
2720 instAttributes.put(instance.getUniqueId(), oldResource.getComponentInstancesAttributes().get(foundInstance.get().getUniqueId()).stream().map(AttributeDefinition::new).collect(toList()));
2725 private Optional<ComponentInstance> findInstance(Resource oldResource, ComponentInstance instance) {
2726 if(oldResource != null && CollectionUtils.isNotEmpty(oldResource.getComponentInstances())) {
2727 return oldResource.getComponentInstances().stream().filter(i -> i.getName().equals(instance.getName())).findFirst();
2729 return Optional.empty();
2732 private void associateResourceInstances(String yamlName, Resource resource,
2733 List<RequirementCapabilityRelDef> relations) {
2734 Either<List<RequirementCapabilityRelDef>, StorageOperationStatus> relationsEither = toscaOperationFacade.associateResourceInstances(resource, resource.getUniqueId(), relations);
2736 if (relationsEither.isRight() && relationsEither.right().value() != StorageOperationStatus.NOT_FOUND) {
2737 StorageOperationStatus status = relationsEither.right().value();
2738 log.debug("failed to associate instances of resource {} status is {}", resource.getUniqueId(),
2740 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(status), yamlName);
2742 setResourceInstanceRelationsOnComponent(resource, relationsEither.left().value());
2746 private void associateInstAttributeToComponentToInstances(String yamlName, Resource resource,
2747 Map<String, List<AttributeDataDefinition>> instAttributes) {
2748 StorageOperationStatus addArtToInst;
2749 addArtToInst = toscaOperationFacade.associateInstAttributeToComponentToInstances(instAttributes,
2751 if (addArtToInst != StorageOperationStatus.OK && addArtToInst != StorageOperationStatus.NOT_FOUND) {
2752 log.debug("failed to associate attributes of resource {} status is {}", resource.getUniqueId(),
2754 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(addArtToInst),
2759 private void associateOrAddCalculatedCapReq(String yamlName, Resource resource,
2760 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilities,
2761 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements) {
2762 StorageOperationStatus addArtToInst;
2763 addArtToInst = toscaOperationFacade.associateOrAddCalculatedCapReq(instCapabilities, instRequirements,
2765 if (addArtToInst != StorageOperationStatus.OK && addArtToInst != StorageOperationStatus.NOT_FOUND) {
2766 log.debug("failed to associate cap and req of resource {} status is {}", resource.getUniqueId(),
2768 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(addArtToInst), yamlName);
2772 private void associateArtifactsToInstances(String yamlName, Resource resource,
2773 Map<String, Map<String, ArtifactDefinition>> instArtifacts) {
2774 StorageOperationStatus addArtToInst;
2776 addArtToInst = toscaOperationFacade.associateArtifactsToInstances(instArtifacts, resource);
2777 if (addArtToInst != StorageOperationStatus.OK && addArtToInst != StorageOperationStatus.NOT_FOUND) {
2778 log.debug("failed to associate artifact of resource {} status is {}", resource.getUniqueId(), addArtToInst);
2779 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(addArtToInst), yamlName);
2783 private void associateDeploymentArtifactsToInstances(User user, String yamlName, Resource resource,
2784 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts) {
2785 StorageOperationStatus addArtToInst = toscaOperationFacade
2786 .associateDeploymentArtifactsToInstances(instDeploymentArtifacts, resource, user);
2787 if (addArtToInst != StorageOperationStatus.OK && addArtToInst != StorageOperationStatus.NOT_FOUND) {
2788 log.debug("failed to associate artifact of resource {} status is {}", resource.getUniqueId(), addArtToInst);
2789 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(addArtToInst), yamlName);
2793 private void associateComponentInstanceInputsToComponent(String yamlName, Resource resource,
2794 Map<String, List<ComponentInstanceInput>> instInputs) {
2795 if (MapUtils.isNotEmpty(instInputs)) {
2796 Either<Map<String, List<ComponentInstanceInput>>, StorageOperationStatus> addInputToInst = toscaOperationFacade
2797 .associateComponentInstanceInputsToComponent(instInputs, resource.getUniqueId());
2798 if (addInputToInst.isRight()) {
2800 StorageOperationStatus addInputToInstError = addInputToInst.right().value();
2801 log.debug("failed to associate inputs value of resource {} status is {}", resource.getUniqueId(),
2802 addInputToInstError);
2803 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(addInputToInstError), yamlName);
2805 setComponentInstanceInputsOnComponent(resource, instInputs);
2809 private void setComponentInstanceInputsOnComponent(Resource resource, Map<String, List<ComponentInstanceInput>> instInputs) {
2810 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = resource.getComponentInstancesInputs();
2811 if (componentInstancesInputs == null)
2812 componentInstancesInputs = new HashMap<>();
2813 componentInstancesInputs.putAll(instInputs);
2814 resource.setComponentInstancesInputs(componentInstancesInputs);
2817 private void associateComponentInstancePropertiesToComponent(String yamlName, Resource resource,
2818 Map<String, List<ComponentInstanceProperty>> instProperties) {
2819 Either<Map<String, List<ComponentInstanceProperty>>, StorageOperationStatus> addPropToInst = toscaOperationFacade
2820 .associateComponentInstancePropertiesToComponent(instProperties, resource.getUniqueId());
2821 if (addPropToInst.isRight()) {
2822 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(),
2823 StatusCode.ERROR,"ERROR while associate compnent insatnce properties of resource: {} status is: {}",resource.getName(),addPropToInst.right().value());
2824 StorageOperationStatus storageOperationStatus = addPropToInst.right().value();
2825 log.debug("failed to associate properties of resource {} status is {}", resource.getUniqueId(),
2826 storageOperationStatus);
2827 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(storageOperationStatus), yamlName);
2829 setComponentInstancePropertiesOnComponent(resource, instProperties);
2832 private void setComponentInstancePropertiesOnComponent(Resource resource, Map<String, List<ComponentInstanceProperty>> instProperties) {
2833 Map<String, List<ComponentInstanceProperty>> componentInstanceProps = resource.getComponentInstancesProperties();
2834 if (componentInstanceProps == null )
2835 componentInstanceProps = new HashMap<>();
2836 componentInstanceProps.putAll(instProperties);
2837 resource.setComponentInstancesProperties(componentInstanceProps);
2840 private void handleSubstitutionMappings(Resource resource,
2841 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
2842 if (resource.getResourceType() == ResourceTypeEnum.CVFC) {
2843 Either<Resource, StorageOperationStatus> getResourceRes =
2844 updateCalculatedCapReqWithSubstitutionMappings(resource, uploadResInstancesMap);
2845 if (getResourceRes.isRight()) {
2846 ResponseFormat responseFormat = componentsUtils
2847 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResourceRes.right()
2848 .value()), resource);
2849 throw new ByResponseFormatComponentException(responseFormat);
2854 private void addRelationsToRI(String yamlName, Resource resource,
2855 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
2856 List<ComponentInstance> componentInstancesList, List<RequirementCapabilityRelDef> relations) {
2857 for (Entry<String, UploadComponentInstanceInfo> entry : uploadResInstancesMap.entrySet()) {
2858 UploadComponentInstanceInfo uploadComponentInstanceInfo = entry.getValue();
2859 ComponentInstance currentCompInstance = null;
2860 for (ComponentInstance compInstance : componentInstancesList) {
2862 if (compInstance.getName()
2863 .equals(uploadComponentInstanceInfo.getName())) {
2864 currentCompInstance = compInstance;
2869 if (currentCompInstance == null) {
2870 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(),
2871 resource.getUniqueId());
2872 BeEcompErrorManager.getInstance()
2873 .logInternalDataError(
2874 COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE,
2875 resource.getUniqueId(), ErrorSeverity.ERROR);
2876 throw new ByActionStatusComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2879 ResponseFormat addRelationToRiRes = addRelationToRI(yamlName, resource, entry.getValue(), relations);
2880 if (addRelationToRiRes.getStatus() != 200) {
2881 throw new ByResponseFormatComponentException(addRelationToRiRes);
2887 private void setResourceInstanceRelationsOnComponent(Resource resource, List<RequirementCapabilityRelDef> relations) {
2888 if (resource.getComponentInstancesRelations() != null) {
2889 resource.getComponentInstancesRelations().addAll(relations);
2891 resource.setComponentInstancesRelations(relations);
2895 private void processComponentInstance(String yamlName, Resource resource,
2896 List<ComponentInstance> componentInstancesList,
2897 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes,
2898 Map<String, List<ComponentInstanceProperty>> instProperties,
2899 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
2900 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> instRequirements,
2901 Map<String, Map<String, ArtifactDefinition>> instDeploymentArtifacts,
2902 Map<String, Map<String, ArtifactDefinition>> instArtifacts,
2903 Map<String, List<AttributeDataDefinition>> instAttributes,
2904 Map<String, Resource> originCompMap,
2905 Map<String, List<ComponentInstanceInput>> instInputs,
2906 UploadComponentInstanceInfo uploadComponentInstanceInfo) {
2907 Optional<ComponentInstance> currentCompInstanceOpt = componentInstancesList.stream()
2908 .filter(i -> i.getName()
2909 .equals(uploadComponentInstanceInfo.getName()))
2911 if (!currentCompInstanceOpt.isPresent()) {
2912 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, uploadComponentInstanceInfo.getName(),
2913 resource.getUniqueId());
2914 BeEcompErrorManager.getInstance()
2915 .logInternalDataError(
2916 COMPONENT_INSTANCE_WITH_NAME + uploadComponentInstanceInfo.getName() + IN_RESOURCE,
2917 resource.getUniqueId(), ErrorSeverity.ERROR);
2918 throw new ByActionStatusComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
2920 ComponentInstance currentCompInstance = currentCompInstanceOpt.get();
2921 String resourceInstanceId = currentCompInstance.getUniqueId();
2922 Resource originResource = getOriginResource(originCompMap, currentCompInstance);
2923 if (isNotEmpty(originResource.getRequirements())) {
2924 instRequirements.put(currentCompInstance, originResource.getRequirements());
2926 if (isNotEmpty(originResource.getCapabilities())) {
2927 processComponentInstanceCapabilities(allDataTypes, instCapabilties, uploadComponentInstanceInfo,
2928 currentCompInstance, originResource);
2930 if (originResource.getDeploymentArtifacts() != null && !originResource.getDeploymentArtifacts()
2932 instDeploymentArtifacts.put(resourceInstanceId, originResource.getDeploymentArtifacts());
2934 if (originResource.getArtifacts() != null && !originResource.getArtifacts().isEmpty()) {
2935 instArtifacts.put(resourceInstanceId, originResource.getArtifacts());
2937 if (originResource.getAttributes() != null && !originResource.getAttributes().isEmpty()) {
2938 instAttributes.put(resourceInstanceId, originResource.getAttributes());
2940 if (originResource.getResourceType() != ResourceTypeEnum.CVFC) {
2941 ResponseFormat addPropertiesValueToRiRes = addPropertyValuesToRi(uploadComponentInstanceInfo, resource,
2942 originResource, currentCompInstance, instProperties, allDataTypes.left()
2944 if (addPropertiesValueToRiRes.getStatus() != 200) {
2945 throw new ByResponseFormatComponentException(addPropertiesValueToRiRes);
2948 addInputsValuesToRi(uploadComponentInstanceInfo, resource, originResource, currentCompInstance, instInputs,
2954 private Resource getOriginResource(Map<String, Resource> originCompMap, ComponentInstance currentCompInstance) {
2955 Resource originResource;
2956 if (!originCompMap.containsKey(currentCompInstance.getComponentUid())) {
2957 Either<Resource, StorageOperationStatus> getOriginResourceRes = toscaOperationFacade
2958 .getToscaFullElement(currentCompInstance.getComponentUid());
2959 if (getOriginResourceRes.isRight()) {
2960 log.debug("failed to fetch resource with uniqueId {} and tosca component name {} status is {}",
2961 currentCompInstance.getComponentUid(), currentCompInstance.getToscaComponentName(),
2962 getOriginResourceRes);
2963 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(getOriginResourceRes.right()
2964 .value()), currentCompInstance.getComponentUid());
2966 originResource = getOriginResourceRes.left()
2968 originCompMap.put(originResource.getUniqueId(), originResource);
2970 originResource = originCompMap.get(currentCompInstance.getComponentUid());
2972 return originResource;
2975 private void processComponentInstanceCapabilities(
2976 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes,
2977 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> instCapabilties,
2978 UploadComponentInstanceInfo uploadComponentInstanceInfo, ComponentInstance currentCompInstance,
2979 Resource originResource) {
2980 Map<String, List<CapabilityDefinition>> originCapabilities;
2981 if (isNotEmpty(uploadComponentInstanceInfo.getCapabilities())) {
2982 originCapabilities = new HashMap<>();
2983 Map<String, Map<String, UploadPropInfo>> newPropertiesMap = new HashMap<>();
2984 originResource.getCapabilities()
2985 .forEach((k, v) -> addCapabilities(originCapabilities, k, v));
2986 uploadComponentInstanceInfo.getCapabilities()
2988 .forEach(l -> addCapabilitiesProperties(newPropertiesMap, l));
2989 updateCapabilityPropertiesValues(allDataTypes, originCapabilities, newPropertiesMap);
2991 originCapabilities = originResource.getCapabilities();
2993 instCapabilties.put(currentCompInstance, originCapabilities);
2996 private void updateCapabilityPropertiesValues(
2997 Either<Map<String, DataTypeDefinition>, JanusGraphOperationStatus> allDataTypes,
2998 Map<String, List<CapabilityDefinition>> originCapabilities,
2999 Map<String, Map<String, UploadPropInfo>> newPropertiesMap) {
3000 originCapabilities.values()
3002 .flatMap(Collection::stream)
3003 .filter(c -> newPropertiesMap.containsKey(c.getName()))
3004 .forEach(c -> updatePropertyValues(c.getProperties(), newPropertiesMap.get(c.getName()),
3009 private void addCapabilitiesProperties(Map<String, Map<String, UploadPropInfo>> newPropertiesMap,
3010 List<UploadCapInfo> capabilities) {
3011 for (UploadCapInfo capability : capabilities) {
3012 if (isNotEmpty(capability.getProperties())) {
3013 newPropertiesMap.put(capability.getName(), capability.getProperties()
3015 .collect(toMap(UploadInfo::getName, p -> p)));
3020 private void addCapabilities(Map<String, List<CapabilityDefinition>> originCapabilities, String type,
3021 List<CapabilityDefinition> capabilities) {
3022 List<CapabilityDefinition> list = capabilities.stream()
3023 .map(CapabilityDefinition::new)
3025 originCapabilities.put(type, list);
3028 private void updatePropertyValues(List<ComponentInstanceProperty> properties,
3029 Map<String, UploadPropInfo> newProperties, Map<String, DataTypeDefinition> allDataTypes) {
3030 properties.forEach(p -> updatePropertyValue(p, newProperties.get(p.getName()), allDataTypes));
3033 private String updatePropertyValue(ComponentInstanceProperty property, UploadPropInfo propertyInfo,
3034 Map<String, DataTypeDefinition> allDataTypes) {
3035 String value = null;
3036 List<GetInputValueDataDefinition> getInputs = null;
3037 boolean isValidate = true;
3038 if (null != propertyInfo && propertyInfo.getValue() != null) {
3039 getInputs = propertyInfo.getGet_input();
3040 isValidate = getInputs == null || getInputs.isEmpty();
3042 value = getPropertyJsonStringValue(propertyInfo.getValue(), property.getType());
3044 value = getPropertyJsonStringValue(propertyInfo.getValue(),
3045 TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
3048 property.setValue(value);
3049 return validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
3052 private Either<Resource, StorageOperationStatus> updateCalculatedCapReqWithSubstitutionMappings(Resource resource,
3053 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap) {
3054 Either<Resource, StorageOperationStatus> updateRes = null;
3055 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities = new HashMap<>();
3056 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements = new HashMap<>();
3057 StorageOperationStatus status = toscaOperationFacade
3058 .deleteAllCalculatedCapabilitiesRequirements(resource.getUniqueId());
3059 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
3061 "Failed to delete all calculated capabilities and requirements of resource {} upon update. Status is {}",
3062 resource.getUniqueId(), status);
3063 updateRes = Either.right(status);
3065 if (updateRes == null) {
3066 fillUpdatedInstCapabilitiesRequirements(resource.getComponentInstances(), uploadResInstancesMap,
3067 updatedInstCapabilities, updatedInstRequirements);
3068 status = toscaOperationFacade.associateOrAddCalculatedCapReq(updatedInstCapabilities,
3069 updatedInstRequirements, resource);
3070 if (status != StorageOperationStatus.OK && status != StorageOperationStatus.NOT_FOUND) {
3072 "Failed to associate capabilities and requirementss of resource {}, updated according to a substitution mapping. Status is {}",
3073 resource.getUniqueId(), status);
3074 updateRes = Either.right(status);
3077 if (updateRes == null) {
3078 updateRes = Either.left(resource);
3083 private void fillUpdatedInstCapabilitiesRequirements(List<ComponentInstance> componentInstances,
3084 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap,
3085 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilities,
3086 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements) {
3088 componentInstances.stream()
3090 fillUpdatedInstCapabilities(updatedInstCapabilities, i, uploadResInstancesMap.get(i.getName())
3091 .getCapabilitiesNamesToUpdate());
3092 fillUpdatedInstRequirements(updatedInstRequirements, i, uploadResInstancesMap.get(i.getName())
3093 .getRequirementsNamesToUpdate());
3097 private void fillUpdatedInstRequirements(
3098 Map<ComponentInstance, Map<String, List<RequirementDefinition>>> updatedInstRequirements,
3099 ComponentInstance instance, Map<String, String> requirementsNamesToUpdate) {
3100 Map<String, List<RequirementDefinition>> updatedRequirements = new HashMap<>();
3101 Set<String> updatedReqNames = new HashSet<>();
3102 if (isNotEmpty(requirementsNamesToUpdate)) {
3103 for (Map.Entry<String, List<RequirementDefinition>> requirements : instance.getRequirements()
3105 updatedRequirements.put(requirements.getKey(), requirements.getValue()
3107 .filter(r -> requirementsNamesToUpdate.containsKey(r.getName())
3108 && !updatedReqNames.contains(requirementsNamesToUpdate.get(r.getName())))
3110 r.setParentName(r.getName());
3111 r.setName(requirementsNamesToUpdate.get(r.getName()));
3112 updatedReqNames.add(r.getName());
3115 .collect(toList()));
3118 if (isNotEmpty(updatedRequirements)) {
3119 updatedInstRequirements.put(instance, updatedRequirements);
3123 private void fillUpdatedInstCapabilities(
3124 Map<ComponentInstance, Map<String, List<CapabilityDefinition>>> updatedInstCapabilties,
3125 ComponentInstance instance, Map<String, String> capabilitiesNamesToUpdate) {
3126 Map<String, List<CapabilityDefinition>> updatedCapabilities = new HashMap<>();
3127 Set<String> updatedCapNames = new HashSet<>();
3128 if (isNotEmpty(capabilitiesNamesToUpdate)) {
3129 for (Map.Entry<String, List<CapabilityDefinition>> requirements : instance.getCapabilities()
3131 updatedCapabilities.put(requirements.getKey(), requirements.getValue()
3133 .filter(c -> capabilitiesNamesToUpdate.containsKey(c.getName())
3134 && !updatedCapNames.contains(capabilitiesNamesToUpdate.get(c.getName())))
3136 c.setParentName(c.getName());
3137 c.setName(capabilitiesNamesToUpdate.get(c.getName()));
3138 updatedCapNames.add(c.getName());
3141 .collect(toList()));
3144 if (isNotEmpty(updatedCapabilities)) {
3145 updatedInstCapabilties.put(instance, updatedCapabilities);
3149 private ResponseFormat addRelationToRI(String yamlName, Resource resource,
3150 UploadComponentInstanceInfo nodesInfoValue, List<RequirementCapabilityRelDef> relations) {
3151 List<ComponentInstance> componentInstancesList = resource.getComponentInstances();
3153 ComponentInstance currentCompInstance = null;
3155 for (ComponentInstance compInstance : componentInstancesList) {
3157 if (compInstance.getName()
3158 .equals(nodesInfoValue.getName())) {
3159 currentCompInstance = compInstance;
3165 if (currentCompInstance == null) {
3166 log.debug(COMPONENT_INSTANCE_WITH_NAME_IN_RESOURCE, nodesInfoValue.getName(), resource.getUniqueId());
3167 BeEcompErrorManager.getInstance()
3168 .logInternalDataError(COMPONENT_INSTANCE_WITH_NAME + nodesInfoValue.getName() + IN_RESOURCE,
3169 resource.getUniqueId(), ErrorSeverity.ERROR);
3170 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
3172 String resourceInstanceId = currentCompInstance.getUniqueId();
3174 Map<String, List<UploadReqInfo>> regMap = nodesInfoValue.getRequirements();
3176 if (regMap != null) {
3177 Iterator<Entry<String, List<UploadReqInfo>>> nodesRegValue = regMap.entrySet()
3180 while (nodesRegValue.hasNext()) {
3181 Entry<String, List<UploadReqInfo>> nodesRegInfoEntry = nodesRegValue.next();
3183 List<UploadReqInfo> uploadRegInfoList = nodesRegInfoEntry.getValue();
3184 for (UploadReqInfo uploadRegInfo : uploadRegInfoList) {
3185 log.debug("Going to create relation {}", uploadRegInfo.getName());
3186 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(), StatusCode.STARTED,"Started to create relations on instance: {}",uploadRegInfo.getName());
3187 String regName = uploadRegInfo.getName();
3188 RequirementCapabilityRelDef regCapRelDef = new RequirementCapabilityRelDef();
3189 regCapRelDef.setFromNode(resourceInstanceId);
3190 log.debug("try to find available requirement {} ", regName);
3191 Either<RequirementDefinition, ResponseFormat> eitherReqStatus = findAviableRequiremen(regName,
3192 yamlName, nodesInfoValue, currentCompInstance, uploadRegInfo.getCapabilityName());
3193 if (eitherReqStatus.isRight()) {
3194 log.debug("failed to find available requirement {} status is {}", regName,
3195 eitherReqStatus.right()
3197 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(), StatusCode.ERROR,"ERROR while search available requirement {} status is: {}",regName,eitherReqStatus.right().value());
3198 return eitherReqStatus.right()
3202 RequirementDefinition validReq = eitherReqStatus.left()
3204 List<CapabilityRequirementRelationship> reqAndRelationshipPairList = regCapRelDef
3205 .getRelationships();
3206 if (reqAndRelationshipPairList == null) {
3207 reqAndRelationshipPairList = new ArrayList<>();
3209 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
3210 reqAndRelationshipPair.setRequirement(regName);
3211 reqAndRelationshipPair.setRequirementOwnerId(validReq.getOwnerId());
3212 reqAndRelationshipPair.setRequirementUid(validReq.getUniqueId());
3213 RelationshipImpl relationship = new RelationshipImpl();
3214 relationship.setType(validReq.getCapability());
3215 reqAndRelationshipPair.setRelationships(relationship);
3217 ComponentInstance currentCapCompInstance = null;
3218 for (ComponentInstance compInstance : componentInstancesList) {
3219 if (compInstance.getName()
3220 .equals(uploadRegInfo.getNode())) {
3221 currentCapCompInstance = compInstance;
3226 if (currentCapCompInstance == null) {
3227 log.debug("The component instance with name {} not found on resource {} ",
3228 uploadRegInfo.getNode(), resource.getUniqueId());
3229 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(), StatusCode.ERROR,"ERROR component instance with name: {} not found on resource: {}",uploadRegInfo.getNode(),resource.getUniqueId());
3230 BeEcompErrorManager.getInstance()
3231 .logInternalDataError(
3232 COMPONENT_INSTANCE_WITH_NAME + uploadRegInfo.getNode() + IN_RESOURCE,
3233 resource.getUniqueId(), ErrorSeverity.ERROR);
3234 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
3236 regCapRelDef.setToNode(currentCapCompInstance.getUniqueId());
3237 log.debug("try to find aviable Capability req name is {} ", validReq.getName());
3238 CapabilityDefinition aviableCapForRel = findAvailableCapabilityByTypeOrName(validReq,
3239 currentCapCompInstance, uploadRegInfo);
3241 if (aviableCapForRel == null) {
3242 log.debug("aviable capability was not found. req name is {} component instance is {}",
3243 validReq.getName(), currentCapCompInstance.getUniqueId());
3244 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RELATIONS,resource.getComponentMetadataForSupportLog(), StatusCode.ERROR,"ERROR available capability was not found. req name is: {} component instance is: {}",validReq.getName(),currentCapCompInstance.getUniqueId());
3245 BeEcompErrorManager.getInstance()
3246 .logInternalDataError(
3247 "aviable capability was not found. req name is " + validReq.getName()
3248 + " component instance is " + currentCapCompInstance.getUniqueId(),
3249 resource.getUniqueId(), ErrorSeverity.ERROR);
3250 return componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, yamlName);
3252 reqAndRelationshipPair.setCapability(aviableCapForRel.getName());
3253 reqAndRelationshipPair.setCapabilityUid(aviableCapForRel.getUniqueId());
3254 reqAndRelationshipPair.setCapabilityOwnerId(aviableCapForRel.getOwnerId());
3256 CapabilityRequirementRelationship capReqRel = new CapabilityRequirementRelationship();
3257 capReqRel.setRelation(reqAndRelationshipPair);
3258 reqAndRelationshipPairList.add(capReqRel);
3259 regCapRelDef.setRelationships(reqAndRelationshipPairList);
3260 relations.add(regCapRelDef);
3263 } else if (resource.getResourceType() != ResourceTypeEnum.CVFC) {
3264 return componentsUtils.getResponseFormat(ActionStatus.OK, yamlName);
3266 return componentsUtils.getResponseFormat(ActionStatus.OK);
3269 private void addInputsValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo, Resource resource,
3270 Resource originResource, ComponentInstance currentCompInstance,
3271 Map<String, List<ComponentInstanceInput>> instInputs, Map<String, DataTypeDefinition> allDataTypes) {
3272 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
3273 if (MapUtils.isNotEmpty(propMap)) {
3274 Map<String, InputDefinition> currPropertiesMap = new HashMap<>();
3275 List<ComponentInstanceInput> instPropList = new ArrayList<>();
3277 if (CollectionUtils.isEmpty(originResource.getInputs())) {
3278 log.debug("failed to find properties ");
3279 loggerSupportability.log(LoggerSupportabilityActions.CREATE_INPUTS,resource.getComponentMetadataForSupportLog(),StatusCode.ERROR,"ERROR while try to find properties");
3280 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND);
3282 originResource.getInputs()
3283 .forEach(p -> addInput(currPropertiesMap, p));
3284 for (List<UploadPropInfo> propertyList : propMap.values()) {
3285 processProperty(resource, currentCompInstance, allDataTypes, currPropertiesMap, instPropList,
3288 currPropertiesMap.values()
3289 .forEach(p -> instPropList.add(new ComponentInstanceInput(p)));
3290 instInputs.put(currentCompInstance.getUniqueId(), instPropList);
3294 private void processProperty(Resource resource, ComponentInstance currentCompInstance,
3295 Map<String, DataTypeDefinition> allDataTypes, Map<String, InputDefinition> currPropertiesMap,
3296 List<ComponentInstanceInput> instPropList, List<UploadPropInfo> propertyList) {
3297 UploadPropInfo propertyInfo = propertyList.get(0);
3298 String propName = propertyInfo.getName();
3299 if (!currPropertiesMap.containsKey(propName)) {
3300 loggerSupportability.log(LoggerSupportabilityActions.PROPERTY,resource.getComponentMetadataForSupportLog(),
3301 StatusCode.ERROR,"ERROR failed to find property: {}",propName);
3302 log.debug("failed to find property {} ", propName);
3303 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND, propName);
3305 InputDefinition curPropertyDef = currPropertiesMap.get(propName);
3306 ComponentInstanceInput property = null;
3308 String value = null;
3309 List<GetInputValueDataDefinition> getInputs = null;
3310 boolean isValidate = true;
3311 if (propertyInfo.getValue() != null) {
3312 getInputs = propertyInfo.getGet_input();
3313 isValidate = getInputs == null || getInputs.isEmpty();
3315 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
3317 value = getPropertyJsonStringValue(propertyInfo.getValue(),
3318 TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
3321 String innerType = null;
3322 property = new ComponentInstanceInput(curPropertyDef, value, null);
3324 String validPropertyVAlue = validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
3326 property.setValue(validPropertyVAlue);
3328 if (isNotEmpty(getInputs)) {
3329 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
3330 for (GetInputValueDataDefinition getInput : getInputs) {
3331 List<InputDefinition> inputs = resource.getInputs();
3332 if (CollectionUtils.isEmpty(inputs)) {
3333 loggerSupportability.log(LoggerSupportabilityActions.PROPERTY,resource.getComponentMetadataForSupportLog(),
3334 StatusCode.ERROR,"ERROR Failed to add property: "+propName+" to resource instance: {}. Inputs list is empty ",currentCompInstance.getUniqueId());
3335 log.debug("Failed to add property {} to resource instance {}. Inputs list is empty ", property,
3336 currentCompInstance.getUniqueId());
3337 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
3340 Optional<InputDefinition> optional = inputs.stream()
3341 .filter(p -> p.getName()
3342 .equals(getInput.getInputName()))
3344 if (!optional.isPresent()) {
3345 loggerSupportability.log(LoggerSupportabilityActions.PROPERTY,resource.getComponentMetadataForSupportLog(),
3346 StatusCode.ERROR,"ERROR Failed to find input: "+getInput.getInputName());
3347 log.debug("Failed to find input {} ", getInput.getInputName());
3348 // @@TODO error message
3349 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
3351 InputDefinition input = optional.get();
3352 getInput.setInputId(input.getUniqueId());
3353 getInputValues.add(getInput);
3355 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
3356 processGetInput(getInputValues, inputs, getInputIndex);
3358 property.setGetInputValues(getInputValues);
3360 instPropList.add(property);
3361 // delete overriden property
3362 currPropertiesMap.remove(property.getName());
3365 private void processGetInput(List<GetInputValueDataDefinition> getInputValues, List<InputDefinition> inputs,
3366 GetInputValueDataDefinition getInputIndex) {
3367 Optional<InputDefinition> optional;
3368 if (getInputIndex != null) {
3369 optional = inputs.stream()
3370 .filter(p -> p.getName()
3371 .equals(getInputIndex.getInputName()))
3373 if (!optional.isPresent()) {
3374 log.debug("Failed to find input {} ", getInputIndex.getInputName());
3375 // @@TODO error message
3376 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
3378 InputDefinition inputIndex = optional.get();
3379 getInputIndex.setInputId(inputIndex.getUniqueId());
3380 getInputValues.add(getInputIndex);
3384 private void addInput(Map<String, InputDefinition> currPropertiesMap, InputDefinition prop) {
3385 String propName = prop.getName();
3386 if (!currPropertiesMap.containsKey(propName)) {
3387 currPropertiesMap.put(propName, prop);
3391 private ResponseFormat addPropertyValuesToRi(UploadComponentInstanceInfo uploadComponentInstanceInfo,
3392 Resource resource, Resource originResource, ComponentInstance currentCompInstance,
3393 Map<String, List<ComponentInstanceProperty>> instProperties, Map<String, DataTypeDefinition> allDataTypes) {
3395 Map<String, List<UploadPropInfo>> propMap = uploadComponentInstanceInfo.getProperties();
3396 Map<String, PropertyDefinition> currPropertiesMap = new HashMap<>();
3398 List<PropertyDefinition> listFromMap = originResource.getProperties();
3399 if ((propMap != null && !propMap.isEmpty()) && (listFromMap == null || listFromMap.isEmpty())) {
3400 loggerSupportability.log(LoggerSupportabilityActions.PROPERTY,resource.getComponentMetadataForSupportLog(),
3401 StatusCode.ERROR,"ERROR Failed to find properties");
3402 log.debug("failed to find properties");
3403 return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND);
3405 if (listFromMap == null || listFromMap.isEmpty()) {
3406 return componentsUtils.getResponseFormat(ActionStatus.OK);
3408 for (PropertyDefinition prop : listFromMap) {
3409 String propName = prop.getName();
3410 if (!currPropertiesMap.containsKey(propName)) {
3411 currPropertiesMap.put(propName, prop);
3414 List<ComponentInstanceProperty> instPropList = new ArrayList<>();
3415 if (propMap != null && propMap.size() > 0) {
3416 for (List<UploadPropInfo> propertyList : propMap.values()) {
3418 UploadPropInfo propertyInfo = propertyList.get(0);
3419 String propName = propertyInfo.getName();
3420 if (!currPropertiesMap.containsKey(propName)) {
3421 log.debug("failed to find property {} ", propName);
3422 loggerSupportability.log(LoggerSupportabilityActions.PROPERTY,resource.getComponentMetadataForSupportLog(), StatusCode.ERROR,"ERROR Failed to find property: {}",propName);
3423 return componentsUtils.getResponseFormat(ActionStatus.PROPERTY_NOT_FOUND, propName);
3425 PropertyDefinition curPropertyDef = currPropertiesMap.get(propName);
3426 ComponentInstanceProperty property = null;
3428 String value = null;
3429 List<GetInputValueDataDefinition> getInputs = null;
3430 boolean isValidate = true;
3431 if (propertyInfo.getValue() != null) {
3432 getInputs = propertyInfo.getGet_input();
3433 isValidate = getInputs == null || getInputs.isEmpty();
3435 value = getPropertyJsonStringValue(propertyInfo.getValue(), curPropertyDef.getType());
3437 value = getPropertyJsonStringValue(propertyInfo.getValue(),
3438 TypeUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
3441 String innerType = null;
3442 property = new ComponentInstanceProperty(curPropertyDef, value, null);
3444 String validatePropValue = validatePropValueBeforeCreate(property, value, isValidate, allDataTypes);
3445 property.setValue(validatePropValue);
3447 if (getInputs != null && !getInputs.isEmpty()) {
3448 List<GetInputValueDataDefinition> getInputValues = new ArrayList<>();
3449 for (GetInputValueDataDefinition getInput : getInputs) {
3450 List<InputDefinition> inputs = resource.getInputs();
3451 if (inputs == null || inputs.isEmpty()) {
3452 log.debug("Failed to add property {} to instance. Inputs list is empty ", property);
3453 loggerSupportability.log(LoggerSupportabilityActions.PROPERTY,resource.getComponentMetadataForSupportLog(), StatusCode.ERROR,"Failed to add property: {} to instance. Inputs list is empty",propName);
3454 rollbackWithException(ActionStatus.INPUTS_NOT_FOUND, property.getGetInputValues()
3456 .map(GetInputValueDataDefinition::getInputName)
3460 Either<InputDefinition, RuntimeException> inputEither = findInputByName(inputs, getInput);
3461 if (inputEither.isRight()) {
3462 throw inputEither.right().value();
3464 InputDefinition input = inputEither.left().value();
3465 getInput.setInputId(input.getUniqueId());
3466 getInputValues.add(getInput);
3468 GetInputValueDataDefinition getInputIndex = getInput.getGetInputIndex();
3469 if (getInputIndex != null) {
3470 Either<InputDefinition, RuntimeException> newInputEither = findInputByName(inputs,
3472 if (inputEither.isRight()) {
3473 throw newInputEither.right().value();
3475 InputDefinition newInput = newInputEither.left().value();
3476 getInputIndex.setInputId(newInput.getUniqueId());
3478 getInputValues.add(getInputIndex);
3483 property.setGetInputValues(getInputValues);
3485 instPropList.add(property);
3486 // delete overriden property
3487 currPropertiesMap.remove(property.getName());
3490 // add rest of properties
3491 if (!currPropertiesMap.isEmpty()) {
3492 for (PropertyDefinition value : currPropertiesMap.values()) {
3493 instPropList.add(new ComponentInstanceProperty(value));
3496 instProperties.put(currentCompInstance.getUniqueId(), instPropList);
3497 return componentsUtils.getResponseFormat(ActionStatus.OK);
3500 // US740820 Relate RIs according to capability name
3501 private CapabilityDefinition findAvailableCapabilityByTypeOrName(RequirementDefinition validReq,
3502 ComponentInstance currentCapCompInstance, UploadReqInfo uploadReqInfo) {
3503 if (null == uploadReqInfo.getCapabilityName() || validReq.getCapability()
3504 .equals(uploadReqInfo.getCapabilityName())) {// get
3508 return findAvailableCapability(validReq, currentCapCompInstance);
3510 return findAvailableCapability(validReq, currentCapCompInstance, uploadReqInfo);
3513 private CapabilityDefinition findAvailableCapability(RequirementDefinition validReq,
3514 ComponentInstance currentCapCompInstance, UploadReqInfo uploadReqInfo) {
3515 CapabilityDefinition cap = null;
3516 Map<String, List<CapabilityDefinition>> capMap = currentCapCompInstance.getCapabilities();
3517 if (!capMap.containsKey(validReq.getCapability())) {
3520 Optional<CapabilityDefinition> capByName = capMap.get(validReq.getCapability())
3522 .filter(p -> p.getName()
3523 .equals(uploadReqInfo.getCapabilityName()))
3525 if (!capByName.isPresent()) {
3528 cap = capByName.get();
3530 if (isBoundedByOccurrences(cap)) {
3531 String leftOccurrences = cap.getLeftOccurrences();
3532 int left = Integer.parseInt(leftOccurrences);
3535 cap.setLeftOccurrences(String.valueOf(left));
3543 private CapabilityDefinition findAvailableCapability(RequirementDefinition validReq, ComponentInstance instance) {
3544 Map<String, List<CapabilityDefinition>> capMap = instance.getCapabilities();
3545 if (capMap.containsKey(validReq.getCapability())) {
3546 List<CapabilityDefinition> capList = capMap.get(validReq.getCapability());
3548 for (CapabilityDefinition cap : capList) {
3549 if (isBoundedByOccurrences(cap)) {
3550 String leftOccurrences = cap.getLeftOccurrences() != null ? cap.getLeftOccurrences()
3551 : cap.getMaxOccurrences();
3552 int left = Integer.parseInt(leftOccurrences);
3555 cap.setLeftOccurrences(String.valueOf(left));
3566 private boolean isBoundedByOccurrences(CapabilityDefinition cap) {
3567 return cap.getMaxOccurrences() != null && !cap.getMaxOccurrences()
3568 .equals(CapabilityDataDefinition.MAX_OCCURRENCES);
3571 private Either<RequirementDefinition, ResponseFormat> findAviableRequiremen(String regName, String yamlName,
3572 UploadComponentInstanceInfo uploadComponentInstanceInfo, ComponentInstance currentCompInstance,
3574 Map<String, List<RequirementDefinition>> comInstRegDefMap = currentCompInstance.getRequirements();
3575 List<RequirementDefinition> list = comInstRegDefMap.get(capName);
3576 RequirementDefinition validRegDef = null;
3578 for (Entry<String, List<RequirementDefinition>> entry : comInstRegDefMap.entrySet()) {
3579 for (RequirementDefinition reqDef : entry.getValue()) {
3580 if (reqDef.getName()
3582 if (reqDef.getMaxOccurrences() != null && !reqDef.getMaxOccurrences()
3583 .equals(RequirementDataDefinition.MAX_OCCURRENCES)) {
3584 String leftOccurrences = reqDef.getLeftOccurrences();
3585 if (leftOccurrences == null) {
3586 leftOccurrences = reqDef.getMaxOccurrences();
3588 int left = Integer.parseInt(leftOccurrences);
3591 reqDef.setLeftOccurrences(String.valueOf(left));
3592 validRegDef = reqDef;
3598 validRegDef = reqDef;
3604 if (validRegDef != null) {
3609 for (RequirementDefinition reqDef : list) {
3610 if (reqDef.getName()
3612 if (reqDef.getMaxOccurrences() != null && !reqDef.getMaxOccurrences()
3613 .equals(RequirementDataDefinition.MAX_OCCURRENCES)) {
3614 String leftOccurrences = reqDef.getLeftOccurrences();
3615 if (leftOccurrences == null) {
3616 leftOccurrences = reqDef.getMaxOccurrences();
3618 int left = Integer.parseInt(leftOccurrences);
3621 reqDef.setLeftOccurrences(String.valueOf(left));
3622 validRegDef = reqDef;
3628 validRegDef = reqDef;
3634 if (validRegDef == null) {
3635 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_NODE_TEMPLATE,
3636 yamlName, uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType());
3637 return Either.right(responseFormat);
3639 return Either.left(validRegDef);
3642 private Resource createResourceInstances(String yamlName, Resource resource, Resource oldResource,
3643 Map<String, UploadComponentInstanceInfo> uploadResInstancesMap, Map<String, Resource> nodeNamespaceMap, Map<String, Resource> existingNodeTypesByResourceNames) {
3645 Either<Resource, ResponseFormat> eitherResource;
3646 log.debug("createResourceInstances is {} - going to create resource instanse from CSAR", yamlName);
3647 if (isEmpty(uploadResInstancesMap) && resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
3648 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
3649 throw new ByResponseFormatComponentException(responseFormat);
3651 if (MapUtils.isNotEmpty(nodeNamespaceMap)) {
3652 nodeNamespaceMap.forEach((k, v) -> existingNodeTypesByResourceNames.put(v.getToscaResourceName(), v));
3654 Map<ComponentInstance, Resource> resourcesInstancesMap = new HashMap<>();
3655 uploadResInstancesMap.values()
3656 .forEach(i -> createAndAddResourceInstance(i, yamlName, resource, nodeNamespaceMap,
3657 existingNodeTypesByResourceNames, resourcesInstancesMap));
3658 if (oldResource != null && oldResource.getResourceType() != ResourceTypeEnum.CVFC && oldResource.getComponentInstances() != null) {
3659 Map<String, Resource> existingNodeTypesByUids = existingNodeTypesByResourceNames.values()
3661 .collect(toMap(Resource::getUniqueId, r -> r));
3662 oldResource.getComponentInstances()
3664 .filter(i -> !i.isCreatedFromCsar())
3665 .forEach(uiInst -> resourcesInstancesMap.put(uiInst,
3666 getOriginResource(existingNodeTypesByUids, uiInst)));
3669 if (isNotEmpty(resourcesInstancesMap)) {
3671 toscaOperationFacade.associateComponentInstancesToComponent(resource,
3672 resourcesInstancesMap, false, oldResource != null);
3673 } catch (StorageException exp) {
3674 if (exp.getStorageOperationStatus() != null && exp.getStorageOperationStatus() != StorageOperationStatus.OK) {
3675 log.debug("Failed to add component instances to container component {}", resource.getName());
3676 ResponseFormat responseFormat = componentsUtils
3677 .getResponseFormat(componentsUtils.convertFromStorageResponse(exp.getStorageOperationStatus()));
3678 eitherResource = Either.right(responseFormat);
3679 throw new ByResponseFormatComponentException(eitherResource.right().value());
3683 if (CollectionUtils.isEmpty(resource.getComponentInstances()) &&
3684 resource.getResourceType() != ResourceTypeEnum.PNF) { // PNF can have no resource instances
3685 log.debug("Error when create resource instance from csar. ComponentInstances list empty");
3686 BeEcompErrorManager.getInstance()
3687 .logBeDaoSystemError(
3688 "Error when create resource instance from csar. ComponentInstances list empty");
3689 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE));
3694 private void createAndAddResourceInstance(UploadComponentInstanceInfo uploadComponentInstanceInfo, String yamlName,
3695 Resource resource, Map<String, Resource> nodeNamespaceMap, Map<String, Resource> existingnodeTypeMap,
3696 Map<ComponentInstance, Resource> resourcesInstancesMap) {
3697 Either<Resource, ResponseFormat> eitherResource;
3698 log.debug("*************Going to create resource instances {}", yamlName);
3699 // updating type if the type is node type name - we need to take the
3701 log.debug("*************Going to create resource instances {}", uploadComponentInstanceInfo.getName());
3702 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
3703 uploadComponentInstanceInfo.setType(nodeNamespaceMap.get(uploadComponentInstanceInfo.getType())
3704 .getToscaResourceName());
3706 Resource refResource = validateResourceInstanceBeforeCreate(yamlName, uploadComponentInstanceInfo,
3707 existingnodeTypeMap);
3709 ComponentInstance componentInstance = new ComponentInstance();
3710 componentInstance.setComponentUid(refResource.getUniqueId());
3711 Collection<String> directives = uploadComponentInstanceInfo.getDirectives();
3712 if(directives != null && !directives.isEmpty()) {
3713 componentInstance.setDirectives(new ArrayList<>(directives));
3715 UploadNodeFilterInfo uploadNodeFilterInfo = uploadComponentInstanceInfo.getUploadNodeFilterInfo();
3716 if (uploadNodeFilterInfo != null){
3717 componentInstance.setNodeFilter(new CINodeFilterUtils().getNodeFilterDataDefinition(uploadNodeFilterInfo,
3718 componentInstance.getUniqueId()));
3720 ComponentTypeEnum containerComponentType = resource.getComponentType();
3721 NodeTypeEnum containerNodeType = containerComponentType.getNodeType();
3722 if (containerNodeType == NodeTypeEnum.Resource && isNotEmpty(uploadComponentInstanceInfo.getCapabilities())
3723 && isNotEmpty(refResource.getCapabilities())) {
3724 setCapabilityNamesTypes(refResource.getCapabilities(), uploadComponentInstanceInfo.getCapabilities());
3725 Map<String, List<CapabilityDefinition>> validComponentInstanceCapabilities = getValidComponentInstanceCapabilities(
3726 refResource.getUniqueId(), refResource.getCapabilities(),
3727 uploadComponentInstanceInfo.getCapabilities());
3728 componentInstance.setCapabilities(validComponentInstanceCapabilities);
3731 if (isNotEmpty(uploadComponentInstanceInfo.getArtifacts())) {
3732 Map<String, Map<String, UploadArtifactInfo>> artifacts = uploadComponentInstanceInfo.getArtifacts();
3733 Map<String, ToscaArtifactDataDefinition> toscaArtifacts = new HashMap<>();
3734 Map<String, Map<String, UploadArtifactInfo>> arts = artifacts.entrySet().stream()
3735 .filter(e -> e.getKey().contains(TypeUtils.ToscaTagNamesEnum.ARTIFACTS.getElementName()))
3736 .collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue()));
3737 Map<String, UploadArtifactInfo> artifact = arts.get(TypeUtils.ToscaTagNamesEnum.ARTIFACTS.getElementName());
3738 for (Map.Entry<String, UploadArtifactInfo> entry : artifact.entrySet()) {
3739 ToscaArtifactDataDefinition to = new ToscaArtifactDataDefinition();
3740 to.setFile(entry.getValue().getFile());
3741 to.setType(entry.getValue().getType());
3742 toscaArtifacts.put(entry.getKey(), to);
3744 componentInstance.setToscaArtifacts(toscaArtifacts);
3747 if (!existingnodeTypeMap.containsKey(uploadComponentInstanceInfo.getType())) {
3748 log.debug("createResourceInstances - not found lates version for resource instance with name {} and type ",
3749 uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType());
3750 throw new ByActionStatusComponentException(ActionStatus.INVALID_NODE_TEMPLATE,
3751 yamlName, uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType());
3753 Resource origResource = existingnodeTypeMap.get(uploadComponentInstanceInfo.getType());
3754 componentInstance.setName(uploadComponentInstanceInfo.getName());
3755 componentInstance.setIcon(origResource.getIcon());
3756 componentInstance.setCreatedFrom(CreatedFrom.CSAR);
3757 resourcesInstancesMap.put(componentInstance, origResource);
3760 private ComponentParametersView getComponentWithInstancesFilter() {
3761 ComponentParametersView parametersView = new ComponentParametersView();
3762 parametersView.disableAll();
3763 parametersView.setIgnoreComponentInstances(false);
3764 parametersView.setIgnoreInputs(false);
3765 // inputs are read when creating
3766 // property values on instances
3767 parametersView.setIgnoreUsers(false);
3768 return parametersView;
3771 private void setCapabilityNamesTypes(Map<String, List<CapabilityDefinition>> originCapabilities,
3772 Map<String, List<UploadCapInfo>> uploadedCapabilities) {
3773 for (Entry<String, List<UploadCapInfo>> currEntry : uploadedCapabilities.entrySet()) {
3774 if (originCapabilities.containsKey(currEntry.getKey())) {
3775 currEntry.getValue()
3777 .forEach(cap -> cap.setType(currEntry.getKey()));
3780 for (Map.Entry<String, List<CapabilityDefinition>> capabilities : originCapabilities.entrySet()) {
3781 capabilities.getValue()
3784 if (uploadedCapabilities.containsKey(cap.getName())) {
3785 uploadedCapabilities.get(cap.getName())
3788 c.setName(cap.getName());
3789 c.setType(cap.getType());
3796 private Resource validateResourceInstanceBeforeCreate(String yamlName,
3797 UploadComponentInstanceInfo uploadComponentInstanceInfo, Map<String, Resource> nodeNamespaceMap) {
3800 "validateResourceInstanceBeforeCreate - going to validate resource instance with name {} and type {} before create",
3801 uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType());
3802 Resource refResource;
3803 if (nodeNamespaceMap.containsKey(uploadComponentInstanceInfo.getType())) {
3804 refResource = nodeNamespaceMap.get(uploadComponentInstanceInfo.getType());
3806 Either<Resource, StorageOperationStatus> findResourceEither = toscaOperationFacade
3807 .getLatestCertifiedNodeTypeByToscaResourceName(uploadComponentInstanceInfo.getType());
3808 if (findResourceEither.isRight()) {
3810 "validateResourceInstanceBeforeCreate - not found lates version for resource instance with name {} and type {}",
3811 uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType());
3812 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(findResourceEither.right().value()));
3814 refResource = findResourceEither.left().value();
3815 nodeNamespaceMap.put(refResource.getToscaResourceName(), refResource);
3817 String componentState = refResource.getComponentMetadataDefinition()
3818 .getMetadataDataDefinition()
3820 if (componentState.equals(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name())) {
3822 "validateResourceInstanceBeforeCreate - component instance of component {} can not be created because the component is in an illegal state {}.",
3823 refResource.getName(), componentState);
3824 throw new ByActionStatusComponentException(ActionStatus.ILLEGAL_COMPONENT_STATE,
3825 refResource.getComponentType().getValue(),refResource.getName(), componentState);
3828 if (!ModelConverter.isAtomicComponent(refResource) && refResource.getResourceType() != ResourceTypeEnum.CVFC) {
3829 log.debug("validateResourceInstanceBeforeCreate - ref resource type is ", refResource.getResourceType());
3830 throw new ByActionStatusComponentException(ActionStatus.INVALID_NODE_TEMPLATE,
3831 yamlName, uploadComponentInstanceInfo.getName(), uploadComponentInstanceInfo.getType());
3836 public Resource propagateStateToCertified(User user, Resource resource,
3837 LifecycleChangeInfoWithAction lifecycleChangeInfo, boolean inTransaction, boolean needLock,
3838 boolean forceCertificationAllowed) {
3840 boolean failed = false;
3842 if (resource.getLifecycleState() != LifecycleStateEnum.CERTIFIED && forceCertificationAllowed
3843 && lifecycleBusinessLogic.isFirstCertification(resource.getVersion())) {
3844 nodeForceCertification(resource, user, lifecycleChangeInfo, inTransaction, needLock);
3846 if (resource.getLifecycleState() == LifecycleStateEnum.CERTIFIED) {
3847 Either<ArtifactDefinition, Operation> eitherPopulated = populateToscaArtifacts(
3848 resource, user, false, inTransaction, needLock, false);
3851 return nodeFullCertification(resource.getUniqueId(), user, lifecycleChangeInfo, inTransaction, needLock);
3852 } catch (ComponentException e) {
3854 log.debug("The exception has occurred upon certification of resource {}. ", resource.getName(), e);
3858 BeEcompErrorManager.getInstance()
3859 .logBeSystemError("Change LifecycleState - Certify");
3860 if (!inTransaction) {
3861 janusGraphDao.rollback();
3863 } else if (!inTransaction) {
3864 janusGraphDao.commit();
3869 private Resource nodeFullCertification(String uniqueId, User user,
3870 LifecycleChangeInfoWithAction lifecycleChangeInfo, boolean inTransaction, boolean needLock) {
3871 Either<Resource, ResponseFormat> resourceResponse = lifecycleBusinessLogic.changeState(uniqueId, user, LifeCycleTransitionEnum.CERTIFY, lifecycleChangeInfo,
3872 inTransaction, needLock);
3873 if(resourceResponse.isRight()){
3874 throw new ByResponseFormatComponentException(resourceResponse.right().value());
3876 return resourceResponse.left().value();
3879 private Resource nodeForceCertification(Resource resource, User user,
3880 LifecycleChangeInfoWithAction lifecycleChangeInfo, boolean inTransaction, boolean needLock) {
3881 return lifecycleBusinessLogic.forceResourceCertification(resource, user, lifecycleChangeInfo, inTransaction,
3885 public ImmutablePair<Resource, ActionStatus> createOrUpdateResourceByImport(final Resource resource,
3887 final boolean isNormative,
3888 final boolean isInTransaction,
3889 final boolean needLock,
3890 final CsarInfo csarInfo,
3891 final String nodeName,
3892 final boolean isNested) {
3894 ImmutablePair<Resource, ActionStatus> result = null;
3895 // check if resource already exists (search by tosca name = type)
3896 final boolean isNestedResource = isNestedResourceUpdate(csarInfo, nodeName);
3897 final Either<Resource, StorageOperationStatus> latestByToscaName = toscaOperationFacade
3898 .getLatestByToscaResourceName(resource.getToscaResourceName());
3900 if (latestByToscaName.isLeft()) {
3901 Resource foundResource = latestByToscaName.left().value();
3902 // we don't allow updating names of top level types
3903 if (!isNestedResource && !StringUtils.equals(resource.getName(), foundResource.getName())) {
3904 BeEcompErrorManager.getInstance().logBeComponentMissingError("Create / Update resource by import",
3905 ComponentTypeEnum.RESOURCE.getValue(), resource.getName());
3906 log.debug("resource already exist new name={} old name={} same type={}", resource.getName(),
3907 foundResource.getName(), resource.getToscaResourceName());
3908 final ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESOURCE_ALREADY_EXISTS);
3909 componentsUtils.auditResource(responseFormat, user, resource, AuditingActionEnum.IMPORT_RESOURCE);
3910 throwComponentException(responseFormat);
3912 result = updateExistingResourceByImport(resource, foundResource, user, isNormative, needLock, isNested);
3913 } else if (isNotFound(latestByToscaName)) {
3914 if (isNestedResource) {
3915 result = createOrUpdateNestedResource(resource, user, isNormative, isInTransaction, needLock, csarInfo,
3916 isNested, nodeName);
3918 result = createResourceByImport(resource, user, isNormative, isInTransaction, csarInfo);
3921 StorageOperationStatus status = latestByToscaName.right().value();
3922 log.debug("failed to get latest version of resource {}. status={}", resource.getName(), status);
3923 ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(componentsUtils
3924 .convertFromStorageResponse(latestByToscaName.right().value()), resource);
3925 componentsUtils.auditResource(responseFormat, user, resource, AuditingActionEnum.IMPORT_RESOURCE);
3926 throwComponentException(responseFormat);
3931 private boolean isNestedResourceUpdate(CsarInfo csarInfo, String nodeName) {
3932 return csarInfo != null && csarInfo.isUpdate() && nodeName != null;
3935 private ImmutablePair<Resource, ActionStatus> createOrUpdateNestedResource(final Resource resource,
3937 final boolean isNormative,
3938 final boolean isInTransaction,
3939 final boolean needLock,
3940 final CsarInfo csarInfo,
3941 final boolean isNested,
3942 final String nodeName) {
3943 final Either<Component, StorageOperationStatus> latestByToscaName = toscaOperationFacade
3944 .getLatestByToscaResourceName(buildNestedToscaResourceName(resource.getResourceType()
3945 .name(), csarInfo.getVfResourceName(), nodeName).getRight());
3946 if (latestByToscaName.isLeft()) {
3947 final Resource nestedResource = (Resource) latestByToscaName.left().value();
3948 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
3949 final Either<Boolean, ResponseFormat> eitherValidation = validateNestedDerivedFromDuringUpdate(nestedResource,
3950 resource, ValidationUtils.hasBeenCertified(nestedResource.getVersion()));
3951 if (eitherValidation.isRight()) {
3952 return createResourceByImport(resource, user, isNormative, isInTransaction, csarInfo);
3954 return updateExistingResourceByImport(resource, nestedResource, user, isNormative, needLock, isNested);
3956 return createResourceByImport(resource, user, isNormative, isInTransaction, csarInfo);
3960 private boolean isNotFound(Either<Resource, StorageOperationStatus> getResourceEither) {
3961 return getResourceEither.isRight() && getResourceEither.right()
3962 .value() == StorageOperationStatus.NOT_FOUND;
3965 private ImmutablePair<Resource, ActionStatus> createResourceByImport(Resource resource, User user,
3966 boolean isNormative, boolean isInTransaction, CsarInfo csarInfo) {
3967 log.debug("resource with name {} does not exist. create new resource", resource.getName());
3968 validateResourceBeforeCreate(resource, user, AuditingActionEnum.IMPORT_RESOURCE, isInTransaction, csarInfo);
3969 final Resource createResourceByDao = createResourceByDao(resource, user, AuditingActionEnum.IMPORT_RESOURCE, isNormative,
3971 Resource createdResource = updateCatalog(createResourceByDao, ChangeTypeEnum.LIFECYCLE).left().map(r -> (Resource)r).left().value();
3972 ImmutablePair<Resource, ActionStatus> resourcePair = new ImmutablePair<>(createdResource, ActionStatus.CREATED);
3973 ASDCKpiApi.countImportResourcesKPI();
3974 return resourcePair;
3977 public boolean isResourceExist(String resourceName) {
3978 Either<Resource, StorageOperationStatus> latestByName = toscaOperationFacade.getLatestByName(resourceName);
3979 return latestByName.isLeft();
3982 private ImmutablePair<Resource, ActionStatus> updateExistingResourceByImport(Resource newResource,
3983 Resource oldResource, User user, boolean inTransaction, boolean needLock, boolean isNested) {
3984 String lockedResourceId = oldResource.getUniqueId();
3985 log.debug("found resource: name={}, id={}, version={}, state={}", oldResource.getName(), lockedResourceId,
3986 oldResource.getVersion(), oldResource.getLifecycleState());
3987 ImmutablePair<Resource, ActionStatus> resourcePair = null;
3989 lockComponent(lockedResourceId, oldResource, needLock, "Update Resource by Import");
3990 oldResource = prepareResourceForUpdate(oldResource, newResource, user, inTransaction, false);
3991 mergeOldResourceMetadataWithNew(oldResource, newResource);
3993 validateResourceFieldsBeforeUpdate(oldResource, newResource, inTransaction, isNested);
3994 validateCapabilityTypesCreate(user, getCapabilityTypeOperation(), newResource, AuditingActionEnum.IMPORT_RESOURCE, inTransaction);
3995 // contact info normalization
3996 newResource.setContactId(newResource.getContactId().toLowerCase());
3997 PropertyConstraintsUtils.validatePropertiesConstraints(newResource, oldResource);
3998 // non-updatable fields
3999 newResource.setCreatorUserId(user.getUserId());
4000 newResource.setCreatorFullName(user.getFullName());
4001 newResource.setLastUpdaterUserId(user.getUserId());
4002 newResource.setLastUpdaterFullName(user.getFullName());
4003 newResource.setUniqueId(oldResource.getUniqueId());
4004 newResource.setVersion(oldResource.getVersion());
4005 newResource.setInvariantUUID(oldResource.getInvariantUUID());
4006 newResource.setLifecycleState(oldResource.getLifecycleState());
4007 newResource.setUUID(oldResource.getUUID());
4008 newResource.setNormalizedName(oldResource.getNormalizedName());
4009 newResource.setSystemName(oldResource.getSystemName());
4010 if (oldResource.getCsarUUID() != null) {
4011 newResource.setCsarUUID(oldResource.getCsarUUID());
4013 if (oldResource.getImportedToscaChecksum() != null) {
4014 newResource.setImportedToscaChecksum(oldResource.getImportedToscaChecksum());
4016 newResource.setAbstract(oldResource.isAbstract());
4018 if (CollectionUtils.isEmpty(newResource.getDerivedFrom())){
4019 newResource.setDerivedFrom(oldResource.getDerivedFrom());
4021 if (CollectionUtils.isEmpty(newResource.getDataTypes())){
4022 newResource.setDataTypes(oldResource.getDataTypes());
4024 if (StringUtils.isEmpty(newResource.getDerivedFromGenericType())){
4025 newResource.setDerivedFromGenericType(oldResource.getDerivedFromGenericType());
4027 if (StringUtils.isEmpty(newResource.getDerivedFromGenericVersion())){
4028 newResource.setDerivedFromGenericVersion(oldResource.getDerivedFromGenericVersion());
4031 // created without tosca artifacts - add the placeholders
4032 if (MapUtils.isEmpty(newResource.getToscaArtifacts())){
4033 setToscaArtifactsPlaceHolders(newResource, user);
4036 if (MapUtils.isEmpty(newResource.getInterfaces())){
4037 newResource.setInterfaces(oldResource.getInterfaces());
4039 if (CollectionUtils.isEmpty(newResource.getAttributes())) {
4040 newResource.setAttributes(oldResource.getAttributes());
4043 if (CollectionUtils.isEmpty(newResource.getProperties())) {
4044 newResource.setProperties(oldResource.getProperties());
4047 Either<Resource, StorageOperationStatus> overrideResource = toscaOperationFacade.overrideComponent(newResource, oldResource);
4049 if (overrideResource.isRight()) {
4050 ResponseFormat responseFormat = componentsUtils
4051 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(overrideResource.right()
4052 .value()), newResource);
4053 componentsUtils.auditResource(responseFormat, user, newResource, AuditingActionEnum.IMPORT_RESOURCE);
4055 throwComponentException(responseFormat);
4057 updateCatalog(overrideResource.left()
4058 .value(), ChangeTypeEnum.LIFECYCLE);
4060 log.debug("Resource updated successfully!!!");
4061 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
4062 componentsUtils.auditResource(responseFormat, user, newResource, AuditingActionEnum.IMPORT_RESOURCE,
4063 ResourceVersionInfo.newBuilder()
4064 .state(oldResource.getLifecycleState()
4066 .version(oldResource.getVersion())
4069 resourcePair = new ImmutablePair<>(overrideResource.left()
4070 .value(), ActionStatus.OK);
4071 return resourcePair;
4073 if (resourcePair == null) {
4074 BeEcompErrorManager.getInstance()
4075 .logBeSystemError("Change LifecycleState - Certify");
4076 janusGraphDao.rollback();
4077 } else if (!inTransaction) {
4078 janusGraphDao.commit();
4081 log.debug("unlock resource {}", lockedResourceId);
4082 graphLockOperation.unlockComponent(lockedResourceId, NodeTypeEnum.Resource);
4089 * Merge old resource with new. Keep old category and vendor name without
4092 * @param oldResource
4093 * @param newResource
4095 private void mergeOldResourceMetadataWithNew(Resource oldResource, Resource newResource) {
4097 // keep old category and vendor name without change
4098 // merge the rest of the resource metadata
4099 if (newResource.getTags() == null || newResource.getTags().isEmpty()) {
4100 newResource.setTags(oldResource.getTags());
4103 if (newResource.getDescription() == null) {
4104 newResource.setDescription(oldResource.getDescription());
4107 if (newResource.getVendorRelease() == null) {
4108 newResource.setVendorRelease(oldResource.getVendorRelease());
4111 if (newResource.getResourceVendorModelNumber() == null) {
4112 newResource.setResourceVendorModelNumber(oldResource.getResourceVendorModelNumber());
4115 if (newResource.getContactId() == null) {
4116 newResource.setContactId(oldResource.getContactId());
4119 newResource.setCategories(oldResource.getCategories());
4120 if (newResource.getVendorName() == null) {
4121 newResource.setVendorName(oldResource.getVendorName());
4123 List<GroupDefinition>oldForUpdate = oldResource.getGroups();
4124 if(CollectionUtils.isNotEmpty(oldForUpdate)){
4125 List<GroupDefinition>groupForUpdate = oldForUpdate.stream().map(group -> new GroupDefinition(group)).collect(Collectors.toList());
4127 groupForUpdate.stream().filter(group -> group.isVspOriginated())
4128 .forEach(group -> group.setName(group.getInvariantName()));
4130 newResource.setGroups(groupForUpdate);
4134 if(newResource.getResourceType().isAtomicType() && !newResource.getName().equals("Root")&& newResource.getResourceType() != ResourceTypeEnum.CVFC) {
4135 ResourceTypeEnum updatedResourceType = newResource.getResourceType();
4136 Component derivedFromResource = getParentComponent(newResource);
4137 if (derivedFromResource.getComponentType() == ComponentTypeEnum.RESOURCE) {
4138 Resource parentResource = (Resource) derivedFromResource;
4139 if (!(parentResource.isAbstract() && (ResourceTypeEnum.VFC == parentResource.getResourceType() || ResourceTypeEnum.ABSTRACT == parentResource.getResourceType())) &&
4140 parentResource.getResourceType() != updatedResourceType) {
4141 BeEcompErrorManager.getInstance()
4142 .logInternalDataError("mergeOldResourceMetadataWithNew", "resource type of the resource does not match to derived from resource type",
4143 ErrorSeverity.ERROR);
4144 log.debug("#mergeOldResourceMetadataWithNew - resource type {} of the resource {} does not match to derived from resource type {}",
4145 newResource.getResourceType(), newResource.getToscaResourceName(), parentResource.getResourceType());
4146 throw new ByActionStatusComponentException(ActionStatus.INVALID_RESOURCE_TYPE);
4153 private Component getParentComponent(Resource newResource) {
4154 String toscaResourceNameDerivedFrom = newResource.getDerivedFrom().get(0);
4155 Either<Component, StorageOperationStatus> latestByToscaResourceName = toscaOperationFacade.getLatestByToscaResourceName(toscaResourceNameDerivedFrom);
4156 if(latestByToscaResourceName.isRight()){
4157 BeEcompErrorManager.getInstance()
4158 .logInternalDataError("mergeOldResourceMetadataWithNew", "derived from resource not found", ErrorSeverity.ERROR);
4159 log.debug("#mergeOldResourceMetadataWithNew - derived from resource {} not found", toscaResourceNameDerivedFrom);
4160 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_NOT_FOUND, toscaResourceNameDerivedFrom);
4162 return latestByToscaResourceName.left().value();
4165 private Resource prepareResourceForUpdate(Resource oldResource, Resource newResource, User user,
4166 boolean inTransaction, boolean needLock) {
4168 if (!ComponentValidationUtils.canWorkOnResource(oldResource, user.getUserId())) {
4170 return lifecycleBusinessLogic.changeState(oldResource.getUniqueId(), user, LifeCycleTransitionEnum.CHECKOUT,
4171 new LifecycleChangeInfoWithAction("update by import"), inTransaction, needLock)
4173 .on(response -> failOnChangeState(response, user, oldResource, newResource));
4178 private Resource failOnChangeState(ResponseFormat response, User user, Resource oldResource, Resource newResource) {
4179 log.info("resource {} cannot be updated. reason={}", oldResource.getUniqueId(), response.getFormattedMessage());
4180 componentsUtils.auditResource(response, user, newResource, AuditingActionEnum.IMPORT_RESOURCE,
4181 ResourceVersionInfo.newBuilder()
4182 .state(oldResource.getLifecycleState()
4184 .version(oldResource.getVersion())
4186 throw new ByResponseFormatComponentException(response);
4189 public Resource validateResourceBeforeCreate(Resource resource, User user, AuditingActionEnum actionEnum,
4190 boolean inTransaction, CsarInfo csarInfo) {
4192 validateResourceFieldsBeforeCreate(user, resource, actionEnum, inTransaction);
4193 validateCapabilityTypesCreate(user, getCapabilityTypeOperation(), resource, actionEnum, inTransaction);
4194 validateLifecycleTypesCreate(user, resource, actionEnum);
4195 validateResourceType(user, resource, actionEnum);
4196 resource.setCreatorUserId(user.getUserId());
4197 resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName());
4198 resource.setContactId(resource.getContactId()
4200 if (StringUtils.isEmpty(resource.getToscaResourceName()) && !ModelConverter.isAtomicComponent(resource)) {
4201 String resourceSystemName;
4202 if (csarInfo != null && StringUtils.isNotEmpty(csarInfo.getVfResourceName())) {
4203 resourceSystemName = ValidationUtils.convertToSystemName(csarInfo.getVfResourceName());
4205 resourceSystemName = resource.getSystemName();
4207 resource.setToscaResourceName(CommonBeUtils
4208 .generateToscaResourceName(resource.getResourceType().name().toLowerCase(), resourceSystemName));
4211 // Generate invariant UUID - must be here and not in operation since it
4212 // should stay constant during clone
4214 String invariantUUID = UniqueIdBuilder.buildInvariantUUID();
4215 resource.setInvariantUUID(invariantUUID);
4220 private Either<Boolean, ResponseFormat> validateResourceType(User user, Resource resource,
4221 AuditingActionEnum actionEnum) {
4222 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
4223 if (resource.getResourceType() == null) {
4224 log.debug("Invalid resource type for resource");
4225 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT);
4226 eitherResult = Either.right(errorResponse);
4227 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
4229 return eitherResult;
4232 private Either<Boolean, ResponseFormat> validateLifecycleTypesCreate(User user, Resource resource,
4233 AuditingActionEnum actionEnum) {
4234 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
4235 if (resource.getInterfaces() != null && resource.getInterfaces()
4237 log.debug("validate interface lifecycle Types Exist");
4238 Iterator<InterfaceDefinition> intItr = resource.getInterfaces()
4241 while (intItr.hasNext() && eitherResult.isLeft()) {
4242 InterfaceDefinition interfaceDefinition = intItr.next();
4243 String intType = interfaceDefinition.getUniqueId();
4244 Either<InterfaceDefinition, StorageOperationStatus> eitherCapTypeFound = interfaceTypeOperation
4245 .getInterface(intType);
4246 if (eitherCapTypeFound.isRight()) {
4247 if (eitherCapTypeFound.right()
4248 .value() == StorageOperationStatus.NOT_FOUND) {
4249 BeEcompErrorManager.getInstance()
4250 .logBeGraphObjectMissingError("Create Resource - validateLifecycleTypesCreate",
4251 "Interface", intType);
4252 log.debug("Lifecycle Type: {} is required by resource: {} but does not exist in the DB",
4253 intType, resource.getName());
4254 BeEcompErrorManager.getInstance()
4255 .logBeDaoSystemError("Create Resource - validateLifecycleTypesCreate");
4256 log.debug("request to data model failed with error: {}", eitherCapTypeFound.right()
4261 ResponseFormat errorResponse = componentsUtils
4262 .getResponseFormat(ActionStatus.MISSING_LIFECYCLE_TYPE, intType);
4263 eitherResult = Either.right(errorResponse);
4264 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
4269 return eitherResult;
4272 private Either<Boolean, ResponseFormat> validateCapabilityTypesCreate(User user,
4273 ICapabilityTypeOperation capabilityTypeOperation, Resource resource, AuditingActionEnum actionEnum,
4274 boolean inTransaction) {
4276 Either<Boolean, ResponseFormat> eitherResult = Either.left(true);
4277 if (resource.getCapabilities() != null && resource.getCapabilities()
4279 log.debug("validate capability Types Exist - capabilities section");
4281 for (Entry<String, List<CapabilityDefinition>> typeEntry : resource.getCapabilities()
4284 eitherResult = validateCapabilityTypeExists(user, capabilityTypeOperation, resource, actionEnum,
4285 eitherResult, typeEntry, inTransaction);
4286 if (eitherResult.isRight()) {
4287 return Either.right(eitherResult.right()
4293 if (resource.getRequirements() != null && resource.getRequirements()
4295 log.debug("validate capability Types Exist - requirements section");
4296 for (String type : resource.getRequirements()
4298 eitherResult = validateCapabilityTypeExists(user, capabilityTypeOperation, resource,
4299 resource.getRequirements()
4301 actionEnum, eitherResult, type, inTransaction);
4302 if (eitherResult.isRight()) {
4303 return Either.right(eitherResult.right()
4309 return eitherResult;
4312 // @param typeObject- the object to which the validation is done
4313 private Either<Boolean, ResponseFormat> validateCapabilityTypeExists(User user,
4314 ICapabilityTypeOperation capabilityTypeOperation, Resource resource, List<?> validationObjects,
4315 AuditingActionEnum actionEnum, Either<Boolean, ResponseFormat> eitherResult, String type,
4316 boolean inTransaction) {
4317 Either<CapabilityTypeDefinition, StorageOperationStatus> eitherCapTypeFound = capabilityTypeOperation
4318 .getCapabilityType(type, inTransaction);
4319 if (eitherCapTypeFound.isRight()) {
4320 if (eitherCapTypeFound.right()
4321 .value() == StorageOperationStatus.NOT_FOUND) {
4322 BeEcompErrorManager.getInstance()
4323 .logBeGraphObjectMissingError(CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES, "Capability Type",
4325 log.debug("Capability Type: {} is required by resource: {} but does not exist in the DB", type,
4326 resource.getName());
4327 BeEcompErrorManager.getInstance()
4328 .logBeDaoSystemError(CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES);
4330 log.debug("Trying to get capability type {} failed with error: {}", type, eitherCapTypeFound.right()
4333 ResponseFormat errorResponse = null;
4335 errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_CAPABILITY_TYPE, type);
4337 errorResponse = componentsUtils.getResponseFormatByElement(ActionStatus.MISSING_CAPABILITY_TYPE,
4340 eitherResult = Either.right(errorResponse);
4341 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
4343 return eitherResult;
4346 private Either<Boolean, ResponseFormat> validateCapabilityTypeExists(User user,
4347 ICapabilityTypeOperation capabilityTypeOperation, Resource resource, AuditingActionEnum actionEnum,
4348 Either<Boolean, ResponseFormat> eitherResult, Entry<String, List<CapabilityDefinition>> typeEntry,
4349 boolean inTransaction) {
4350 Either<CapabilityTypeDefinition, StorageOperationStatus> eitherCapTypeFound = capabilityTypeOperation
4351 .getCapabilityType(typeEntry.getKey(), inTransaction);
4352 if (eitherCapTypeFound.isRight()) {
4353 if (eitherCapTypeFound.right().value() == StorageOperationStatus.NOT_FOUND) {
4354 BeEcompErrorManager.getInstance()
4355 .logBeGraphObjectMissingError(CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES, "Capability Type",
4356 typeEntry.getKey());
4357 log.debug("Capability Type: {} is required by resource: {} but does not exist in the DB",
4358 typeEntry.getKey(), resource.getName());
4359 BeEcompErrorManager.getInstance().logBeDaoSystemError(CREATE_RESOURCE_VALIDATE_CAPABILITY_TYPES);
4361 log.debug("Trying to get capability type {} failed with error: {}", typeEntry.getKey(),
4362 eitherCapTypeFound.right().value().name());
4363 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_CAPABILITY_TYPE,
4364 typeEntry.getKey());
4365 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
4366 return Either.right(errorResponse);
4368 CapabilityTypeDefinition capabilityTypeDefinition = eitherCapTypeFound.left().value();
4369 if (capabilityTypeDefinition.getProperties() != null) {
4370 for (CapabilityDefinition capDef : typeEntry.getValue()) {
4371 List<ComponentInstanceProperty> properties = capDef.getProperties();
4372 List<ComponentInstanceProperty> changedProperties = new ArrayList<>();
4373 if (properties == null || properties.isEmpty()) {
4374 for (Entry<String, PropertyDefinition> prop : capabilityTypeDefinition.getProperties().entrySet()) {
4375 ComponentInstanceProperty newProp = new ComponentInstanceProperty(prop.getValue());
4376 changedProperties.add(newProp);
4379 List<ComponentInstanceProperty> propsToAdd = new ArrayList<>();
4380 for (Entry<String, PropertyDefinition> prop : capabilityTypeDefinition.getProperties().entrySet()) {
4381 PropertyDefinition propFromDef = prop.getValue();
4382 boolean propFound = false;
4383 for (ComponentInstanceProperty cip : properties) {
4384 if (propFromDef.getName().equals(cip.getName())) {
4385 //merge property value and property description only, ignore other fields
4386 if(cip.getDescription() != null && !cip.getDescription().equals(propFromDef.getDescription())){
4387 propFromDef.setDescription(cip.getDescription());
4389 propertyDataValueMergeBusinessLogic.mergePropertyValue(propFromDef, cip, new ArrayList<>());
4390 if(cip.getValue() != null){
4391 propFromDef.setValue(cip.getValue());
4393 propsToAdd.add(new ComponentInstanceProperty(propFromDef));
4395 properties.remove(cip);
4400 propsToAdd.add(new ComponentInstanceProperty(propFromDef));
4403 if (!propsToAdd.isEmpty()) {
4404 changedProperties.addAll(propsToAdd);
4407 capDef.setProperties(changedProperties);
4410 return eitherResult;
4413 public Resource createResourceByDao(Resource resource, User user, AuditingActionEnum actionEnum,
4414 boolean isNormative, boolean inTransaction) {
4417 // lock new resource name in order to avoid creation resource with same
4419 Resource createdResource = null;
4420 if (!inTransaction) {
4421 Either<Boolean, ResponseFormat> lockResult = lockComponentByName(resource.getSystemName(), resource,
4423 if (lockResult.isRight()) {
4424 ResponseFormat responseFormat = lockResult.right().value();
4425 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
4426 throw new ByResponseFormatComponentException(responseFormat);
4429 log.debug("name is locked {} status = {}", resource.getSystemName(), lockResult);
4432 if (resource.deriveFromGeneric()) {
4433 handleResourceGenericType(resource);
4435 createdResource = createResourceTransaction(resource, user, isNormative);
4436 componentsUtils.auditResource(componentsUtils.getResponseFormat(ActionStatus.CREATED), user,
4437 createdResource, actionEnum);
4438 ASDCKpiApi.countCreatedResourcesKPI();
4439 } catch (ComponentException e) {
4440 ResponseFormat responseFormat = e.getResponseFormat() == null
4441 ? componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()) : e.getResponseFormat();
4442 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
4444 } catch (StorageException e) {
4445 ResponseFormat responseFormat = componentsUtils
4446 .getResponseFormat(componentsUtils.convertFromStorageResponse(e.getStorageOperationStatus()));
4447 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
4450 if (!inTransaction) {
4451 graphLockOperation.unlockComponentByName(resource.getSystemName(), resource.getUniqueId(),
4452 NodeTypeEnum.Resource);
4455 return createdResource;
4458 private Resource createResourceTransaction(Resource resource, User user, boolean isNormative) {
4459 // validate resource name uniqueness
4460 log.debug("validate resource name");
4461 Either<Boolean, StorageOperationStatus> eitherValidation = toscaOperationFacade.validateComponentNameExists(
4462 resource.getName(), resource.getResourceType(), resource.getComponentType());
4463 if (eitherValidation.isRight()) {
4464 loggerSupportability.log(LoggerSupportabilityActions.VALIDATE_NAME,resource.getComponentMetadataForSupportLog(),
4465 StatusCode.ERROR,"ERROR while validate component name {} Status is: {}",resource.getName(),eitherValidation.right().value());
4466 log.debug("Failed to validate component name {}. Status is {}. ", resource.getName(),
4467 eitherValidation.right()
4469 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(eitherValidation.right()
4472 if (eitherValidation.left()
4474 log.debug("resource with name: {}, already exists", resource.getName());
4475 loggerSupportability.log(LoggerSupportabilityActions.CREATE_RESOURCE_FROM_YAML,resource.getComponentMetadataForSupportLog(),
4476 StatusCode.ERROR,"resource with name: {} already exists",resource.getName());
4477 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_NAME_ALREADY_EXIST,
4478 ComponentTypeEnum.RESOURCE.getValue(), resource.getName());
4481 log.debug("send resource {} to dao for create", resource.getName());
4483 createArtifactsPlaceHolderData(resource, user);
4486 log.debug("enrich resource with creator, version and state");
4487 resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
4488 resource.setVersion(INITIAL_VERSION);
4489 resource.setHighestVersion(true);
4490 if (resource.getResourceType() != null && resource.getResourceType() != ResourceTypeEnum.CVFC) {
4491 resource.setAbstract(false);
4494 return toscaOperationFacade.createToscaComponent(resource)
4496 .on(r -> throwComponentExceptionByResource(r, resource));
4499 private Resource throwComponentExceptionByResource(StorageOperationStatus status, Resource resource) {
4500 ResponseFormat responseFormat = componentsUtils
4501 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(status), resource);
4502 throw new ByResponseFormatComponentException(responseFormat);
4505 private void createArtifactsPlaceHolderData(Resource resource, User user) {
4506 // create mandatory artifacts
4508 // TODO it must be removed after that artifact uniqueId creation will be
4509 // moved to ArtifactOperation
4511 setInformationalArtifactsPlaceHolder(resource, user);
4512 setDeploymentArtifactsPlaceHolder(resource, user);
4513 setToscaArtifactsPlaceHolders(resource, user);
4516 @SuppressWarnings("unchecked")
4518 public void setDeploymentArtifactsPlaceHolder(Component component, User user) {
4519 Resource resource = (Resource) component;
4520 Map<String, ArtifactDefinition> artifactMap = resource.getDeploymentArtifacts();
4521 if (artifactMap == null) {
4522 artifactMap = new HashMap<>();
4524 Map<String, Object> deploymentResourceArtifacts = ConfigurationManager.getConfigurationManager()
4526 .getDeploymentResourceArtifacts();
4527 if (deploymentResourceArtifacts != null) {
4528 Map<String, ArtifactDefinition> finalArtifactMap = artifactMap;
4529 deploymentResourceArtifacts
4530 .forEach((k, v) -> processDeploymentResourceArtifacts(user, resource, finalArtifactMap, k, v));
4532 resource.setDeploymentArtifacts(artifactMap);
4535 private void processDeploymentResourceArtifacts(User user, Resource resource,
4536 Map<String, ArtifactDefinition> artifactMap, String k, Object v) {
4537 boolean shouldCreateArtifact = true;
4538 Map<String, Object> artifactDetails = (Map<String, Object>) v;
4539 Object object = artifactDetails.get(PLACE_HOLDER_RESOURCE_TYPES);
4540 if (object != null) {
4541 List<String> artifactTypes = (List<String>) object;
4542 if (!artifactTypes.contains(resource.getResourceType()
4544 shouldCreateArtifact = false;
4548 log.info("resource types for artifact placeholder {} were not defined. default is all resources", k);
4550 if (shouldCreateArtifact) {
4551 if (artifactsBusinessLogic != null) {
4552 ArtifactDefinition artifactDefinition = artifactsBusinessLogic.createArtifactPlaceHolderInfo(
4553 resource.getUniqueId(), k, (Map<String, Object>) v, user, ArtifactGroupTypeEnum.DEPLOYMENT);
4554 if (artifactDefinition != null && !artifactMap.containsKey(artifactDefinition.getArtifactLabel())) {
4555 artifactMap.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
4561 @SuppressWarnings("unchecked")
4562 private void setInformationalArtifactsPlaceHolder(Resource resource, User user) {
4563 Map<String, ArtifactDefinition> artifactMap = resource.getArtifacts();
4564 if (artifactMap == null) {
4565 artifactMap = new HashMap<>();
4567 String resourceUniqueId = resource.getUniqueId();
4568 List<String> exludeResourceCategory = ConfigurationManager.getConfigurationManager()
4570 .getExcludeResourceCategory();
4571 List<String> exludeResourceType = ConfigurationManager.getConfigurationManager()
4573 .getExcludeResourceType();
4574 Map<String, Object> informationalResourceArtifacts = ConfigurationManager.getConfigurationManager()
4576 .getInformationalResourceArtifacts();
4577 List<CategoryDefinition> categories = resource.getCategories();
4578 boolean isCreateArtifact = true;
4579 if (exludeResourceCategory != null) {
4580 String category = categories.get(0)
4582 isCreateArtifact = exludeResourceCategory.stream()
4583 .noneMatch(e -> e.equalsIgnoreCase(category));
4585 if (isCreateArtifact && exludeResourceType != null) {
4586 String resourceType = resource.getResourceType()
4588 isCreateArtifact = exludeResourceType.stream()
4589 .noneMatch(e -> e.equalsIgnoreCase(resourceType));
4591 if (informationalResourceArtifacts != null && isCreateArtifact) {
4592 Set<String> keys = informationalResourceArtifacts.keySet();
4593 for (String informationalResourceArtifactName : keys) {
4594 Map<String, Object> artifactInfoMap = (Map<String, Object>) informationalResourceArtifacts
4595 .get(informationalResourceArtifactName);
4596 ArtifactDefinition artifactDefinition = artifactsBusinessLogic.createArtifactPlaceHolderInfo(
4597 resourceUniqueId, informationalResourceArtifactName, artifactInfoMap, user,
4598 ArtifactGroupTypeEnum.INFORMATIONAL);
4599 artifactMap.put(artifactDefinition.getArtifactLabel(), artifactDefinition);
4603 resource.setArtifacts(artifactMap);
4613 public ResponseFormat deleteResource(String resourceId, User user) {
4614 ResponseFormat responseFormat;
4615 validateUserExists(user);
4617 Either<Resource, StorageOperationStatus> resourceStatus = toscaOperationFacade.getToscaElement(resourceId);
4618 if (resourceStatus.isRight()) {
4619 log.debug("failed to get resource {}", resourceId);
4620 return componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(resourceStatus.right()
4624 Resource resource = resourceStatus.left()
4627 StorageOperationStatus result = StorageOperationStatus.OK;
4628 lockComponent(resourceId, resource, "Mark resource to delete");
4631 result = markComponentToDelete(resource);
4632 if (result == StorageOperationStatus.OK) {
4633 responseFormat = componentsUtils.getResponseFormat(ActionStatus.NO_CONTENT);
4635 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(result);
4636 responseFormat = componentsUtils.getResponseFormatByResource(actionStatus, resource.getName());
4638 return responseFormat;
4641 if (result == null || result != StorageOperationStatus.OK) {
4642 janusGraphDao.rollback();
4644 janusGraphDao.commit();
4646 graphLockOperation.unlockComponent(resourceId, NodeTypeEnum.Resource);
4651 public ResponseFormat deleteResourceByNameAndVersion(String resourceName, String version, User user) {
4652 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.NO_CONTENT);
4653 validateUserExists(user);
4654 Resource resource = null;
4655 StorageOperationStatus result = StorageOperationStatus.OK;
4656 boolean failed = false;
4659 Either<Resource, StorageOperationStatus> resourceStatus = toscaOperationFacade
4660 .getComponentByNameAndVersion(ComponentTypeEnum.RESOURCE, resourceName, version);
4661 if (resourceStatus.isRight()) {
4662 log.debug("failed to get resource {} version {}", resourceName, version);
4663 return componentsUtils
4664 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(resourceStatus.right()
4665 .value()), resourceName);
4668 resource = resourceStatus.left()
4672 janusGraphDao.commit();
4674 if (resource != null) {
4675 lockComponent(resource.getUniqueId(), resource, DELETE_RESOURCE);
4677 result = markComponentToDelete(resource);
4678 if (result != StorageOperationStatus.OK) {
4679 ActionStatus actionStatus = componentsUtils.convertFromStorageResponse(result);
4680 responseFormat = componentsUtils.getResponseFormatByResource(actionStatus, resource.getName());
4681 return responseFormat;
4683 }catch (ComponentException e){
4687 if (failed || result == null || result != StorageOperationStatus.OK) {
4688 janusGraphDao.rollback();
4690 janusGraphDao.commit();
4692 graphLockOperation.unlockComponent(resource.getUniqueId(), NodeTypeEnum.Resource);
4695 return responseFormat;
4698 public Either<Resource, ResponseFormat> getResource(String resourceId, User user) {
4701 validateUserExists(user);
4704 Either<Resource, StorageOperationStatus> storageStatus = toscaOperationFacade.getToscaElement(resourceId);
4705 if (storageStatus.isRight()) {
4706 log.debug("failed to get resource by id {}", resourceId);
4707 return Either.right(componentsUtils
4708 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(storageStatus.right()
4709 .value()), resourceId));
4711 if (!(storageStatus.left()
4712 .value() instanceof Resource)) {
4713 return Either.right(componentsUtils.getResponseFormatByResource(
4714 componentsUtils.convertFromStorageResponse(StorageOperationStatus.NOT_FOUND), resourceId));
4716 return Either.left(storageStatus.left()
4721 public Either<Resource, ResponseFormat> getResourceByNameAndVersion(String resourceName, String resourceVersion,
4724 validateUserExists(userId);
4726 Either<Resource, StorageOperationStatus> getResource = toscaOperationFacade
4727 .getComponentByNameAndVersion(ComponentTypeEnum.RESOURCE, resourceName, resourceVersion);
4728 if (getResource.isRight()) {
4729 log.debug("failed to get resource by name {} and version {}", resourceName, resourceVersion);
4730 return Either.right(componentsUtils
4731 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(getResource.right()
4732 .value()), resourceName));
4734 return Either.left(getResource.left()
4739 * updateResourceMetadata
4742 * - modifier data (userId)
4743 * @param inTransaction
4745 * @param resourceIdToUpdate
4746 * - the resource identifier
4747 * @param newResource
4748 * @return Either<Resource , responseFormat>
4750 public Resource updateResourceMetadata(String resourceIdToUpdate, Resource newResource, Resource currentResource,
4751 User user, boolean inTransaction) {
4753 validateUserExists(user.getUserId());
4755 log.debug("Get resource with id {}", resourceIdToUpdate);
4756 boolean needToUnlock = false;
4759 if (currentResource == null) {
4760 Either<Resource, StorageOperationStatus> storageStatus = toscaOperationFacade
4761 .getToscaElement(resourceIdToUpdate);
4762 if (storageStatus.isRight()) {
4763 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormatByResource(
4764 componentsUtils.convertFromStorageResponse(storageStatus.right()
4769 currentResource = storageStatus.left()
4772 // verify that resource is checked-out and the user is the last
4774 if (!ComponentValidationUtils.canWorkOnResource(currentResource, user.getUserId())) {
4775 throw new ByResponseFormatComponentException(componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION));
4779 StorageOperationStatus lockResult = graphLockOperation.lockComponent(resourceIdToUpdate,
4780 NodeTypeEnum.Resource);
4781 if (lockResult != StorageOperationStatus.OK) {
4782 BeEcompErrorManager.getInstance()
4783 .logBeFailedLockObjectError("Upload Artifact - lock ", NodeTypeEnum.Resource.getName(),
4784 resourceIdToUpdate);
4785 log.debug("Failed to lock resource: {}, error - {}", resourceIdToUpdate, lockResult);
4786 ResponseFormat responseFormat = componentsUtils
4787 .getResponseFormat(componentsUtils.convertFromStorageResponse(lockResult));
4788 throw new ByResponseFormatComponentException(responseFormat);
4791 needToUnlock = true;
4793 // critical section starts here
4794 // convert json to object
4796 // Update and updated resource must have a non-empty "derivedFrom"
4798 // This code is not called from import resources, because of root
4799 // VF "derivedFrom" should be null (or ignored)
4800 if (ModelConverter.isAtomicComponent(currentResource)) {
4801 validateDerivedFromNotEmpty(null, newResource, null);
4802 validateDerivedFromNotEmpty(null, currentResource, null);
4804 newResource.setDerivedFrom(null);
4807 Either<Resource, ResponseFormat> dataModelResponse = updateResourceMetadata(resourceIdToUpdate, newResource,
4808 user, currentResource, false, true);
4809 if (dataModelResponse.isRight()) {
4810 log.debug("failed to update resource metadata!!!");
4811 throw new ByResponseFormatComponentException(dataModelResponse.right().value());
4814 log.debug("Resource metadata updated successfully!!!");
4815 return dataModelResponse.left()
4818 } catch (ComponentException | StorageException e) {
4819 rollback(inTransaction, newResource, null, null);
4822 if (!inTransaction) {
4823 janusGraphDao.commit();
4826 graphLockOperation.unlockComponent(resourceIdToUpdate, NodeTypeEnum.Resource);
4831 private Either<Resource, ResponseFormat> updateResourceMetadata(String resourceIdToUpdate, Resource newResource,
4832 User user, Resource currentResource, boolean shouldLock, boolean inTransaction) {
4833 updateVfModuleGroupsNames(currentResource, newResource);
4834 validateResourceFieldsBeforeUpdate(currentResource, newResource, inTransaction, false);
4835 // Setting last updater and uniqueId
4836 newResource.setContactId(newResource.getContactId()
4838 newResource.setLastUpdaterUserId(user.getUserId());
4839 newResource.setUniqueId(resourceIdToUpdate);
4840 // Cannot set highest version through UI
4841 newResource.setHighestVersion(currentResource.isHighestVersion());
4842 newResource.setCreationDate(currentResource.getCreationDate());
4844 Either<Boolean, ResponseFormat> processUpdateOfDerivedFrom = processUpdateOfDerivedFrom(currentResource,
4845 newResource, user.getUserId(), inTransaction);
4847 if (processUpdateOfDerivedFrom.isRight()) {
4848 log.debug("Couldn't update derived from for resource {}", resourceIdToUpdate);
4849 return Either.right(processUpdateOfDerivedFrom.right()
4853 log.debug("send resource {} to dao for update", newResource.getUniqueId());
4854 if (isNotEmpty(newResource.getGroups())) {
4855 for (GroupDefinition group : newResource.getGroups()) {
4856 if (DEFAULT_GROUP_VF_MODULE.equals(group.getType())) {
4857 groupBusinessLogic.validateAndUpdateGroupMetadata(newResource.getComponentMetadataDefinition()
4858 .getMetadataDataDefinition()
4859 .getUniqueId(), user, newResource.getComponentType(), group, true, false);
4863 Either<Resource, StorageOperationStatus> dataModelResponse = toscaOperationFacade
4864 .updateToscaElement(newResource);
4866 if (dataModelResponse.isRight()) {
4867 ResponseFormat responseFormat = componentsUtils
4868 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(dataModelResponse.right()
4869 .value()), newResource);
4870 return Either.right(responseFormat);
4871 } else if (dataModelResponse.left()
4873 log.debug("No response from updateResource");
4874 return Either.right(componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR));
4876 return Either.left(dataModelResponse.left()
4880 private void updateVfModuleGroupsNames(Resource currentResource, Resource newResource) {
4881 if (currentResource.getGroups() != null && !currentResource.getName()
4882 .equals(newResource.getName())) {
4883 List<GroupDefinition> updatedGroups = currentResource.getGroups()
4885 .map(group -> getUpdatedGroup(group, currentResource.getName(), newResource.getName()))
4887 newResource.setGroups(updatedGroups);
4891 private GroupDefinition getUpdatedGroup(GroupDefinition currGroup, String replacePattern, String with) {
4892 GroupDefinition updatedGroup = new GroupDefinition(currGroup);
4893 if (updatedGroup.isSamePrefix(replacePattern) && updatedGroup.getType()
4894 .equals(DEFAULT_GROUP_VF_MODULE)) {
4895 String prefix = updatedGroup.getName()
4896 .substring(0, replacePattern.length());
4897 String newGroupName = updatedGroup.getName()
4898 .replaceFirst(prefix, with);
4899 updatedGroup.setName(newGroupName);
4901 return updatedGroup;
4905 * validateResourceFieldsBeforeCreate
4908 * - modifier data (userId)
4910 private void validateResourceFieldsBeforeCreate(User user, Resource resource,
4911 AuditingActionEnum actionEnum, boolean inTransaction) {
4912 componentValidator.validate(user, resource, actionEnum);
4913 // validate category
4914 log.debug("validate category");
4915 validateCategory(user, resource, actionEnum, inTransaction);
4916 // validate vendor name & release & model number
4917 log.debug("validate vendor name");
4918 validateVendorName(user, resource, actionEnum);
4919 log.debug("validate vendor release");
4920 validateVendorReleaseName(user, resource, actionEnum);
4921 log.debug("validate resource vendor model number");
4922 validateResourceVendorModelNumber(user, resource, actionEnum);
4924 log.debug("validate cost");
4925 validateCost(resource);
4926 // validate licenseType
4927 log.debug("validate licenseType");
4928 validateLicenseType(user, resource, actionEnum);
4929 // validate template (derived from)
4930 log.debug("validate derived from");
4931 if (!ModelConverter.isAtomicComponent(resource) && resource.getResourceType() != ResourceTypeEnum.CVFC) {
4932 resource.setDerivedFrom(null);
4934 validateDerivedFromExist(user, resource, actionEnum);
4935 // warn about non-updatable fields
4936 checkComponentFieldsForOverrideAttempt(resource);
4937 String currentCreatorFullName = resource.getCreatorFullName();
4938 if (currentCreatorFullName != null) {
4939 log.debug("Resource Creator fullname is automatically set and cannot be updated");
4942 String currentLastUpdaterFullName = resource.getLastUpdaterFullName();
4943 if (currentLastUpdaterFullName != null) {
4944 log.debug("Resource LastUpdater fullname is automatically set and cannot be updated");
4947 Long currentLastUpdateDate = resource.getLastUpdateDate();
4948 if (currentLastUpdateDate != null) {
4949 log.debug("Resource last update date is automatically set and cannot be updated");
4952 Boolean currentAbstract = resource.isAbstract();
4953 if (currentAbstract != null) {
4954 log.debug("Resource abstract is automatically set and cannot be updated");
4959 * validateResourceFieldsBeforeUpdate
4961 * @param currentResource
4962 * - Resource object to validate
4965 private void validateResourceFieldsBeforeUpdate(Resource currentResource, Resource updateInfoResource,
4966 boolean inTransaction, boolean isNested) {
4967 validateFields(currentResource, updateInfoResource, inTransaction, isNested);
4968 warnNonEditableFields(currentResource, updateInfoResource);
4971 private void warnNonEditableFields(Resource currentResource, Resource updateInfoResource) {
4972 String currentResourceVersion = currentResource.getVersion();
4973 String updatedResourceVersion = updateInfoResource.getVersion();
4975 if ((updatedResourceVersion != null) && (!updatedResourceVersion.equals(currentResourceVersion))) {
4976 log.debug("Resource version is automatically set and cannot be updated");
4979 String currentCreatorUserId = currentResource.getCreatorUserId();
4980 String updatedCreatorUserId = updateInfoResource.getCreatorUserId();
4982 if ((updatedCreatorUserId != null) && (!updatedCreatorUserId.equals(currentCreatorUserId))) {
4983 log.debug("Resource Creator UserId is automatically set and cannot be updated");
4986 String currentCreatorFullName = currentResource.getCreatorFullName();
4987 String updatedCreatorFullName = updateInfoResource.getCreatorFullName();
4989 if ((updatedCreatorFullName != null) && (!updatedCreatorFullName.equals(currentCreatorFullName))) {
4990 log.debug("Resource Creator fullname is automatically set and cannot be updated");
4993 String currentLastUpdaterUserId = currentResource.getLastUpdaterUserId();
4994 String updatedLastUpdaterUserId = updateInfoResource.getLastUpdaterUserId();
4996 if ((updatedLastUpdaterUserId != null) && (!updatedLastUpdaterUserId.equals(currentLastUpdaterUserId))) {
4997 log.debug("Resource LastUpdater userId is automatically set and cannot be updated");
5000 String currentLastUpdaterFullName = currentResource.getLastUpdaterFullName();
5001 String updatedLastUpdaterFullName = updateInfoResource.getLastUpdaterFullName();
5003 if ((updatedLastUpdaterFullName != null) && (!updatedLastUpdaterFullName.equals(currentLastUpdaterFullName))) {
5004 log.debug("Resource LastUpdater fullname is automatically set and cannot be updated");
5006 Long currentCreationDate = currentResource.getCreationDate();
5007 Long updatedCreationDate = updateInfoResource.getCreationDate();
5009 if ((updatedCreationDate != null) && (!updatedCreationDate.equals(currentCreationDate))) {
5010 log.debug("Resource Creation date is automatically set and cannot be updated");
5013 Long currentLastUpdateDate = currentResource.getLastUpdateDate();
5014 Long updatedLastUpdateDate = updateInfoResource.getLastUpdateDate();
5016 if ((updatedLastUpdateDate != null) && (!updatedLastUpdateDate.equals(currentLastUpdateDate))) {
5017 log.debug("Resource last update date is automatically set and cannot be updated");
5020 LifecycleStateEnum currentLifecycleState = currentResource.getLifecycleState();
5021 LifecycleStateEnum updatedLifecycleState = updateInfoResource.getLifecycleState();
5023 if ((updatedLifecycleState != null) && (!updatedLifecycleState.equals(currentLifecycleState))) {
5024 log.debug("Resource lifecycle state date is automatically set and cannot be updated");
5027 Boolean currentAbstract = currentResource.isAbstract();
5028 Boolean updatedAbstract = updateInfoResource.isAbstract();
5030 if ((updatedAbstract != null) && (!updatedAbstract.equals(currentAbstract))) {
5031 log.debug("Resource abstract is automatically set and cannot be updated");
5034 Boolean currentHighestVersion = currentResource.isHighestVersion();
5035 Boolean updatedHighestVersion = updateInfoResource.isHighestVersion();
5037 if ((updatedHighestVersion != null) && (!updatedHighestVersion.equals(currentHighestVersion))) {
5038 log.debug("Resource highest version is automatically set and cannot be updated");
5041 String currentUuid = currentResource.getUUID();
5042 String updatedUuid = updateInfoResource.getUUID();
5044 if ((updatedUuid != null) && (!updatedUuid.equals(currentUuid))) {
5045 log.debug("Resource UUID is automatically set and cannot be updated");
5048 log.debug("Resource Type cannot be updated");
5049 String currentInvariantUuid = currentResource.getInvariantUUID();
5050 String updatedInvariantUuid = updateInfoResource.getInvariantUUID();
5052 if ((updatedInvariantUuid != null) && (!updatedInvariantUuid.equals(currentInvariantUuid))) {
5053 log.debug("Resource invariant UUID is automatically set and cannot be updated");
5054 updateInfoResource.setInvariantUUID(currentInvariantUuid);
5058 private void validateFields(Resource currentResource, Resource updateInfoResource, boolean inTransaction,
5060 boolean hasBeenCertified = ValidationUtils.hasBeenCertified(currentResource.getVersion());
5061 log.debug("validate resource name before update");
5062 validateResourceName(currentResource, updateInfoResource, hasBeenCertified, isNested);
5063 log.debug("validate description before update");
5064 componentDescriptionValidator.validateAndCorrectField(null, updateInfoResource, null);
5065 log.debug("validate icon before update");
5066 validateIcon(currentResource, updateInfoResource, hasBeenCertified);
5067 log.debug("validate tags before update");
5068 componentTagsValidator.validateAndCorrectField(null, updateInfoResource, null);
5069 log.debug("validate vendor name before update");
5070 validateVendorName(null, updateInfoResource, null);
5071 log.debug("validate resource vendor model number before update");
5072 validateResourceVendorModelNumber(currentResource, updateInfoResource);
5073 log.debug("validate vendor release before update");
5074 validateVendorReleaseName(null, updateInfoResource, null);
5075 log.debug("validate contact info before update");
5076 componentContactIdValidator.validateAndCorrectField(null, updateInfoResource, null);
5077 log.debug(VALIDATE_DERIVED_BEFORE_UPDATE);
5078 validateDerivedFromDuringUpdate(currentResource, updateInfoResource, hasBeenCertified);
5079 log.debug("validate category before update");
5080 validateCategory(currentResource, updateInfoResource, hasBeenCertified, inTransaction);
5083 private boolean isResourceNameEquals(Resource currentResource, Resource updateInfoResource) {
5084 String resourceNameUpdated = updateInfoResource.getName();
5085 String resourceNameCurrent = currentResource.getName();
5086 if (resourceNameCurrent.equals(resourceNameUpdated)) {
5089 // In case of CVFC type we should support the case of old VF with CVFC
5090 // instances that were created without the "Cvfc" suffix
5091 return currentResource.getResourceType() == ResourceTypeEnum.CVFC
5092 && resourceNameUpdated.equals(addCvfcSuffixToResourceName(resourceNameCurrent));
5095 private String addCvfcSuffixToResourceName(String resourceName) {
5096 return resourceName + "Cvfc";
5099 private void validateResourceName(Resource currentResource, Resource updateInfoResource, boolean hasBeenCertified,
5101 String resourceNameUpdated = updateInfoResource.getName();
5102 if (!isResourceNameEquals(currentResource, updateInfoResource)) {
5103 if (isNested || !hasBeenCertified) {
5104 componentNameValidator.validateAndCorrectField(null, updateInfoResource, null);
5105 validateResourceNameUniqueness(updateInfoResource);
5106 currentResource.setName(resourceNameUpdated);
5107 currentResource.setNormalizedName(ValidationUtils.normaliseComponentName(resourceNameUpdated));
5108 currentResource.setSystemName(ValidationUtils.convertToSystemName(resourceNameUpdated));
5111 log.info("Resource name: {}, cannot be updated once the resource has been certified once.",
5112 resourceNameUpdated);
5113 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_NAME_CANNOT_BE_CHANGED);
5118 private void validateIcon(Resource currentResource, Resource updateInfoResource, boolean hasBeenCertified) {
5119 String iconUpdated = updateInfoResource.getIcon();
5120 String iconCurrent = currentResource.getIcon();
5121 if (!iconCurrent.equals(iconUpdated)) {
5122 if (!hasBeenCertified) {
5123 componentIconValidator.validateAndCorrectField(null, updateInfoResource, null);
5125 log.info("Icon {} cannot be updated once the resource has been certified once.", iconUpdated);
5126 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_ICON_CANNOT_BE_CHANGED);
5131 private void validateResourceVendorModelNumber(Resource currentResource, Resource updateInfoResource) {
5132 String updatedResourceVendorModelNumber = updateInfoResource.getResourceVendorModelNumber();
5133 String currentResourceVendorModelNumber = currentResource.getResourceVendorModelNumber();
5134 if (!currentResourceVendorModelNumber.equals(updatedResourceVendorModelNumber)) {
5135 validateResourceVendorModelNumber(null, updateInfoResource, null);
5139 private Either<Boolean, ResponseFormat> validateCategory(Resource currentResource, Resource updateInfoResource,
5140 boolean hasBeenCertified, boolean inTransaction) {
5141 validateCategory(null, updateInfoResource, null, inTransaction);
5142 if (hasBeenCertified) {
5143 CategoryDefinition currentCategory = currentResource.getCategories()
5145 SubCategoryDefinition currentSubCategory = currentCategory.getSubcategories()
5147 CategoryDefinition updateCategory = updateInfoResource.getCategories()
5149 SubCategoryDefinition updtaeSubCategory = updateCategory.getSubcategories()
5151 if (!currentCategory.getName()
5152 .equals(updateCategory.getName())
5153 || !currentSubCategory.getName()
5154 .equals(updtaeSubCategory.getName())) {
5155 log.info("Category {} cannot be updated once the resource has been certified once.",
5156 currentResource.getCategories());
5157 ResponseFormat errorResponse = componentsUtils
5158 .getResponseFormat(ActionStatus.RESOURCE_CATEGORY_CANNOT_BE_CHANGED);
5159 return Either.right(errorResponse);
5162 return Either.left(true);
5165 private Either<Boolean, ResponseFormat> validateDerivedFromDuringUpdate(Resource currentResource,
5166 Resource updateInfoResource, boolean hasBeenCertified) {
5168 List<String> currentDerivedFrom = currentResource.getDerivedFrom();
5169 List<String> updatedDerivedFrom = updateInfoResource.getDerivedFrom();
5170 if (currentDerivedFrom == null || currentDerivedFrom.isEmpty() || updatedDerivedFrom == null
5171 || updatedDerivedFrom.isEmpty()) {
5172 log.trace("Update normative types");
5173 return Either.left(true);
5176 String derivedFromCurrent = currentDerivedFrom.get(0);
5177 String derivedFromUpdated = updatedDerivedFrom.get(0);
5179 if (!derivedFromCurrent.equals(derivedFromUpdated)) {
5180 if (!hasBeenCertified) {
5181 validateDerivedFromExist(null, updateInfoResource, null);
5183 Either<Boolean, ResponseFormat> validateDerivedFromExtending = validateDerivedFromExtending(null,
5184 currentResource, updateInfoResource, null);
5186 if (validateDerivedFromExtending.isRight() || !validateDerivedFromExtending.left()
5188 log.debug("Derived from cannot be updated if it doesnt inherits directly or extends inheritance");
5189 return validateDerivedFromExtending;
5193 // For derived from, we must know whether it was actually changed,
5194 // otherwise we must do no action.
5195 // Due to changes it inflicts on data model (remove artifacts,
5196 // properties...), it's not like a flat field which can be
5197 // overwritten if not changed.
5198 // So we must indicate that derived from is not changed
5199 updateInfoResource.setDerivedFrom(null);
5201 return Either.left(true);
5204 private Either<Boolean, ResponseFormat> validateNestedDerivedFromDuringUpdate(Resource currentResource,
5205 Resource updateInfoResource, boolean hasBeenCertified) {
5207 List<String> currentDerivedFrom = currentResource.getDerivedFrom();
5208 List<String> updatedDerivedFrom = updateInfoResource.getDerivedFrom();
5209 if (currentDerivedFrom == null || currentDerivedFrom.isEmpty() || updatedDerivedFrom == null
5210 || updatedDerivedFrom.isEmpty()) {
5211 log.trace("Update normative types");
5212 return Either.left(true);
5215 String derivedFromCurrent = currentDerivedFrom.get(0);
5216 String derivedFromUpdated = updatedDerivedFrom.get(0);
5218 if (!derivedFromCurrent.equals(derivedFromUpdated)) {
5219 if (!hasBeenCertified) {
5220 validateDerivedFromExist(null, updateInfoResource, null);
5222 Either<Boolean, ResponseFormat> validateDerivedFromExtending = validateDerivedFromExtending(null,
5223 currentResource, updateInfoResource, null);
5225 if (validateDerivedFromExtending.isRight() || !validateDerivedFromExtending.left()
5227 log.debug("Derived from cannot be updated if it doesnt inherits directly or extends inheritance");
5228 return validateDerivedFromExtending;
5232 return Either.left(true);
5235 private void validateDerivedFromExist(User user, Resource resource, AuditingActionEnum actionEnum) {
5236 if (resource.getDerivedFrom() == null || resource.getDerivedFrom()
5240 String templateName = resource.getDerivedFrom()
5242 Either<Boolean, StorageOperationStatus> dataModelResponse = toscaOperationFacade
5243 .validateToscaResourceNameExists(templateName);
5244 if (dataModelResponse.isRight()) {
5245 StorageOperationStatus storageStatus = dataModelResponse.right()
5247 BeEcompErrorManager.getInstance()
5248 .logBeDaoSystemError("Create Resource - validateDerivedFromExist");
5249 log.debug("request to data model failed with error: {}", storageStatus);
5250 ResponseFormat responseFormat = componentsUtils
5251 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(storageStatus), resource);
5252 log.trace("audit before sending response");
5253 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5254 throw new ByActionStatusComponentException(componentsUtils.convertFromStorageResponse(storageStatus));
5255 } else if (!dataModelResponse.left()
5257 log.info("resource template with name: {}, does not exists", templateName);
5258 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.PARENT_RESOURCE_NOT_FOUND);
5259 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5260 throw new ByActionStatusComponentException(ActionStatus.PARENT_RESOURCE_NOT_FOUND);
5264 // Tal G for extending inheritance US815447
5265 private Either<Boolean, ResponseFormat> validateDerivedFromExtending(User user, Resource currentResource,
5266 Resource updateInfoResource, AuditingActionEnum actionEnum) {
5267 String currentTemplateName = currentResource.getDerivedFrom()
5269 String updatedTemplateName = updateInfoResource.getDerivedFrom()
5272 Either<Boolean, StorageOperationStatus> dataModelResponse = toscaOperationFacade
5273 .validateToscaResourceNameExtends(currentTemplateName, updatedTemplateName);
5274 if (dataModelResponse.isRight()) {
5275 StorageOperationStatus storageStatus = dataModelResponse.right()
5277 BeEcompErrorManager.getInstance()
5278 .logBeDaoSystemError("Create/Update Resource - validateDerivingFromExtendingType");
5279 ResponseFormat responseFormat = componentsUtils.getResponseFormatByResource(
5280 componentsUtils.convertFromStorageResponse(storageStatus), currentResource);
5281 log.trace("audit before sending response");
5282 componentsUtils.auditResource(responseFormat, user, currentResource, actionEnum);
5283 return Either.right(responseFormat);
5286 if (!dataModelResponse.left()
5288 log.info("resource template with name {} does not inherit as original {}", updatedTemplateName,
5289 currentTemplateName);
5290 ResponseFormat responseFormat = componentsUtils
5291 .getResponseFormat(ActionStatus.PARENT_RESOURCE_DOES_NOT_EXTEND);
5292 componentsUtils.auditResource(responseFormat, user, currentResource, actionEnum);
5294 return Either.right(responseFormat);
5297 return Either.left(true);
5300 public void validateDerivedFromNotEmpty(User user, Resource resource, AuditingActionEnum actionEnum) {
5301 log.debug("validate resource derivedFrom field");
5302 if ((resource.getDerivedFrom() == null) || (resource.getDerivedFrom()
5304 || (resource.getDerivedFrom()
5306 || (resource.getDerivedFrom()
5310 log.info("derived from (template) field is missing for the resource");
5311 ResponseFormat responseFormat = componentsUtils
5312 .getResponseFormat(ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
5313 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5315 throw new ByActionStatusComponentException(ActionStatus.MISSING_DERIVED_FROM_TEMPLATE);
5319 private void validateResourceNameUniqueness(Resource resource) {
5321 Either<Boolean, StorageOperationStatus> resourceOperationResponse = toscaOperationFacade
5322 .validateComponentNameExists(resource.getName(), resource.getResourceType(),
5323 resource.getComponentType());
5324 if (resourceOperationResponse.isLeft() && resourceOperationResponse.left()
5326 log.debug("resource with name: {}, already exists", resource.getName());
5327 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_NAME_ALREADY_EXIST,
5328 ComponentTypeEnum.RESOURCE.getValue(), resource.getName());
5329 } else if (resourceOperationResponse.isRight()) {
5330 log.debug("error while validateResourceNameExists for resource: {}", resource.getName());
5331 throw new StorageException(resourceOperationResponse.right()
5336 private void validateCategory(User user, Resource resource, AuditingActionEnum actionEnum, boolean inTransaction) {
5338 List<CategoryDefinition> categories = resource.getCategories();
5339 if (CollectionUtils.isEmpty(categories)) {
5340 log.debug(CATEGORY_IS_EMPTY);
5341 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_MISSING_CATEGORY,
5342 ComponentTypeEnum.RESOURCE.getValue());
5343 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5344 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_MISSING_CATEGORY,
5345 ComponentTypeEnum.RESOURCE.getValue());
5347 if (categories.size() > 1) {
5348 log.debug("Must be only one category for resource");
5349 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_TOO_MUCH_CATEGORIES,
5350 ComponentTypeEnum.RESOURCE.getValue());
5352 CategoryDefinition category = categories.get(0);
5353 List<SubCategoryDefinition> subcategories = category.getSubcategories();
5354 if (CollectionUtils.isEmpty(subcategories)) {
5355 log.debug("Missinig subcategory for resource");
5356 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_MISSING_SUBCATEGORY);
5358 if (subcategories.size() > 1) {
5359 log.debug("Must be only one sub category for resource");
5360 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_TOO_MUCH_SUBCATEGORIES);
5363 SubCategoryDefinition subcategory = subcategories.get(0);
5365 if (!ValidationUtils.validateStringNotEmpty(category.getName())) {
5366 log.debug(CATEGORY_IS_EMPTY);
5367 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_MISSING_CATEGORY,
5368 ComponentTypeEnum.RESOURCE.getValue());
5369 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5370 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_MISSING_CATEGORY,
5371 ComponentTypeEnum.RESOURCE.getValue());
5373 if (!ValidationUtils.validateStringNotEmpty(subcategory.getName())) {
5374 log.debug(CATEGORY_IS_EMPTY);
5375 ResponseFormat responseFormat = componentsUtils.getResponseFormat(
5376 ActionStatus.COMPONENT_MISSING_SUBCATEGORY, ComponentTypeEnum.RESOURCE.getValue());
5377 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5378 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_MISSING_SUBCATEGORY,
5379 ComponentTypeEnum.RESOURCE.getValue());
5382 validateCategoryListed(category, subcategory, user, resource, actionEnum, inTransaction);
5385 private void validateCategoryListed(CategoryDefinition category, SubCategoryDefinition subcategory, User user,
5386 Resource resource, AuditingActionEnum actionEnum, boolean inTransaction) {
5387 ResponseFormat responseFormat;
5388 if (category != null && subcategory != null) {
5389 log.debug("validating resource category {} against valid categories list", category);
5390 Either<List<CategoryDefinition>, ActionStatus> categories = elementDao
5391 .getAllCategories(NodeTypeEnum.ResourceNewCategory, inTransaction);
5392 if (categories.isRight()) {
5393 log.debug("failed to retrieve resource categories from JanusGraph");
5394 responseFormat = componentsUtils.getResponseFormat(categories.right()
5396 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5397 throw new ByActionStatusComponentException(categories.right()
5400 List<CategoryDefinition> categoryList = categories.left()
5402 Optional<CategoryDefinition> foundCategory = categoryList.stream()
5403 .filter(cat -> cat.getName()
5404 .equals(category.getName()))
5406 if (!foundCategory.isPresent()) {
5407 log.debug("Category {} is not part of resource category group. Resource category valid values are {}",
5408 category, categoryList);
5409 failOnInvalidCategory(user, resource, actionEnum);
5411 Optional<SubCategoryDefinition> foundSubcategory = foundCategory.get()
5414 .filter(subcat -> subcat.getName()
5415 .equals(subcategory.getName()))
5417 if (!foundSubcategory.isPresent()) {
5419 "SubCategory {} is not part of resource category group. Resource subcategory valid values are {}",
5420 subcategory, foundCategory.get()
5421 .getSubcategories());
5422 failOnInvalidCategory(user, resource, actionEnum);
5427 private void failOnInvalidCategory(User user, Resource resource, AuditingActionEnum actionEnum) {
5428 ResponseFormat responseFormat;
5429 responseFormat = componentsUtils.getResponseFormat(ActionStatus.COMPONENT_INVALID_CATEGORY,
5430 ComponentTypeEnum.RESOURCE.getValue());
5431 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5432 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_INVALID_CATEGORY, ComponentTypeEnum.RESOURCE.getValue());
5435 public void validateVendorReleaseName(User user, Resource resource, AuditingActionEnum actionEnum) {
5436 String vendorRelease = resource.getVendorRelease();
5437 log.debug("validate vendor relese name");
5438 if (!ValidationUtils.validateStringNotEmpty(vendorRelease)) {
5439 log.info("vendor relese name is missing.");
5440 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_VENDOR_RELEASE);
5441 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5442 throw new ByActionStatusComponentException(ActionStatus.MISSING_VENDOR_RELEASE);
5445 validateVendorReleaseName(vendorRelease, user, resource, actionEnum);
5448 public void validateVendorReleaseName(String vendorRelease, User user, Resource resource,
5449 AuditingActionEnum actionEnum) {
5450 if (vendorRelease != null) {
5451 if (!ValidationUtils.validateVendorReleaseLength(vendorRelease)) {
5452 log.info("vendor release exceds limit.");
5453 ResponseFormat errorResponse = componentsUtils.getResponseFormat(
5454 ActionStatus.VENDOR_RELEASE_EXCEEDS_LIMIT, "" + ValidationUtils.VENDOR_RELEASE_MAX_LENGTH);
5455 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5456 throw new ByActionStatusComponentException(ActionStatus.VENDOR_RELEASE_EXCEEDS_LIMIT,
5457 "" + ValidationUtils.VENDOR_RELEASE_MAX_LENGTH);
5460 if (!ValidationUtils.validateVendorRelease(vendorRelease)) {
5461 log.info("vendor release is not valid.");
5462 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.INVALID_VENDOR_RELEASE);
5463 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5464 throw new ByActionStatusComponentException(ActionStatus.INVALID_VENDOR_RELEASE, vendorRelease);
5469 private void validateVendorName(User user, Resource resource,
5470 AuditingActionEnum actionEnum) {
5471 String vendorName = resource.getVendorName();
5472 if (!ValidationUtils.validateStringNotEmpty(vendorName)) {
5473 log.info("vendor name is missing.");
5474 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.MISSING_VENDOR_NAME);
5475 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5476 throw new ByActionStatusComponentException(ActionStatus.MISSING_VENDOR_NAME);
5478 validateVendorName(vendorName, user, resource, actionEnum);
5481 private void validateVendorName(String vendorName, User user, Resource resource,
5482 AuditingActionEnum actionEnum) {
5483 if (vendorName != null) {
5484 if (!ValidationUtils.validateVendorNameLength(vendorName)) {
5485 log.info("vendor name exceds limit.");
5486 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.VENDOR_NAME_EXCEEDS_LIMIT,
5487 "" + ValidationUtils.VENDOR_NAME_MAX_LENGTH);
5488 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5489 throw new ByActionStatusComponentException(ActionStatus.VENDOR_NAME_EXCEEDS_LIMIT,
5490 "" + ValidationUtils.VENDOR_NAME_MAX_LENGTH);
5493 if (!ValidationUtils.validateVendorName(vendorName)) {
5494 log.info("vendor name is not valid.");
5495 ResponseFormat errorResponse = componentsUtils.getResponseFormat(ActionStatus.INVALID_VENDOR_NAME);
5496 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5497 throw new ByActionStatusComponentException(ActionStatus.INVALID_VENDOR_NAME, vendorName);
5502 private void validateResourceVendorModelNumber(User user, Resource resource, AuditingActionEnum actionEnum) {
5503 String resourceVendorModelNumber = resource.getResourceVendorModelNumber();
5504 if (StringUtils.isNotEmpty(resourceVendorModelNumber)) {
5505 if (!ValidationUtils.validateResourceVendorModelNumberLength(resourceVendorModelNumber)) {
5506 log.info("resource vendor model number exceeds limit.");
5507 ResponseFormat errorResponse = componentsUtils.getResponseFormat(
5508 ActionStatus.RESOURCE_VENDOR_MODEL_NUMBER_EXCEEDS_LIMIT,
5509 "" + ValidationUtils.RESOURCE_VENDOR_MODEL_NUMBER_MAX_LENGTH);
5510 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5511 throw new ByActionStatusComponentException(ActionStatus.RESOURCE_VENDOR_MODEL_NUMBER_EXCEEDS_LIMIT,
5512 "" + ValidationUtils.RESOURCE_VENDOR_MODEL_NUMBER_MAX_LENGTH);
5514 // resource vendor model number is currently validated as vendor
5516 if (!ValidationUtils.validateVendorName(resourceVendorModelNumber)) {
5517 log.info("resource vendor model number is not valid.");
5518 ResponseFormat errorResponse = componentsUtils
5519 .getResponseFormat(ActionStatus.INVALID_RESOURCE_VENDOR_MODEL_NUMBER);
5520 componentsUtils.auditResource(errorResponse, user, resource, actionEnum);
5521 throw new ByActionStatusComponentException(ActionStatus.INVALID_RESOURCE_VENDOR_MODEL_NUMBER);
5527 private void validateCost(Resource resource) {
5528 String cost = resource.getCost();
5530 if (!ValidationUtils.validateCost(cost)) {
5531 log.debug("resource cost is invalid.");
5532 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
5537 private void validateLicenseType(User user, Resource resource,
5538 AuditingActionEnum actionEnum) {
5539 log.debug("validate licenseType");
5540 String licenseType = resource.getLicenseType();
5541 if (licenseType != null) {
5542 List<String> licenseTypes = ConfigurationManager.getConfigurationManager().getConfiguration()
5544 if (!licenseTypes.contains(licenseType)) {
5545 log.debug("License type {} isn't configured", licenseType);
5546 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_CONTENT);
5547 if (actionEnum != null) {
5548 // In update case, no audit is required
5549 componentsUtils.auditResource(responseFormat, user, resource, actionEnum);
5551 throw new ByActionStatusComponentException(ActionStatus.INVALID_CONTENT);
5556 private Either<Boolean, ResponseFormat> processUpdateOfDerivedFrom(Resource currentResource,
5557 Resource updatedResource, String userId, boolean inTransaction) {
5558 if (updatedResource.getDerivedFrom() != null) {
5559 log.debug("Starting derived from update for resource {}", updatedResource.getUniqueId());
5560 log.debug("1. Removing interface artifacts from graph");
5561 // Remove all interface artifacts of resource
5562 String resourceId = updatedResource.getUniqueId();
5563 Map<String, InterfaceDefinition> interfaces = currentResource.getInterfaces();
5565 if (interfaces != null) {
5566 Collection<InterfaceDefinition> values = interfaces.values();
5567 for (InterfaceDefinition interfaceDefinition : values) {
5568 String interfaceType = interfaceTypeOperation.getShortInterfaceName(interfaceDefinition);
5570 log.trace("Starting interface artifacts removal for interface type {}", interfaceType);
5571 Map<String, Operation> operations = interfaceDefinition.getOperationsMap();
5572 if (operations != null) {
5573 for (Entry<String, Operation> operationEntry : operations.entrySet()) {
5574 Operation operation = operationEntry.getValue();
5575 ArtifactDefinition implementation = operation.getImplementationArtifact();
5576 if (implementation != null) {
5577 String uniqueId = implementation.getUniqueId();
5578 log.debug("Removing interface artifact definition {}, operation {}, interfaceType {}",
5579 uniqueId, operationEntry.getKey(), interfaceType);
5580 // only thing that transacts and locks here
5581 Either<ArtifactDefinition, ResponseFormat> deleteArtifactByInterface =
5582 artifactsBusinessLogic.deleteArtifactByInterface(resourceId, userId, uniqueId, true);
5583 if (deleteArtifactByInterface.isRight()) {
5584 log.debug("Couldn't remove artifact definition with id {}", uniqueId);
5585 if (!inTransaction) {
5586 janusGraphDao.rollback();
5588 return Either.right(deleteArtifactByInterface.right()
5592 log.trace("No implementation found for operation {} - nothing to delete",
5593 operationEntry.getKey());
5597 log.trace("No operations found for interface type {}", interfaceType);
5601 log.debug("2. Removing properties");
5602 Either<Map<String, PropertyDefinition>, StorageOperationStatus> findPropertiesOfNode = propertyOperation
5603 .deleteAllPropertiesAssociatedToNode(NodeTypeEnum.Resource, resourceId);
5605 if (findPropertiesOfNode.isRight() && findPropertiesOfNode.right().value() != StorageOperationStatus.OK) {
5606 log.debug("Failed to remove all properties of resource");
5607 if (!inTransaction) {
5608 janusGraphDao.rollback();
5610 return Either.right(componentsUtils
5611 .getResponseFormat(componentsUtils.convertFromStorageResponse(findPropertiesOfNode.right()
5616 log.debug("Derived from wasn't changed during update");
5619 if (inTransaction) {
5620 return Either.left(true);
5622 janusGraphDao.commit();
5623 return Either.left(true);
5627 /**** Auditing *******************/
5629 protected static IElementOperation getElementDao(Class<IElementOperation> class1, ServletContext context) {
5630 WebAppContextWrapper webApplicationContextWrapper = (WebAppContextWrapper) context
5631 .getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR);
5633 WebApplicationContext webApplicationContext = webApplicationContextWrapper.getWebAppContext(context);
5635 return webApplicationContext.getBean(class1);
5638 public ICapabilityTypeOperation getCapabilityTypeOperation() {
5639 return capabilityTypeOperation;
5643 public void setCapabilityTypeOperation(ICapabilityTypeOperation capabilityTypeOperation) {
5644 this.capabilityTypeOperation = capabilityTypeOperation;
5647 public Boolean validatePropertiesDefaultValues(Resource resource) {
5648 log.debug("validate resource properties default values");
5649 List<PropertyDefinition> properties = resource.getProperties();
5650 if (properties != null) {
5651 iterateOverProperties(properties);
5656 public void iterateOverProperties(List<PropertyDefinition> properties) {
5658 String innerType = null;
5659 for (PropertyDefinition property : properties) {
5660 if (!propertyOperation.isPropertyTypeValid(property)) {
5661 log.info("Invalid type for property {}", property);
5662 throw new ByActionStatusComponentException(ActionStatus.INVALID_PROPERTY_TYPE,
5663 property.getType(), property.getName());
5666 Map<String, DataTypeDefinition> allDataTypes = getAllDataTypes(applicationDataTypeCache);
5667 type = property.getType();
5669 if (type.equals(ToscaPropertyType.LIST.getType()) || type.equals(ToscaPropertyType.MAP.getType())) {
5670 ResponseFormat responseFormat = validateMapOrListPropertyType(property, innerType, allDataTypes);
5671 if (responseFormat != null) {
5675 validateDefaultPropertyValue(property, allDataTypes, type, innerType);
5679 private void validateDefaultPropertyValue(PropertyDefinition property,
5680 Map<String, DataTypeDefinition> allDataTypes, String type, String innerType) {
5681 if (!propertyOperation.isPropertyDefaultValueValid(property, allDataTypes)) {
5682 log.info("Invalid default value for property {}", property);
5683 ResponseFormat responseFormat;
5684 if (type.equals(ToscaPropertyType.LIST.getType()) || type.equals(ToscaPropertyType.MAP.getType())) {
5685 throw new ByActionStatusComponentException(ActionStatus.INVALID_COMPLEX_DEFAULT_VALUE,
5686 property.getName(), type, innerType, property.getDefaultValue());
5688 throw new ByActionStatusComponentException(ActionStatus.INVALID_DEFAULT_VALUE,
5689 property.getName(), type, property.getDefaultValue());
5693 private ResponseFormat validateMapOrListPropertyType(PropertyDefinition property, String innerType,
5694 Map<String, DataTypeDefinition> allDataTypes) {
5695 ResponseFormat responseFormat = null;
5696 ImmutablePair<String, Boolean> propertyInnerTypeValid = propertyOperation.isPropertyInnerTypeValid(property,
5698 innerType = propertyInnerTypeValid.getLeft();
5699 if (!propertyInnerTypeValid.getRight()
5701 log.info("Invalid inner type for property {}", property);
5702 responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_PROPERTY_INNER_TYPE, innerType,
5703 property.getName());
5705 return responseFormat;
5709 public Either<List<String>, ResponseFormat> deleteMarkedComponents() {
5710 return deleteMarkedComponents(ComponentTypeEnum.RESOURCE);
5714 public ComponentInstanceBusinessLogic getComponentInstanceBL() {
5715 return componentInstanceBusinessLogic;
5718 private String getComponentTypeForResponse(Component component) {
5719 String componentTypeForResponse = "SERVICE";
5720 if (component instanceof Resource) {
5721 componentTypeForResponse = ((Resource) component).getResourceType()
5724 return componentTypeForResponse;
5727 public Either<Resource, ResponseFormat> getLatestResourceFromCsarUuid(String csarUuid, User user) {
5730 validateUserExists(user);
5732 // get resource from csar uuid
5733 Either<Resource, StorageOperationStatus> either = toscaOperationFacade
5734 .getLatestComponentByCsarOrName(ComponentTypeEnum.RESOURCE, csarUuid, "");
5735 if (either.isRight()) {
5736 ResponseFormat resp = componentsUtils.getResponseFormat(ActionStatus.RESOURCE_FROM_CSAR_NOT_FOUND,
5738 return Either.right(resp);
5741 return Either.left(either.left()
5746 public Either<List<ComponentInstance>, ResponseFormat> getComponentInstancesFilteredByPropertiesAndInputs(
5747 String componentId, String userId) {
5751 private Map<String, List<CapabilityDefinition>> getValidComponentInstanceCapabilities(String resourceId,
5752 Map<String, List<CapabilityDefinition>> defaultCapabilities,
5753 Map<String, List<UploadCapInfo>> uploadedCapabilities) {
5755 Map<String, List<CapabilityDefinition>> validCapabilitiesMap = new HashMap<>();
5756 uploadedCapabilities.forEach((k, v) -> addValidComponentInstanceCapabilities(k, v, resourceId,
5757 defaultCapabilities, validCapabilitiesMap));
5758 return validCapabilitiesMap;
5761 private void addValidComponentInstanceCapabilities(String key, List<UploadCapInfo> capabilities, String resourceId,
5762 Map<String, List<CapabilityDefinition>> defaultCapabilities,
5763 Map<String, List<CapabilityDefinition>> validCapabilitiesMap) {
5764 String capabilityType = capabilities.get(0)
5766 if (defaultCapabilities.containsKey(capabilityType)) {
5767 CapabilityDefinition defaultCapability = getCapability(resourceId, defaultCapabilities, capabilityType);
5768 validateCapabilityProperties(capabilities, resourceId, defaultCapability);
5769 List<CapabilityDefinition> validCapabilityList = new ArrayList<>();
5770 validCapabilityList.add(defaultCapability);
5771 validCapabilitiesMap.put(key, validCapabilityList);
5773 throw new ByActionStatusComponentException(ActionStatus.MISSING_CAPABILITY_TYPE, capabilityType);
5777 private void validateCapabilityProperties(List<UploadCapInfo> capabilities, String resourceId,
5778 CapabilityDefinition defaultCapability) {
5779 if (CollectionUtils.isEmpty(defaultCapability.getProperties()) && isNotEmpty(capabilities.get(0)
5780 .getProperties())) {
5781 log.debug("Failed to validate capability {} of component {}. Property list is empty. ",
5782 defaultCapability.getName(), resourceId);
5783 log.debug("Failed to update capability property values. Property list of fetched capability {} is empty. ",
5784 defaultCapability.getName());
5785 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NOT_FOUND, resourceId);
5786 } else if (isNotEmpty(capabilities.get(0)
5787 .getProperties())) {
5788 validateUniquenessUpdateUploadedComponentInstanceCapability(defaultCapability, capabilities.get(0));
5792 private CapabilityDefinition getCapability(String resourceId,
5793 Map<String, List<CapabilityDefinition>> defaultCapabilities, String capabilityType) {
5794 CapabilityDefinition defaultCapability;
5795 if (isNotEmpty(defaultCapabilities.get(capabilityType)
5797 .getProperties())) {
5798 defaultCapability = defaultCapabilities.get(capabilityType)
5801 Either<Component, StorageOperationStatus> getFullComponentRes = toscaOperationFacade
5802 .getToscaFullElement(resourceId);
5803 if (getFullComponentRes.isRight()) {
5804 log.debug("Failed to get full component {}. Status is {}. ", resourceId, getFullComponentRes.right()
5806 throw new ByActionStatusComponentException(ActionStatus.COMPONENT_NOT_FOUND, resourceId);
5808 defaultCapability = getFullComponentRes.left()
5811 .get(capabilityType)
5814 return defaultCapability;
5817 private void validateUniquenessUpdateUploadedComponentInstanceCapability(CapabilityDefinition defaultCapability,
5818 UploadCapInfo uploadedCapability) {
5819 List<ComponentInstanceProperty> validProperties = new ArrayList<>();
5820 Map<String, PropertyDefinition> defaultProperties = defaultCapability.getProperties()
5822 .collect(toMap(PropertyDefinition::getName, Function.identity()));
5823 List<UploadPropInfo> uploadedProperties = uploadedCapability.getProperties();
5824 for (UploadPropInfo property : uploadedProperties) {
5825 String propertyName = property.getName()
5827 String propertyType = property.getType();
5828 ComponentInstanceProperty validProperty;
5829 if (defaultProperties.containsKey(propertyName)
5830 && propertTypeEqualsTo(defaultProperties, propertyName, propertyType)) {
5831 throw new ByActionStatusComponentException(ActionStatus.PROPERTY_NAME_ALREADY_EXISTS, propertyName);
5833 validProperty = new ComponentInstanceProperty();
5834 validProperty.setName(propertyName);
5835 if (property.getValue() != null) {
5836 validProperty.setValue(property.getValue()
5839 validProperty.setDescription(property.getDescription());
5840 validProperty.setPassword(property.isPassword());
5841 validProperties.add(validProperty);
5843 defaultCapability.setProperties(validProperties);
5846 private boolean propertTypeEqualsTo(Map<String, PropertyDefinition> defaultProperties, String propertyName,
5847 String propertyType) {
5848 return propertyType != null && !defaultProperties.get(propertyName)
5850 .equals(propertyType);
5853 private Either<EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>>, ResponseFormat> organizeVfCsarArtifactsByArtifactOperation(
5854 List<NonMetaArtifactInfo> artifactPathAndNameList, List<ArtifactDefinition> existingArtifactsToHandle,
5855 Resource resource, User user) {
5857 EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>> nodeTypeArtifactsToHandle = new EnumMap<>(
5858 ArtifactOperationEnum.class);
5859 Wrapper<ResponseFormat> responseWrapper = new Wrapper<>();
5860 Either<EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>>, ResponseFormat> nodeTypeArtifactsToHandleRes = Either
5861 .left(nodeTypeArtifactsToHandle);
5863 // add all found Csar artifacts to list to upload
5864 List<NonMetaArtifactInfo> artifactsToUpload = new ArrayList<>(artifactPathAndNameList);
5865 List<NonMetaArtifactInfo> artifactsToUpdate = new ArrayList<>();
5866 List<NonMetaArtifactInfo> artifactsToDelete = new ArrayList<>();
5867 for (NonMetaArtifactInfo currNewArtifact : artifactPathAndNameList) {
5868 ArtifactDefinition foundArtifact;
5870 if (!existingArtifactsToHandle.isEmpty()) {
5871 foundArtifact = existingArtifactsToHandle.stream()
5872 .filter(a -> a.getArtifactName()
5873 .equals(currNewArtifact.getArtifactName()))
5876 if (foundArtifact != null) {
5877 if (foundArtifact.getArtifactType().equals(currNewArtifact.getArtifactType())) {
5878 if (!foundArtifact.getArtifactChecksum()
5879 .equals(currNewArtifact.getArtifactChecksum())) {
5880 currNewArtifact.setArtifactUniqueId(foundArtifact.getUniqueId());
5881 // if current artifact already exists, but has
5882 // different content, add him to the list to
5884 artifactsToUpdate.add(currNewArtifact);
5886 // remove found artifact from the list of existing
5887 // artifacts to handle, because it was already
5889 existingArtifactsToHandle.remove(foundArtifact);
5890 // and remove found artifact from the list to
5891 // upload, because it should either be updated or be
5893 artifactsToUpload.remove(currNewArtifact);
5895 log.debug("Can't upload two artifact with the same name {}.",
5896 currNewArtifact.getArtifactName());
5897 ResponseFormat responseFormat = ResponseFormatManager.getInstance()
5898 .getResponseFormat(ActionStatus.ARTIFACT_ALREADY_EXIST_IN_DIFFERENT_TYPE_IN_CSAR,
5899 currNewArtifact.getArtifactName(), currNewArtifact.getArtifactType(),
5900 foundArtifact.getArtifactType());
5901 AuditingActionEnum auditingAction = artifactsBusinessLogic
5902 .detectAuditingType(new ArtifactOperationInfo(false, false,
5903 ArtifactOperationEnum.CREATE), foundArtifact.getArtifactChecksum());
5904 artifactsBusinessLogic.handleAuditing(auditingAction, resource, resource.getUniqueId(),
5905 user, null, null, foundArtifact.getUniqueId(), responseFormat,
5906 resource.getComponentType(), null);
5907 responseWrapper.setInnerElement(responseFormat);
5913 if (responseWrapper.isEmpty()) {
5914 for (ArtifactDefinition currArtifact : existingArtifactsToHandle) {
5915 if (currArtifact.getIsFromCsar()) {
5916 artifactsToDelete.add(new NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
5917 currArtifact.getArtifactType(),
5918 currArtifact.getArtifactGroupType(), null, currArtifact.getUniqueId(),
5919 currArtifact.getIsFromCsar()));
5921 artifactsToUpdate.add(new NonMetaArtifactInfo(currArtifact.getArtifactName(), null,
5922 currArtifact.getArtifactType(),
5923 currArtifact.getArtifactGroupType(), null, currArtifact.getUniqueId(),
5924 currArtifact.getIsFromCsar()));
5929 if (responseWrapper.isEmpty()) {
5930 if (!artifactsToUpload.isEmpty()) {
5931 nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.CREATE, artifactsToUpload);
5933 if (!artifactsToUpdate.isEmpty()) {
5934 nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.UPDATE, artifactsToUpdate);
5936 if (!artifactsToDelete.isEmpty()) {
5937 nodeTypeArtifactsToHandle.put(ArtifactOperationEnum.DELETE, artifactsToDelete);
5940 if (!responseWrapper.isEmpty()) {
5941 nodeTypeArtifactsToHandleRes = Either.right(responseWrapper.getInnerElement());
5943 } catch (Exception e) {
5944 ResponseFormat responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
5945 responseWrapper.setInnerElement(responseFormat);
5946 log.debug("Exception occurred when findNodeTypeArtifactsToHandle, error is:{}", e.getMessage(), e);
5948 return nodeTypeArtifactsToHandleRes;
5951 ImmutablePair<String, String> buildNestedToscaResourceName(final String nodeResourceType,
5952 final String vfResourceName,
5953 final String nodeTypeFullName) {
5955 String actualVfName;
5956 if (ResourceTypeEnum.CVFC.name()
5957 .equals(nodeResourceType)) {
5958 actualVfName = vfResourceName + ResourceTypeEnum.CVFC.name();
5959 actualType = ResourceTypeEnum.VFC.name();
5961 actualVfName = vfResourceName;
5962 actualType = nodeResourceType;
5964 String nameWithouNamespacePrefix;
5966 final String nodeTypeNamePrefix = getNodeTypeNamePrefix(nodeTypeFullName);
5967 log.debug("####### buildNestedToscaResourceName nodeResourceType {}, vfResourceName {}, "
5968 + "nodeTypeFullName {}, actualType {}, vfResourceName {} ", nodeResourceType, vfResourceName,
5969 nodeTypeFullName, actualType, vfResourceName);
5970 final StringBuilder toscaResourceName = new StringBuilder(nodeTypeNamePrefix);
5972 if (!nodeTypeFullName.contains(nodeTypeNamePrefix)) {
5973 nameWithouNamespacePrefix = nodeTypeFullName;
5975 nameWithouNamespacePrefix = nodeTypeFullName.substring(nodeTypeNamePrefix.length());
5977 final String[] findTypes = nameWithouNamespacePrefix.split("\\.");
5979 if (nodeResourceType.equalsIgnoreCase(findTypes[0])){
5980 actualName = nameWithouNamespacePrefix.substring(nodeResourceType.length());
5982 actualName = "." + nameWithouNamespacePrefix;
5985 if (actualName.startsWith(Constants.ABSTRACT)) {
5986 toscaResourceName.append(nodeResourceType.toLowerCase()).append('.')
5987 .append(ValidationUtils.convertToSystemName(actualVfName));
5989 toscaResourceName.append(actualType.toLowerCase()).append('.')
5990 .append(ValidationUtils.convertToSystemName(actualVfName)).append('.').append(Constants.ABSTRACT);
5992 final StringBuilder previousToscaResourceName = new StringBuilder(toscaResourceName);
5993 final String[] actualNames = actualName.split("\\.");
5994 if (actualNames.length < 3) {
5995 return new ImmutablePair<>(toscaResourceName.append(actualName.toLowerCase()).toString(),
5996 previousToscaResourceName.append(actualName).toString());
5998 return new ImmutablePair<>(toscaResourceName.append(actualName.toLowerCase()).toString(),
5999 previousToscaResourceName.append(actualName.substring(actualNames[1].length() + 1)
6000 .toLowerCase()).toString());
6001 } catch (final Exception e) {
6002 log.debug("Exception occured when buildNestedToscaResourceName, error is:{}", e.getMessage(), e);
6003 throw new ByActionStatusComponentException(ActionStatus.INVALID_TOSCA_TEMPLATE, vfResourceName);
6008 * Extracts a Node Type Name prefix from the given Node Type Name.
6010 * @param fullName Node Type Name
6011 * @return Node Type Name Prefix
6013 private String getNodeTypeNamePrefix(final String fullName) {
6014 String tempPrefix = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX;
6015 final List<String> definedNodeTypeNamespaceList = getDefinedNodeTypeNamespaceList();
6016 log.debug("************* getPrefiX fullName {} FROM {}", fullName, definedNodeTypeNamespaceList);
6017 final Optional<String> validNameSpace = validateNodeTypeNamePrefix(fullName, definedNodeTypeNamespaceList);
6018 if (validNameSpace.isPresent()) {
6019 tempPrefix = validNameSpace.get();
6021 log.debug("************* getNodeTypeNamePrefix return fullName {} ", tempPrefix);
6026 public Either<UiComponentDataTransfer, ResponseFormat> getUiComponentDataTransferByComponentId(String resourceId,
6027 List<String> dataParamsToReturn) {
6029 ComponentParametersView paramsToRetuen = new ComponentParametersView(dataParamsToReturn);
6030 Either<Resource, StorageOperationStatus> resourceResultEither =
6031 toscaOperationFacade.getToscaElement(resourceId,
6034 if (resourceResultEither.isRight()) {
6035 if (resourceResultEither.right().value() == StorageOperationStatus.NOT_FOUND) {
6036 log.debug("Failed to found resource with id {} ", resourceId);
6038 .right(componentsUtils.getResponseFormat(ActionStatus.RESOURCE_NOT_FOUND, resourceId));
6041 log.debug("failed to get resource by id {} with filters {}", resourceId, dataParamsToReturn);
6042 return Either.right(componentsUtils
6043 .getResponseFormatByResource(componentsUtils.convertFromStorageResponse(resourceResultEither.right()
6047 Resource resource = resourceResultEither.left().value();
6048 if (dataParamsToReturn.contains(ComponentFieldsEnum.INPUTS.getValue())) {
6049 ListUtils.emptyIfNull(resource.getInputs())
6050 .forEach(input -> input.setConstraints(setInputConstraint(input)));
6053 UiComponentDataTransfer dataTransfer = uiComponentDataConverter.getUiDataTransferFromResourceByParams(resource,
6054 dataParamsToReturn);
6055 return Either.left(dataTransfer);
6059 public Either<Component, ActionStatus> shouldUpgradeToLatestDerived(Component clonedComponent) {
6060 Resource resource = (Resource) clonedComponent;
6061 if (ModelConverter.isAtomicComponent(resource.getResourceType())) {
6062 Either<Component, StorageOperationStatus> shouldUpgradeToLatestDerived = toscaOperationFacade
6063 .shouldUpgradeToLatestDerived(resource);
6064 if (shouldUpgradeToLatestDerived.isRight()) {
6065 return Either.right(componentsUtils.convertFromStorageResponse(shouldUpgradeToLatestDerived.right()
6068 return Either.left(shouldUpgradeToLatestDerived.left()
6071 return super.shouldUpgradeToLatestDerived(clonedComponent);